Update symbol defaults, factories to have only lower alphabets.

src/cipher_analytical_machine/cli.clj

@@ -12,6 +12,9 @@
 (def cipher-options
   #{"Caesar"})
 
+(def language-options
+  #{"en", "uk"})
+
 (def cli-options
   [["-m" "--message MESSAGE" "The message will be encrypted or decrypted."]
    ["-M" "--message-file MESSAGE-FILE" "The file contains the message that will be encrypted or decrypted."]
@@ -22,6 +25,8 @@
    ["-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")]
+   ["-l" "--language CODE" "The string will be used to set a default symbols for a cipher."
+    :validate [#(contains? language-options %) "Must be a code from the list: en, uk!!!"]]
    ["-C" "--cracking" "Cracking the encrypted message."]
    ["-h" "--help"]])
 
@@ -88,29 +93,72 @@
   (println exit-message)
   (System/exit (if status 0 1)))
 
-(defn get-message
+(defn get-or-load-option
-  "Return the message"
+  "Return the option value or load the value from a file."
-  [options arguments]
+  [options arguments option]
-  (cond
+  (let [file-option (keyword (str (name option) "-file"))]
-    (contains? options :message)
+    (cond
-    (:message options)
+      (contains? options option)
+      (option options)
 
-    (contains? options :message-file)
+      (contains? options file-option)
-    (file/read-file (:message-file options))))
+      (file/read-file (file-option options)))))
+
+(defn set-option
+  "Set a option in the option map."
+  [options option value]
+  (-> options
+      (assoc option value)))
+
+(defn set-symbols
+  "Set defaults symbols for a language."
+  [options]
+  (set-option options :symbols
+              (sf/default-symbol-factory (:language options))))
+
+(defn load-and-set-option
+  "Load the option and set it."
+  [options option]
+  (->> (get-or-load-option options nil option)
+       (set-option options option)))
+
+(defn load-all-options
+  "Load all options."
+  [options]
+  (-> options
+      (set-symbols)
+      (load-and-set-option :message)))
+
+(defn cracking-actions
+  [options arguments action-type]
+  (let [message (:message options)
+        symbols (:symbols options)
+        frequencies symbol-frequences/english-letter-frequences]
+    (cond
+      (= action-type :cracking)
+      (caesar-analyzers/get-plaintext message symbols frequencies)
+      )))
+
+(defn crypt-actions
+  [options arguments action-type]
+  (let [message (:message options)
+        key (Integer/parseInt (:key options))
+        symbols (:symbols options)]
+    (cond
+      (= action-type :encrypt)
+      (caesar/encrypt-message message key symbols)
+
+      (= action-type :decrypt)
+      (caesar/decrypt-message message key symbols))))
 
 (defn actions
   [options arguments action-type]
-  (let [message (get-message options arguments)
+  (let [options (load-all-options options)]
-        key (Integer/parseInt (:key options))
-        symbols (:symbols options)]
     (println
      (cond
+       (contains? #{:encrypt :decrypt} action-type)
+       (crypt-actions options arguments action-type)
+
        (= action-type :cracking)
-       (caesar-analyzers/get-plaintext message symbols symbol-frequences/english-letter-frequences)
+       (cracking-actions options arguments action-type)))))
-
-       (= action-type :encrypt)
-       (caesar/encrypt-message message key symbols)
-
-       (= action-type :decrypt)
-       (caesar/decrypt-message message key symbols)))))
 

src/cipher_analytical_machine/symbol_factories.clj

@@ -2,7 +2,7 @@
   (:require [clojure.string :as cs])
   (:gen-class))
 
-(defn lower-english-alphabet-factory
+(defn english-alphabet-factory
   "Return the English alphabet with only lowercase letters"
   []
   (reduce
@@ -10,23 +10,11 @@
    ""
    (range (int \a) (inc (int \z)))))
 
-(defn english-alphabet-factory
+(defn ukrainian-alphabet-factory
-  "Return the English alphabet with lower and upper case letters"
-  []
-  (let [letters (lower-english-alphabet-factory)]
-    (str letters (cs/upper-case letters))))
-
-(defn lower-ukrainian-alphabet-factory
   "Return the Ukrainian alphabet with only lowercase letters"
   []
   "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя")
 
-(defn ukrainian-alphabet-factory
-  "Return the Ukrainian alphabet with lower and upper case letters"
-  []
-  (let [letters (lower-ukrainian-alphabet-factory)]
-    (str letters (cs/upper-case letters))))
-
 (defn digit-set-factory
   "Return digits"
   []
@@ -48,14 +36,10 @@
   (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

test/cipher_analytical_machine/symbol_factories_test.clj

@@ -4,38 +4,22 @@
    [cipher-analytical-machine.symbol-factories :refer :all]
   ))
 
-(deftest lower-english-alphabet-factory-test
+(deftest english-alphabet-factory-test
-  (let [symbols (lower-english-alphabet-factory)]
+  (let [symbols (english-alphabet-factory)]
     (testing "It must have the same order."
       (is (= "abcdefghijklmnopqrstuvwxyz" symbols)))
 
     (testing "It must have 26 letters."
       (is (= 26 (count symbols))))))
 
-(deftest english-alphabet-factory-test
+(deftest ukrainian-alphabet-factory-test
-  (let [symbols (english-alphabet-factory)]
+  (let [symbols (ukrainian-alphabet-factory)]
-    (testing "It must have the same order."
-      (is (= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" symbols)))
-
-    (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 the same order."
       (is (= "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" symbols)))
 
     (testing "It must have 33 letters."
       (is (= 33 (count symbols))))))
 
-(deftest ukrainian-alphabet-factory-test
-  (let [symbols (ukrainian-alphabet-factory)]
-    (testing "It must have the same order."
-      (is (= "абвгґдеєжзиіїйклмнопрстуфхцчшщьюяАБВГҐДЕЄЖЗИІЇЙКЛМНОПРСТУФХЦЧШЩЬЮЯ" symbols)))
-
-    (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 the same order."
@@ -61,15 +45,15 @@
       (is (= 3 (count symbols))))))
 
 (deftest default-symbol-factory-test
-  (testing "If language code is 'en', then it must have symbols."
+  (testing "If language code is 'en', then it must have 27 symbols."
     (let [symbols (default-symbol-factory "en")]
-      (is (= 70 (count symbols)))))
+      (is (= 27 (count symbols)))))
 
-  (testing "If language code is 'uk', then it must have symbols."
+  (testing "If language code is 'uk', then it must have 34 symbols."
     (let [symbols (default-symbol-factory "uk")]
-      (is (= 84 (count symbols)))))
+      (is (= 34 (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))))))
+      (is (= 27 (count symbols))))))