Add a generator for the sorted substitution table.

src/cipher_analytical_machine/ciphers/simple_substitution.clj

@@ -1,6 +1,5 @@
 (ns cipher-analytical-machine.ciphers.simple-substitution
   (:require [clojure.string :as cs]
-            [clojure.set :as set]
             [cipher-analytical-machine.ciphers.caesar :as caesar])
   (:gen-class))
 
@@ -18,30 +17,47 @@
        (shuffled-numbers)
        (zipmap symbols)))
 
+(defn generate-sorted-substitution-table
+  "Generate the map (char, int) for the substittion. BUT a value is the index of a symbol (from 0)."
+  [symbols]
+  (-> (count symbols)
+      (take (range))
+      (zipmap symbols)))
+
 (defn find-value-in-table
   "It uses the substitution table to find the value of a char or a number."
-  [char substitution-table symbols]
+  [char substitution-table]
   (get substitution-table char))
 
 (defn encrypt-message
   "Encrypt a message using the simple substitution cipher. The function is case-insensitive. If a symbol isn't in the symbols list, then it will be removed."
+  [message substitution-table]
+  (->> message
+       (map (fn [char] (find-value-in-table char substitution-table)))
+       (remove nil?)
+       (cs/join \,)))
+
+(defn encrypt-message-with-caesar
+  "Encrypt a message using the simple substitution cipher and the Caesar cipher. The function is case-insensitive. If a symbol isn't in the symbols list, then it will be removed."
   [message key substitution-table symbols]
-  (let [max-index (count symbols)]
+  (-> message
-    (->> message
+      (caesar/encrypt-message key symbols)
-         (cs/lower-case)
+      (encrypt-message substitution-table)))
-         (caesar/encrypt-message key symbols)
-         (map (fn [char] (find-value-in-table char substitution-table symbols)))
-         (cs/join \,))))
 
 (defn decrypt-message
-  "Decrypt a message using the simple substitution cipher. The function is case-insensitive."
+  "Decrypt a message using the simple substitution cipher. The function is case-insensitive. The substitution-table must be "
+  [message substitution-table]
+  (let [message (cs/split message #",")]
+    (->> message
+         (map #(Integer/parseInt %))
+         (map (fn [char] (find-value-in-table char substitution-table)))
+         (remove nil?)
+         (cs/join))))
+
+(defn decrypt-message-with-caesar
+  "Decrypt a message using the simple substitution cipher and the Caesar cipher. The function is case-insensitive."
   [message key substitution-table symbols]
-  (let [substitution-table (set/map-invert substitution-table)
+  (-> message
-        max-index (count symbols)
+      (decrypt-message substitution-table)
-        message (cs/split message #",")]
+      (caesar/decrypt-message key symbols)))
-      (->> message
-           (map #(Integer/parseInt %))
-           (map (fn [char] (find-value-in-table char substitution-table symbols)))
-           (caesar/encrypt-message key symbols)
-           (cs/join))))
 

test/cipher_analytical_machine/ciphers/simple_substitution_test.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.ciphers.simple-substitution
+(ns cipher-analytical-machine.ciphers.simple-substitution-test
   (:require
    [clojure.test :refer :all]
    [cipher-analytical-machine.ciphers.simple-substitution :refer :all]))
@@ -22,22 +22,46 @@
         1 \a
         5 nil))))
 
-(deftest encrypt-message-text
+(deftest generate-sorted-substitution-table-test
+  (testing "If the symbol is in the table as a key, then the result won't nil."
+    (are [symbols expected-table]
+        (= expected-table (generate-sorted-substitution-table symbols))
+      "abc" {0 \a 1 \b 2 \c}
+      "a" {0 \a})))
+
+(deftest encrypt-message-test
+  (let [symbols "abc"
+        table {\a 1 \b 2 \c 3}]
+    (testing "The function must encrypt the message and remove unknown symbols."
+      (are [message expected]
+          (= expected (encrypt-message message table))
+        "abc" "1,2,3"
+        "aDbdc" "1,2,3"))))
+
+(deftest encrypt-message-with-caesar-test
   (let [symbols "abc"
         table {\a 1 \b 2 \c 3}]
     (testing "The function must encrypt the message and remove unknown symbols."
       (are [message key expected]
-          (= expected (encrypt-message message key table symbols))
+          (= expected (encrypt-message-with-caesar message key table symbols))
         "abc" 0 "1,2,3"
         "abc" 1 "2,3,1"
         "aDbdc" 0 "1,2,3"))))
 
-(deftest decrypt-message-text
+(deftest decrypt-message-test
+  (let [table {1 \a 2 \b 3 \c}]
+    (testing "The function must decrypt the message and remove unknown numbers."
+      (are [message expected]
+          (= expected (decrypt-message message table))
+        "1,2,3" "abc"
+        "1,12,2,3" "abc"))))
+
+(deftest decrypt-message-with-caesar-test
   (let [symbols "abc"
-        table {\a 1 \b 2 \c 3}]
+        table {1 \a 2 \b 3 \c}]
     (testing "The function must decrypt the message and remove unknown numbers."
       (are [message key expected]
-          (= expected (decrypt-message message key table symbols))
+          (= expected (decrypt-message-with-caesar message key table symbols))
         "1,2,3" 0 "abc"
         "2,3,1" 1 "abc"
         "1,12,2,3" 0 "abc"))))