Add the cracking option.

src/cipher_analytical_machine/cli.clj

@@ -2,6 +2,9 @@
   (:require
    [cipher-analytical-machine.file :as file]
    [cipher-analytical-machine.caesar :as caesar]
+   [cipher-analytical-machine.caesar-analyzers :as caesar-analyzers]
+   [cipher-analytical-machine.symbol-factories :as sf]
+   [cipher-analytical-machine.symbol-frequences :as symbol-frequences]
    [clojure.string :as cs]
    [clojure.tools.cli :refer [parse-opts]])
   (:gen-class))
@@ -17,6 +20,9 @@
     :default "Caesar"]
    ["-e" "--encrypt" "Encrypt the message."]
    ["-d" "--decrypt" "Decrypt the message."]
+   ["-s" "--symbols" "The string will be used as a set of symbols for a cipher."
+    :default (sf/default-symbol-factory "en")]
+   ["-C" "--cracking" "Cracking the encrypted message."]
    ["-h" "--help"]])
 
 (defn usage [options-summary]
@@ -62,7 +68,17 @@
                (contains? options :message-file))
            (or (contains? options :encrypt)
                (contains? options :decrypt)))
-      {:options options :arguments arguments}
+      (cond
+        (contains? options :encrypt)
+        {:options options :arguments arguments :action-type :encrypt}
+
+        (contains? options :decrypt)
+        {:options options :arguments arguments :action-type :decrypt})
+
+      (and (map-has-keys? options [:cipher, :cracking])
+           (or (contains? options :message)
+               (contains? options :message-file)))
+      {:options options :arguments arguments :action-type :cracking}
 
       :else
       {:exit-message (usage summary)})))
@@ -83,16 +99,18 @@
     (file/read-file (:message-file options))))
 
 (defn actions
-  [options arguments]
-  (println (str options arguments))
+  [options arguments action-type]
   (let [message (get-message options arguments)
         key (Integer/parseInt (:key options))
-        symbols "abc"]
+        symbols (:symbols options)]
     (println
      (cond
-       (contains? options :encrypt)
+       (= action-type :cracking)
+       (caesar-analyzers/get-plaintext message symbols symbol-frequences/english-letter-frequences)
+
+       (= action-type :encrypt)
        (caesar/encrypt-message message key symbols)
 
-       (contains? options :decrypt)
+       (= action-type :decrypt)
        (caesar/decrypt-message message key symbols)))))
 

src/cipher_analytical_machine/core.clj

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

src/cipher_analytical_machine/language_analyzer.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.language_analyzer
+(ns cipher-analytical-machine.language-analyzer
   (:import [org.apache.tika.language LanguageIdentifier])
   (:gen-class))
 

src/cipher_analytical_machine/symbol_factories.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.symbol_factories
+(ns cipher-analytical-machine.symbol-factories
   (:require [clojure.string :as cs])
   (:gen-class))
 
@@ -32,3 +32,32 @@
   []
   "0123456789")
 
+(defn punctuation-symbol-factory
+  "Return punctuation symbols"
+  []
+  ".,:;-!?")
+
+(defn space-symbol-factory
+  "Return punctuation symbols"
+  []
+  " \t\n")
+
+(defn default-symbol-factory
+  "Return a default string of symbols for a language"
+  [language-code]
+  (cond
+    (= language-code "en")
+    (str (english-alphabet-factory)
+         (punctuation-symbol-factory)
+         (digit-set-factory)
+         \ )
+
+    (= language-code "uk")
+    (str (ukrainian-alphabet-factory)
+         (punctuation-symbol-factory)
+         (digit-set-factory)
+         \ )
+
+    :else
+    (default-symbol-factory "en")))
+

src/cipher_analytical_machine/symbol_frequences.clj

@@ -1,4 +1,4 @@
-(ns cipher-analytical-machine.symbol_frequences
+(ns cipher-analytical-machine.symbol-frequences
   (:gen-class))
 
 (def english-letter-frequences {

test/cipher_analytical_machine/language_analyzer_test.clj

@@ -1,7 +1,7 @@
-(ns cipher-analytical-machine.language_analyzer_test
+(ns cipher-analytical-machine.language-analyzer-test
   (:require
    [clojure.test :refer :all]
-   [cipher-analytical-machine.language_analyzer :refer :all]
+   [cipher-analytical-machine.language-analyzer :refer :all]
   ))
 
 (deftest detect-language-test
@@ -41,5 +41,5 @@
     (is (is-nonsense? "dfgjldfjgdfl gjdfg idfjig hdgesr khs e." "en")))
 
   (testing "Checking a gibberish that uses Ukrainian letters"
-    (is (is-nonsense? "іаврпшшцді врадів аргів аріл варї йцґ." "uk"))))
+    (is (is-nonsense? "іаврпшшцді івафі лоінїмч йцувіа івапґ." "uk"))))
 

test/cipher_analytical_machine/symbol_factories_test.clj

@@ -1,46 +1,75 @@
 (ns cipher-analytical-machine.symbol-factories-test
   (:require
    [clojure.test :refer :all]
-   [cipher-analytical-machine.symbol_factories :refer :all]
+   [cipher-analytical-machine.symbol-factories :refer :all]
   ))
 
 (deftest lower-english-alphabet-factory-test
   (let [symbols (lower-english-alphabet-factory)]
-    (testing "It must have same order"
+    (testing "It must have the same order."
       (is (= "abcdefghijklmnopqrstuvwxyz" symbols)))
 
-    (testing "It must have 26 letters"
+    (testing "It must have 26 letters."
       (is (= 26 (count symbols))))))
 
 (deftest english-alphabet-factory-test
   (let [symbols (english-alphabet-factory)]
-    (testing "It must have same order"
+    (testing "It must have the same order."
       (is (= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" symbols)))
 
-    (testing "It must have 2*26 letters"
+    (testing "It must have 2*26 letters."
       (is (= (* 2 26) (count symbols))))))
 
 (deftest lower-ukrainian-alphabet-factory-test
   (let [symbols (lower-ukrainian-alphabet-factory)]
-    (testing "It must have same order"
+    (testing "It must have the same order."
       (is (= "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" symbols)))
 
-    (testing "It must have 33 letters"
+    (testing "It must have 33 letters."
       (is (= 33 (count symbols))))))
 
 (deftest ukrainian-alphabet-factory-test
   (let [symbols (ukrainian-alphabet-factory)]
-    (testing "It must have same order"
+    (testing "It must have the same order."
       (is (= "абвгґдеєжзиіїйклмнопрстуфхцчшщьюяАБВГҐДЕЄЖЗИІЇЙКЛМНОПРСТУФХЦЧШЩЬЮЯ" symbols)))
 
-    (testing "It must have 2*33 letters"
+    (testing "It must have 2*33 letters."
       (is (= (* 2 33) (count symbols))))))
 
 (deftest digit-set-factory-test
   (let [symbols (digit-set-factory)]
-    (testing "It must have same order"
+    (testing "It must have the same order."
       (is (= "0123456789" symbols)))
 
-    (testing "It must have 10 digits"
+    (testing "It must have 10 digits."
       (is (= 10 (count symbols))))))
 
+(deftest punctuation-symbol-factory-test
+  (let [symbols (punctuation-symbol-factory)]
+    (testing "It must have the same order."
+      (is (= ".,:;-!?" symbols)))
+
+    (testing "It must have 7 symbols."
+      (is (= 7 (count symbols))))))
+
+(deftest space-symbol-factory-test
+  (let [symbols (space-symbol-factory)]
+    (testing "It must have the same order."
+      (is (= " \t\n" symbols)))
+
+    (testing "It must have 3 symbols."
+      (is (= 3 (count symbols))))))
+
+(deftest default-symbol-factory-test
+  (testing "If language code is 'en', then it must have symbols."
+    (let [symbols (default-symbol-factory "en")]
+      (is (= 70 (count symbols)))))
+
+  (testing "If language code is 'uk', then it must have symbols."
+    (let [symbols (default-symbol-factory "uk")]
+      (is (= 84 (count symbols)))))
+
+  (testing "If language code is unidentified, then it must have the 'en'."
+    (let [symbols (default-symbol-factory "Maybe a code")]
+      (is (= 70 (count symbols))))))
+