Add the simple substitution cipher.

src/cipher_analytical_machine/cli/actions/cryptography.clj

@@ -1,6 +1,9 @@
 (ns cipher-analytical-machine.cli.actions.cryptography
   (:require
-   [cipher-analytical-machine.ciphers.caesar :as caesar])
+   [cipher-analytical-machine.ciphers.caesar :as caesar]
+   [cipher-analytical-machine.ciphers.simple-substitution :as ss]
+   [cipher-analytical-machine.parsers.parsers :as ps]
+   [cipher-analytical-machine.parsers.simple-substitution :as pss])
   (:gen-class))
 
 (defn caesar-actions
@@ -15,10 +18,33 @@
       (= action-type :decrypt)
       (caesar/decrypt-message message key symbols))))
 
+(defn simple-substitution-with-caesar-actions
+  [options arguments action-type]
+  (let [message (:message options)
+        key (:key options)
+        symbols (:symbols options)]
+    (cond
+      (= action-type :encrypt)
+      (let [data (pss/generate-table-or-decode-json key symbols)
+            key (ps/parse-unsigned-int (get data "key"))
+            substitution-table (get data "table")]
+        (println (pss/encode-key-and-substitution-table-to-json key substitution-table))
+        (ss/encrypt-message-with-caesar message key substitution-table symbols))
+
+      (= action-type :decrypt)
+      (let [data (-> (pss/decode-key-and-substitution-table-from-json key)
+                     (pss/invert-table-in-map))
+            key (get data "key")
+            substitution-table (get data "table")]
+        (ss/decrypt-message-with-caesar message key substitution-table symbols)))))
+
 (defn cryptography-actions
   [options arguments action-type]
   (let [cipher (:cipher options)]
     (cond
       (= cipher "Caesar")
-      (caesar-actions options arguments action-type))))
+      (caesar-actions options arguments action-type)
+
+      (= cipher "Simple substitution and Caesar")
+      (simple-substitution-with-caesar-actions options arguments action-type))))
 

src/cipher_analytical_machine/cli/options.clj

@@ -22,7 +22,7 @@
     (option-values-as-list option values)))
 
 (def cipher-options
-  #{"Caesar"})
+  #{"Caesar" "Simple substitution and Caesar"})
 
 (def default-cipher "Caesar")
 

src/cipher_analytical_machine/parsers/parsers.clj

@@ -3,7 +3,21 @@
   (:gen-class))
 
 (defn unsigned-int?
+  "Return true if the string is an unsigned integer."
   [str]
   (if (re-matches #"\d+" str)
     true false))
 
+(defn parse-unsigned-int
+  "Return an integer if the argument is an integer."
+  [str-or-int]
+  (cond
+    (int? str-or-int)
+    str-or-int
+
+    (unsigned-int? str-or-int)
+    (Integer/parseInt str-or-int)
+
+    :else
+    nil))
+

src/cipher_analytical_machine/parsers/simple_substitution.clj

@@ -2,6 +2,7 @@
   (:require
    [cipher-analytical-machine.ciphers.simple-substitution :as ss]
    [cipher-analytical-machine.parsers.parsers :as ps]
+   [clojure.set :as set]
    [cheshire.core :as cc])
   (:gen-class))
 
@@ -42,3 +43,12 @@
         (assoc "table" (ss/generate-substitution-table symbols)))
     (decode-key-and-substitution-table-from-json key-or-json)))
 
+(defn invert-table-in-map
+  "Invert the table in a decoded json (key, table)"
+  [decoded-json]
+  (->>
+   (-> decoded-json
+       (get "table")
+       (set/map-invert))
+   (assoc decoded-json "table")))
+

test/cipher_analytical_machine/parsers/parsers_test.clj

@@ -4,7 +4,7 @@
    [cipher-analytical-machine.parsers.parsers :refer :all]))
 
 (deftest unsigned-int?-test
-  (testing ""
+  (testing "The function return true only for an unsingned integer as a string."
     (are [str expected]
         (= expected
            (unsigned-int? str))
@@ -13,3 +13,13 @@
       "-10" false
       "abc" false)))
 
+(deftest parse-unsigned-int-test
+  (testing "The function parse the integer if the string is an integer."
+    (are [str-or-int expected]
+        (= expected
+           (parse-unsigned-int str-or-int))
+      "9"   9
+      9     9
+      "10"  10
+      "-10" nil
+      "abc" nil)))

test/cipher_analytical_machine/parsers/simple_substitution_test.clj

@@ -39,3 +39,11 @@
         "1" {"key" 1 "table" {0 \a 1 \b 2 \c}}
         "2" {"key" 2 "table" {\a 0 \b 1 \c 2}}))))
 
+(deftest invert-table-in-map-test
+  (testing "The function invert the table in a decoded json."
+    (are [decoded-json expected-data]
+        (= expected-data
+           (invert-table-in-map decoded-json))
+      {"key" 1 "table" {0 \a 1 \b 2 \c}} {"key" 1 "table" {\a 0 \b 1 \c 2}}
+      {"key" 2 "table" {\a 0 \b 1 \c 2}} {"key" 2 "table" {0 \a 1 \b 2 \c}})))
+