Add the main for the cli module.

src/cipher_analytical_machine/analyzers/analyzers.clj

@@ -36,3 +36,22 @@
             0
             letter-counts)))
 
+(defn sort-map-by-count
+  "Return a list of pairs from a map of pairs where a pair is a character and its count. The order is descending."
+  [count-map]
+  (->> count-map
+       (reduce (fn [acc [char count]] (conj acc [char count])) [])
+       (sort-by #(- (second %)))))
+
+(defn table-to-string
+  "Return the string from a frequency table."
+  [table]
+  (->> (map first table)
+       (apply str)))
+
+(defn symbol-frequency-table
+  "Return a table where pairs is a symbol from a cipher text and its value which is a symbol from frequency table."
+  [cipher-table frequency-table]
+  (zipmap (table-to-string (sort-map-by-count cipher-table))
+          (table-to-string (sort-map-by-count frequency-table))))
+

src/cipher_analytical_machine/ciphers/simple_substitution.clj

@@ -44,15 +44,26 @@
       (caesar/encrypt-message key symbols)
       (encrypt-message substitution-table)))
 
+(defn decrypt-by-table
+  "Decrypt a message by the substitution-table"
+  [substitution-table message]
+  (map (fn [char] (find-value-in-table char substitution-table)) message))
+
+(defn decrypt-message-by-symbol-table
+  "Decrypt a message using the simple substitution cipher. The function is case-insensitive. The substitution-table must be (symbols, symbols)."
+  [substitution-table message ]
+  (->> message
+       (decrypt-by-table substitution-table)
+       (remove nil?)
+       (cs/join)))
+
 (defn decrypt-message
-  "Decrypt a message using the simple substitution cipher. The function is case-insensitive. The substitution-table must be "
+  "Decrypt a message using the simple substitution cipher. The function is case-insensitive. The substitution-table must be (int, symbols)."
   [message substitution-table]
   (let [message (cs/split message #",")]
     (->> message
          (map #(Integer/parseInt %))
-         (map (fn [char] (find-value-in-table char substitution-table)))
+         (decrypt-message-by-symbol-table 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."

src/cipher_analytical_machine/cli/cli.clj

@@ -160,3 +160,10 @@
 
      (show-and-save-output options))))
 
+(defn cli-main
+  [args]
+  (let [{:keys [options arguments action-type exit-message ok?]} (validate-args args)]
+    (if exit-message
+      (exit exit-message ok?)
+      (actions options arguments action-type))))
+

src/cipher_analytical_machine/core.clj

@@ -5,8 +5,5 @@
 
 (defn -main
   [& args]
-  (let [{:keys [options arguments action-type exit-message ok?]} (cli/validate-args args)]
+  (cli/cli-main args))
-    (if exit-message
-      (cli/exit exit-message ok?)
-      (cli/actions options arguments action-type))))
 

test/cipher_analytical_machine/analyzers/analyzers_test.clj

@@ -0,0 +1,40 @@
+(ns cipher-analytical-machine.analyzers.analyzers-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.analyzers.analyzers :refer :all]))
+
+(deftest count-characters-test
+  (testing "Count two dublicates and one uniq character from a string."
+    (is (= {\a 2 \b 1}
+           (count-characters "aba")))))
+
+(deftest chi-squared-letter-statistic-test
+  (testing "If the frequence of A is 0.1, the text length is 100 and contains 20 times, then the chi-squared is 10."
+    (is (= 10.0
+           (chi-squared-letter-statistic 20 0.1 100))))
+
+  (testing "If the frequence of A is 0.1, the text length is 10 and contains 5 times, then the chi-squared is 16.0."
+    (is (= 16.0
+           (chi-squared-letter-statistic 5 0.1 10)))))
+
+(deftest chi-squared-statistic-test
+  (let [text "aaaaabbbbb"]
+  (testing "If the frequencies of a and b is 0.1, the text length is 10 and contains them 5 times, then score is 32."
+    (is (= 32.0
+           (chi-squared-statistic text {\a 0.1 \b 0.1}))))))
+
+(deftest sort-map-by-count-test
+  (testing "Test the sort in descending order."
+    (is (= [[\b 3] [\a 2] [\c 1]]
+           (sort-map-by-count {\a 2 \b 3 \c 1} )))))
+
+(deftest table-to-string-test
+  (testing "Test the sort in descending order."
+    (is (= "bac"
+           (table-to-string [[\b 3] [\a 2] [\c 1]])))))
+
+(deftest symbol-frequency-table-test
+  (testing "Test the sort in descending order."
+    (is (= {\d \b, \e \a, \f \c}
+           (symbol-frequency-table {\d 3 \e 2 \f 1} {\b 3 \a 2 \c 1})))))
+

test/cipher_analytical_machine/ciphers/simple_substitution_test.clj

@@ -48,6 +48,23 @@
         "abc" 1 "2,3,1"
         "aDbdc" 0 "1,2,3"))))
 
+(deftest decrypt-by-table-test
+  (let [table {\d \a \e \b \f \c}]
+    (testing "The function must decrypt the message by the table."
+      (are [message expected]
+          (= expected (decrypt-by-table table message))
+        "def" '(\a \b \c)
+        "abf" '(nil nil \c)
+        "fed" '(\c \b \a)))))
+
+(deftest decrypt-message-by-symbol-table-test
+  (let [table {\d \a \e \b \f \c}]
+    (testing "The function must decrypt the message and remove unknown numbers."
+      (are [message expected]
+          (= expected (decrypt-message-by-symbol-table table message))
+        "def" "abc"
+        "daef" "abc"))))
+
 (deftest decrypt-message-test
   (let [table {1 \a 2 \b 3 \c}]
     (testing "The function must decrypt the message and remove unknown numbers."