Refactor the project structure.

src/cipher_analytical_machine/analyzers/analyzers.clj

@@ -0,0 +1,38 @@
+(ns cipher-analytical-machine.analyzers.analyzers
+  (:require [clojure.string :as cs])
+  (:gen-class))
+
+(defn count-characters
+  "Count the letters and return map."
+  [text]
+  (reduce
+   (fn [acc val]
+     (assoc acc val
+            (inc (get acc val 0))))
+   {} text))
+
+(defn chi-squared-letter-statistic
+  "To calculate the frequency distribution of a letter."
+  [letter-count letter-frequence length-text]
+  (let [letter-frequence (* length-text letter-frequence)]
+    (/ (Math/pow
+        (- letter-count letter-frequence) 2)
+       letter-frequence)))
+
+(defn chi-squared-statistic
+  "To calculate the frequency distribution of a language. More detail about the algorithm here: http://practicalcryptography.com/cryptanalysis/text-characterisation/chi-squared-statistic/"
+  [text letter-frequences]
+  (let [length-text (count text)
+        letter-counts (count-characters (cs/lower-case text))]
+    ;letter-counts
+    (reduce
+     (fn [acc [char count]]
+       (+ acc
+          (if (contains? letter-frequences char)
+            (chi-squared-letter-statistic count
+                                          (get letter-frequences char)
+                                          length-text)
+            0)))
+            0
+            letter-counts)))
+

src/cipher_analytical_machine/analyzers/caesar.clj

@@ -0,0 +1,59 @@
+(ns cipher-analytical-machine.analyzers.caesar
+  (:require [cipher-analytical-machine.ciphers.caesar :as caesar]
+            [clojure.string :as cs]
+            [cipher-analytical-machine.analyzers.analyzers :as ca])
+  (:import [cipher_analytical_machine.ciphers.caesar Decrypted]
+           [cipher_analytical_machine.analyzers.caesar FrequencyAnalyzer])
+  (:gen-class))
+
+(defn get-all-texts
+  "Return a list of pairs which have a key and a second posible plaintext."
+  [ciphertext symbols]
+  (let [keys (range (count symbols))]
+    (reduce
+     (fn [acc key]
+       (conj acc [key (caesar/decrypt-message ciphertext key symbols)]))
+     '() keys)))
+
+(defn get-all-scores
+  "For pairs (key, plaintext) finds scores and return list of pairs [key, score]."
+  [letter-frequences pairs]
+  (map (fn [[key text]]
+         [key (ca/chi-squared-statistic text letter-frequences)])
+       pairs))
+
+(defn get-min-score-pair
+  "For pairs (key, plaintext) finds scores and return list of pairs [key, score]."
+  [pairs]
+  (reduce
+   (fn [[key value] [new-key new-value]]
+     (if (> value new-value) [new-key new-value]
+         [key value]))
+   [0 Double/MAX_VALUE]
+   pairs))
+
+(defn get-key
+  "To find the key with frequencies of letters."
+  [ciphertext symbols letter-frequences]
+  (->> (get-all-texts ciphertext symbols)
+       (get-all-scores letter-frequences)
+       (get-min-score-pair)
+       (first)))
+
+(defn get-plaintext
+  "Return the plaintext from a ciphertext. The function is case-insensitive."
+  [ciphertext symbols letter-frequences]
+  (let [ciphertext (cs/lower-case ciphertext)]
+    (caesar/decrypt-message ciphertext
+                            (get-key ciphertext symbols letter-frequences)
+                            symbols)))
+
+(defn frequency-analizer-get-plaintext
+  "Return the plaintext from a ciphertext using simple analizer. The function is case-insensitive."
+  [ciphertext symbols letter-frequences]
+  (let [decrypt (reify Decrypted
+                  (decrypt [this message key symbols]
+                    (caesar/decrypt-message message key symbols)))]
+    (-> (new FrequencyAnalyzer ciphertext symbols letter-frequences decrypt)
+        .crack)))
+

src/cipher_analytical_machine/analyzers/language.clj

@@ -0,0 +1,21 @@
+(ns cipher-analytical-machine.analyzers.language
+  (:import [org.apache.tika.language LanguageIdentifier])
+  (:gen-class))
+
+(defn detect-language
+  "Return a identified language."
+  [text]
+  (-> (new LanguageIdentifier text)
+      .getLanguage))
+
+(defn is-language?
+  "Check if the text written a language."
+  [text language-id]
+  (= (detect-language text)
+     language-id))
+
+(defn is-nonsense?
+  "Check if the text written a language is not a language."
+  [text language-id]
+  (not (is-language? text language-id)))
+