Update the FrequencyAnalyzer to use the frequency string instead.

2023-10-12 22:07:02 +03:00
21 changed files with 81 additions and 715 deletions
@@ -5,42 +5,6 @@ name: default
 steps:
  - name: test
    image: clojure:temurin-11-lein-2.10.0-alpine
    volumes:
      - name: package_cache
        path: /root/.m2/
    commands:
      - lein test
  - name: build
    image: clojure:temurin-11-lein-2.10.0-alpine
    volumes:
      - name: package_cache
        path: /root/.m2/
    commands:
      - lein uberjar
    when:
      event: tag
  - name: gitea_release
    image: plugins/gitea-release
    settings:
      api_key:
        from_secret: API_KEY
      base_url:
        from_secret: BASE_URL
      files:
        - target/uberjar/*.jar
      checksum:
        - md5
        - sha1
        - sha256
        - sha512
        - adler32
        - crc32
    when:
      event: tag
 volumes:
  - name: package_cache
    temp: {}
@@ -7,76 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 ## [0.7.2] - 2023-10-21
 ### Changed
 - Update the CHANGELOG.
 - Update the version.
 - Update the README.
 - Update the CI/CD configuration to publish the artifacts to the release.
 - Update the diffs in the CHANGELOG.
 ## [0.7.1] - 2023-10-20
 ### Removed
 - Remove the test for FrequencyAnalyzer.
 - Remove the option for FrequencyAnalyzer.
 ## [0.7.0] - 2023-10-20
 ### Changed
 - Refactor to move actions to separated files.
 ## [0.6.3] - 2023-10-14
 ### Added
 - Add the IsNonsense interface for FrequencyAnalyzer.
 ### Changed
 - Update the frequency analyzer.
 ## [0.6.2] - 2023-10-14
 ### Added
 - Add the analyzer options and their actions.
 - Add the available ciphers and analyzer for the help.
 - Add validations to check if a cipher or an analyzer is available.
 ### Changed
 - Refactor to move options to a separated file.
 ## [0.6.1] - 2023-10-13
 ### Added
 - Add the function to make a frequency string from a map.
 ### Fixed
 - Fix the bug that the default language symbols override the symbols.
 ### Changed
 - Update the FrequencyAnalyzer to use the frequency string instead.
 ## [0.6.0] - 2023-10-12
 ### Fixed
 - Fix the typo "frequences" to frequencies.
 ### Changed
 - Refactor the project structure.
 ## [0.5.5] - 2023-10-09
 ### Added
 - Add the Gitlab CI/CD configuration.
 ## [0.5.4] - 2023-10-05
 ### Added
 - Add the java source path.
 - Add the Caesar decrypted interface for Java.
 - Add a frequency analyzer as a stub.
 - Add the clojure wrapper for the frequency analizer and its test.
 ## [0.5.3] - 2023-10-05
 ### Added
@@ -177,16 +107,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Project initialization.
-[Unreleased]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.7.2...main?from_project_id=50218541&straight=false
+[Unreleased]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.3...main?from_project_id=50218541&straight=false
 [0.7.2]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.7.1...0.7.2?from_project_id=50218541&straight=false
 [0.7.1]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.7.0...0.7.1?from_project_id=50218541&straight=false
 [0.7.0]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.6.3...0.7.0?from_project_id=50218541&straight=false
 [0.6.3]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.6.2...0.6.3?from_project_id=50218541&straight=false
 [0.6.2]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.6.1...0.6.2?from_project_id=50218541&straight=false
 [0.6.1]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.6.0...0.6.1?from_project_id=50218541&straight=false
 [0.6.0]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.5...0.6.0?from_project_id=50218541&straight=false
 [0.5.5]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.4...0.5.5?from_project_id=50218541&straight=false
 [0.5.4]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.3...0.5.4?from_project_id=50218541&straight=false
 [0.5.3]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.2...0.5.3?from_project_id=50218541&straight=false
 [0.5.2]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.1...0.5.2?from_project_id=50218541&straight=false
 [0.5.1]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.0...0.5.1?from_project_id=50218541&straight=false
@@ -11,12 +11,10 @@ Download from https://gitlab.com/KKlochko/cipher-analytical-machine.
 You need install java, before run the application.
 Run the application with a command:
-    $ java -jar cipher-analytical-machine-VERSION-standalone.jar [args]
+    $ java -jar cipher-analytical-machine-0.1.0-standalone.jar [args]
    $ java -jar cipher-analytical-machine-0.7.2-standalone.jar [args]
 ## License
 Copyright © 2023 Kostiantyn Klochko
 Under the GNU Lesser General Public License v3.0 or later.
@@ -1,4 +1,4 @@
-(defproject cipher-analytical-machine "0.7.2"
+(defproject cipher-analytical-machine "0.1.0-SNAPSHOT"
  :description "A program helps to learn how ciphers works."
  :url "https://gitlab.com/KKlochko/cipher-analytical-machine"
  :license {:name "LGPL"
@@ -6,8 +6,7 @@
  :dependencies [[org.clojure/clojure "1.11.1"]
                 [org.clojure/tools.cli "1.0.219"]
                 [org.apache.tika/tika-core "1.28.5"]
-                 [org.apache.tika/tika-langdetect "1.28.5"]
+                 [org.apache.tika/tika-langdetect "1.28.5"]]
                 [cheshire "5.12.0"]]
  :main ^:skip-aot cipher-analytical-machine.core
  :java-source-paths ["src/main/java"]
  :target-path "target/%s"
@@ -36,22 +36,3 @@
            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))))
@@ -1,10 +1,8 @@
 (ns cipher-analytical-machine.analyzers.caesar
  (:require [cipher-analytical-machine.ciphers.caesar :as caesar]
            [clojure.string :as cs]
            [cipher-analytical-machine.analyzers.language :as language]
            [cipher-analytical-machine.analyzers.analyzers :as ca])
  (:import [cipher_analytical_machine.ciphers.caesar Decrypted]
           [cipher_analytical_machine.analyzers.caesar IsNonsense]
           [cipher_analytical_machine.analyzers.caesar FrequencyAnalyzer])
  (:gen-class))
@@ -52,13 +50,10 @@
 (defn frequency-analizer-get-plaintext
  "Return the plaintext from a ciphertext using simple analizer. The function is case-insensitive."
-  [ciphertext symbols letter-frequencies-string language-code]
+  [ciphertext symbols letter-frequencies-string]
  (let [decrypt (reify Decrypted
                  (decrypt [this message key symbols]
-                    (caesar/decrypt-message message key symbols)))
+                    (caesar/decrypt-message message key symbols)))]
-        is-nonsense (reify IsNonsense
+    (-> (new FrequencyAnalyzer ciphertext symbols letter-frequencies-string decrypt)
                  (isNonsense [this message]
                    (language/is-nonsense? message language-code)))]
    (-> (new FrequencyAnalyzer ciphertext symbols letter-frequencies-string decrypt is-nonsense)
        .crack)))
@@ -1,74 +0,0 @@
 (ns cipher-analytical-machine.ciphers.simple-substitution
  (:require [clojure.string :as cs]
            [cipher-analytical-machine.ciphers.caesar :as caesar])
  (:gen-class))
 (defn shuffled-numbers
  "Generate the shuffled order for integer list."
  [size]
  (-> size
      (take (range))
      (shuffle)))
 (defn generate-substitution-table
  "Generate the map (char, int) for the substittion."
  [symbols]
  (->> (count symbols)
       (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]
  (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]
  (-> message
      (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 (int, symbols)."
  [message substitution-table]
  (let [message (cs/split message #",")]
    (->> message
         (map #(Integer/parseInt %))
         (decrypt-message-by-symbol-table substitution-table))))
 (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]
  (-> message
      (decrypt-message substitution-table)
      (caesar/decrypt-message key symbols)))
@@ -1,26 +0,0 @@
 (ns cipher-analytical-machine.cli.actions.cracking
  (:require
   [cipher-analytical-machine.analyzers.caesar :as caesar-analyzers]
   [cipher-analytical-machine.symbols.frequencies :as symbol-frequencies])
  (:gen-class))
 (defn cracking-caesar
  [options arguments]
  (let [analyzer (:analyzer options)
        message (:message options)
        symbols (:symbols options)
        frequencies symbol-frequencies/english-letter-frequencies]
    (cond
      (= analyzer "Chi^2")
      (caesar-analyzers/get-plaintext message symbols frequencies)
      :else
      (caesar-analyzers/get-plaintext message symbols frequencies))))
 (defn cracking-actions
  [options arguments action-type]
  (let [cipher (:cipher options)]
    (cond
      (= cipher "Caesar")
      (cracking-caesar options arguments))))
@@ -1,50 +0,0 @@
 (ns cipher-analytical-machine.cli.actions.cryptography
  (:require
   [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
  [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 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)
      (= cipher "Simple substitution and Caesar")
      (simple-substitution-with-caesar-actions options arguments action-type))))
@@ -1,14 +1,36 @@
 (ns cipher-analytical-machine.cli.cli
  (:require
   [cipher-analytical-machine.cli.file :as file]
   [cipher-analytical-machine.ciphers.caesar :as caesar]
   [cipher-analytical-machine.analyzers.caesar :as caesar-analyzers]
   [cipher-analytical-machine.symbols.factories :as sf]
-   [cipher-analytical-machine.cli.options :as options]
+   [cipher-analytical-machine.symbols.frequencies :as symbol-frequencies]
   [clojure.string :as cs]
   [cipher-analytical-machine.cli.actions.cryptography :as cryptography]
   [cipher-analytical-machine.cli.actions.cracking :as cracking]
   [clojure.tools.cli :refer [parse-opts]])
  (:gen-class))
 (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."]
   ["-k" "--key KEY" "The key will be used to encrypt or decrypt."]
   ["-c" "--cipher CIPHER" "The cipher will be used to encrypt or decrypt a message."
    :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")]
   ["-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."]
   ["-O" "--output-file OUTPUT-FILE" "Save the program output to a file."]
   ["-h" "--help"]])
 (defn usage [options-summary]
  (->> ["This is cipher-analytical-machine. It can help you to learn how ciphers works."
        ""
@@ -16,12 +38,6 @@
        ""
        "Options:"
        options-summary
        ""
        "Available values"
        ""
        (options/get-available-cipher-options-as-string)
        ""
        (options/get-available-analyzers-options-as-string)
        ""]
       (cs/join \newline)))
@@ -39,7 +55,7 @@
  should exit (with an error message, and optional ok status), or a map
  indicating the action the program should take and the options provided."
  [args]
-  (let [{:keys [options arguments errors summary]} (parse-opts args options/cli-options)]
+  (let [{:keys [options arguments errors summary]} (parse-opts args cli-options)]
    (cond
      (:help options)
      {:exit-message (usage summary) :ok? true}
@@ -61,16 +77,6 @@
           (file/is-file-exists? (:output-file options)))
      {:exit-message (error-msg ["Please, choose another file!!! Overwriting was prevented!!!"])}
      (false? (contains? options/cipher-options (:cipher options)))
      {:exit-message (error-msg ["Please, choose an available cipher!!!\n"
                                 (options/get-available-cipher-options-as-string)])}
      (and (map-has-keys? options [:cipher, :cracking, :analyzer])
           (false? (contains?
             (get options/analyzers-options (:cipher options)) (:analyzer options))))
      {:exit-message (error-msg ["Please, choose an available analyzer!!!\n"
                                 (options/get-available-analyzers-options-as-string)])}
      (and (map-has-keys? options [:cipher, :key])
           (or (contains? options :message)
               (contains? options :message-file))
@@ -116,10 +122,8 @@
 (defn set-symbols
  "Set defaults symbols for a language."
  [options]
  (if (contains? options :language)
  (set-option options :symbols
-                (sf/default-symbol-factory (:language options)))
+              (sf/default-symbol-factory (:language options))))
    options))
 (defn load-and-set-option
  "Load the option and set it."
@@ -147,23 +151,38 @@
    (save-output output options))
  (println output))
 (defn cracking-actions
  [options arguments action-type]
  (let [message (:message options)
        symbols (:symbols options)
        frequencies symbol-frequencies/english-letter-frequencies]
    (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 [options (load-all-options options)]
    (->
     (cond
       (contains? #{:encrypt :decrypt} action-type)
-       (cryptography/cryptography-actions options arguments action-type)
+       (crypt-actions options arguments action-type)
       (= action-type :cracking)
-       (cracking/cracking-actions options arguments action-type))
+       (cracking-actions options arguments action-type))
     (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))))
@@ -1,64 +0,0 @@
 (ns cipher-analytical-machine.cli.options
  (:require
   [cipher-analytical-machine.symbols.factories :as sf]
   [clojure.string :as cs])
  (:gen-class))
 (defn option-values-as-row
  "Return the formatted string of values for an option."
  [option values]
  (str option ": " (cs/join ", " values)))
 (defn option-values-as-list
  "Return the formatted string of values for an option as a multiline list."
  [option values]
  (str option ": \n - " (cs/join "\n - " values)))
 (defn map-of-option-value-as-list
  "Return the formatted string of values for an option as a multiline list.
   The values are a map of pairs (suboption and its options)."
  [option values]
  (let [values (map #(apply option-values-as-row %) values)]
    (option-values-as-list option values)))
 (def cipher-options
  #{"Caesar" "Simple substitution and Caesar"})
 (def default-cipher "Caesar")
 (defn get-available-cipher-options-as-string
  "Return the formatted string of analyzers options."
  []
  (option-values-as-row "Ciphers" cipher-options))
 (def analyzers-options
  {"Caesar" #{"Chi^2"}})
 (defn get-available-analyzers-options-as-string
  "Return the formatted string of analyzers options."
  []
  (map-of-option-value-as-list "Analyzers" analyzers-options))
 (def language-options
  #{"en", "uk"})
 (def default-symbols
  (sf/default-symbol-factory "en"))
 (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."]
   ["-k" "--key KEY" "The key will be used to encrypt or decrypt."]
   ["-c" "--cipher CIPHER" "The cipher will be used to encrypt or decrypt a message."
    :default default-cipher]
   ["-e" "--encrypt" "Encrypt the message."]
   ["-d" "--decrypt" "Decrypt the message."]
   ["-s" "--symbols SYMBOLS" "The string will be used as a set of symbols for a cipher."
    :default default-symbols]
   ["-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."]
   ["-a" "--analyzer ANALYZER" "The way of cracking."]
   ["-O" "--output-file OUTPUT-FILE" "Save the program output to a file."]
   ["-h" "--help"]])
@@ -5,5 +5,8 @@
 (defn -main
  [& args]
-  (cli/cli-main 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 action-type))))
@@ -1,23 +0,0 @@
 (ns cipher-analytical-machine.parsers.parsers
  (:require [cheshire.core :as cc])
  (: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))
@@ -1,54 +0,0 @@
 (ns cipher-analytical-machine.parsers.simple-substitution
  (: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))
 (defn encode-key-and-substitution-table-to-json
  [key substitution-table]
  (-> {"key" key}
      (assoc "table" substitution-table)
      (cc/generate-string)))
 (defn decode-key
  "Returns the first character if the string is a char. Return the number if the string is a number."
  [str]
  (if (ps/unsigned-int? str)
    (Integer/parseInt str)
    (first str)))
 (defn decode-pair
  "Decode a numbers as a string and a char as a string"
  [acc [key value]]
  (if (ps/unsigned-int? key)
    (assoc acc (decode-key key) (decode-key value))
    (assoc acc (decode-key key) value)))
 (defn decode-substitution-table
  [substitution-table-map-from-json]
  (reduce decode-pair {} substitution-table-map-from-json))
 (defn decode-key-and-substitution-table-from-json
  [json]
  (let [data (cc/parse-string json)]
    (assoc data "table" (decode-substitution-table (get data "table")))))
 (defn generate-table-or-decode-json
  "It generate the table and return map with the key and the table if the argument is a key. Else it decode the json."
  [key-or-json symbols]
  (if (ps/unsigned-int? key-or-json)
    (-> {"key" key-or-json}
        (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")))
@@ -1,53 +1,25 @@
 package cipher_analytical_machine.analyzers.caesar;
 import cipher_analytical_machine.analyzers.caesar.IsNonsense;
 import cipher_analytical_machine.ciphers.caesar.Decrypted;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
 public class FrequencyAnalyzer {
    private String ciphertext;
    private int key;
    private String symbols;
    private String symbol_frequences;
    private Decrypted decryptor;
    private IsNonsense isNonsense;
-    public FrequencyAnalyzer(String ciphertext, String symbols, String symbol_frequences, Decrypted decryptor, IsNonsense isNonsense) {
+    public FrequencyAnalyzer(String ciphertext, String symbols, String symbol_frequences, Decrypted decryptor) {
 	this.ciphertext = ciphertext;
-        this.symbol_frequences = symbol_frequences;
+	this.key = 1;
 	this.symbols = symbols;
 	this.symbol_frequences = symbol_frequences;
 	this.decryptor = decryptor;
 	    this.isNonsense = isNonsense;
    }
    public String crack() {
-        // Знаходимо кількість літер
+	return decryptor.decrypt(ciphertext, key, symbols);
        Map<Character, Integer> encryptedLetterCounts = new HashMap<>();
        for (char c : ciphertext.toLowerCase().toCharArray()) {
            encryptedLetterCounts.put(c, encryptedLetterCounts.getOrDefault(c, 0) + 1);
        }
        // Знаходимо букву, яка зустрічається найчастіше
        char mostFrequentEncryptedLetter = ' ';
        int mostFrequentEncryptedLetterCount = 0;
        for (Entry<Character, Integer> entry : encryptedLetterCounts.entrySet()) {
            if (entry.getValue() > mostFrequentEncryptedLetterCount) {
                mostFrequentEncryptedLetter = entry.getKey();
                mostFrequentEncryptedLetterCount = entry.getValue();
            }
        }
        // Обчислимо зміщення
        int size = symbols.length();
        int indexOfMostFrequentEncryptedLetter = symbols.indexOf(mostFrequentEncryptedLetter);
        int indexOfMostFrequentLetter = symbols.indexOf(symbol_frequences.charAt(0));
        int shift = (indexOfMostFrequentEncryptedLetter - indexOfMostFrequentLetter) % size;
        return decryptor.decrypt(ciphertext, shift, symbols);
    }
 }
@@ -1,6 +0,0 @@
 package cipher_analytical_machine.analyzers.caesar;
 public interface IsNonsense {
    boolean isNonsense(String message);
 }
@@ -1,40 +0,0 @@
 (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})))))
@@ -74,3 +74,13 @@
      (is (= (cs/lower-case plaintext)
             (get-plaintext ciphertext symbols frequencies))))))
 (deftest frequency-analizer-get-plaintext-test
  (let [plaintext "abc"
        ciphertext "bca"
        key 1
        symbols "abc"
        frequencies sf/english-letter-frequencies]
    (testing "The ciphertext is 'bca' and key is 1."
      (is (= plaintext
             (frequency-analizer-get-plaintext ciphertext symbols frequencies))))))
@@ -1,85 +0,0 @@
 (ns cipher-analytical-machine.ciphers.simple-substitution-test
  (:require
   [clojure.test :refer :all]
   [cipher-analytical-machine.ciphers.simple-substitution :refer :all]))
 (deftest find-value-in-table-test
  (let [table {\a 1 \b 2 \c 3}
        rtable {1 \a 2 \b 3 \c}]
    (testing "If the symbol is in the table as a key, then the result won't nil."
      (are [key expected]
          (= expected (find-value-in-table key table))
        \a 1
        \d nil
        1 nil
        5 nil))
    (testing "If the digit is in the reversed table as a key, then the result won't nil."
      (are [key expected]
          (= expected (find-value-in-table key rtable))
        \a nil
        \d nil
        1 \a
        5 nil))))
 (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-with-caesar message key table symbols))
        "abc" 0 "1,2,3"
        "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."
      (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 {1 \a 2 \b 3 \c}]
    (testing "The function must decrypt the message and remove unknown numbers."
      (are [message key expected]
          (= 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"))))
@@ -1,25 +0,0 @@
 (ns cipher-analytical-machine.parsers.parsers-test
  (:require
   [clojure.test :refer :all]
   [cipher-analytical-machine.parsers.parsers :refer :all]))
 (deftest unsigned-int?-test
  (testing "The function return true only for an unsingned integer as a string."
    (are [str expected]
        (= expected
           (unsigned-int? str))
      "9" true
      "10" true
      "-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)))
@@ -1,49 +0,0 @@
 (ns cipher-analytical-machine.parsers.simple-substitution-test
  (:require
   [clojure.test :refer :all]
   [cipher-analytical-machine.parsers.simple-substitution :refer :all]))
 (deftest encode-key-and-substitution-table-to-json-test
  (testing "The encoder must parse the map and create a json."
    (are [key table expected-json]
        (= expected-json
           (encode-key-and-substitution-table-to-json key table))
      1 {0 \a 1 \b 2 \c} "{\"key\":1,\"table\":{\"0\":\"a\",\"1\":\"b\",\"2\":\"c\"}}"
      2 {\a 0 \b 1 \c 2} "{\"key\":2,\"table\":{\"a\":0,\"b\":1,\"c\":2}}")))
 (deftest decode-key-and-substitution-table-from-json-test
  (testing "The decoder must parse the json and create a map."
    (are [json expected-data]
        (= expected-data
           (decode-key-and-substitution-table-from-json json))
      "{\"key\":1, \"table\":{\"0\":\"a\",\"1\":\"b\",\"2\":\"c\"}}" {"key" 1 "table" {0 \a 1 \b 2 \c}}
      "{\"key\":2, \"table\":{\"a\":0,\"b\":1,\"c\":2}}" {"key" 2 "table" {\a 0 \b 1 \c 2}})))
 (deftest generate-table-or-decode-json-test
  (let [symbols "abc"]
    (testing "The function decodes the json."
      (are [json expected-data]
          (= expected-data
             (generate-table-or-decode-json json symbols))
        "{\"key\":1, \"table\":{\"0\":\"a\",\"1\":\"b\",\"2\":\"c\"}}" {"key" 1 "table" {0 \a 1 \b 2 \c}}
        "{\"key\":2, \"table\":{\"a\":0,\"b\":1,\"c\":2}}" {"key" 2 "table" {\a 0 \b 1 \c 2}}))
    (testing "The function generates the table, because the argument is a key."
      (are [json expected-data]
          (let [data (generate-table-or-decode-json json symbols)]
            (and (= (get expected-data "key")
                    (get data "key"))
                 (= (keys (get expected-data "table"))
                    (keys (get data "table"))))
             (generate-table-or-decode-json json symbols))
        "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}})))