Refactor to move actions to separated files.

src/cipher_analytical_machine/analyzers/caesar.clj

@@ -1,8 +1,10 @@
 (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))
 
@@ -50,10 +52,13 @@
 
 (defn frequency-analizer-get-plaintext
   "Return the plaintext from a ciphertext using simple analizer. The function is case-insensitive."
-  [ciphertext symbols letter-frequencies-string]
+  [ciphertext symbols letter-frequencies-string language-code]
   (let [decrypt (reify Decrypted
                   (decrypt [this message key symbols]
-                    (caesar/decrypt-message message key symbols)))]
-    (-> (new FrequencyAnalyzer ciphertext symbols letter-frequencies-string decrypt)
+                    (caesar/decrypt-message message key symbols)))
+        is-nonsense (reify IsNonsense
+                  (isNonsense [this message]
+                    (language/is-nonsense? message language-code)))]
+    (-> (new FrequencyAnalyzer ciphertext symbols letter-frequencies-string decrypt is-nonsense)
         .crack)))
 

src/cipher_analytical_machine/cli/actions/cracking.clj

@@ -0,0 +1,26 @@
+(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))))
+

src/cipher_analytical_machine/cli/actions/cryptography.clj

@@ -0,0 +1,24 @@
+(ns cipher-analytical-machine.cli.actions.cryptography
+  (:require
+   [cipher-analytical-machine.ciphers.caesar :as caesar])
+  (: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 cryptography-actions
+  [options arguments action-type]
+  (let [cipher (:cipher options)]
+    (cond
+      (= cipher "Caesar")
+      (caesar-actions options arguments action-type))))
+

src/cipher_analytical_machine/cli/cli.clj

@@ -1,12 +1,11 @@
 (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.symbols.frequencies :as symbol-frequencies]
    [cipher-analytical-machine.cli.options :as options]
    [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))
 
@@ -148,50 +147,16 @@
     (save-output output options))
   (println output))
 
-(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)
-
-      (= analyzer "Frequency")
-      (caesar-analyzers/frequency-analizer-get-plaintext message symbols
-                                                         (symbol-frequencies/map-to-string frequencies)))))
-
-(defn cracking-actions
-  [options arguments action-type]
-  (let [cipher (:cipher options)]
-    (cond
-      (= cipher "Caesar")
-      (cracking-caesar options arguments)
-      )))
-
-(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)
-       (crypt-actions options arguments action-type)
+       (cryptography/cryptography-actions options arguments action-type)
 
        (= action-type :cracking)
-       (cracking-actions options arguments action-type))
+       (cracking/cracking-actions options arguments action-type))
 
      (show-and-save-output options))))
 

src/main/java/cipher_analytical_machine/analyzers/caesar/FrequencyAnalyzer.java

@@ -1,25 +1,53 @@
 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) {
-	this.ciphertext = ciphertext;
-	this.key = 1;
-	this.symbols = symbols;
-	this.symbol_frequences = symbol_frequences;
-	this.decryptor = decryptor;
+    public FrequencyAnalyzer(String ciphertext, String symbols, String symbol_frequences, Decrypted decryptor, IsNonsense isNonsense) {
+	    this.ciphertext = ciphertext;
+        this.symbol_frequences = symbol_frequences;
+        this.symbols = symbols;
+	    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);
     }
 }
 

src/main/java/cipher_analytical_machine/analyzers/caesar/IsNonsense.java

@@ -0,0 +1,6 @@
+package cipher_analytical_machine.analyzers.caesar;
+
+public interface IsNonsense {
+    boolean isNonsense(String message);
+}
+