Crypto/src/ROT13.java

@@ -1,32 +0,0 @@
-import static java.lang.Character.isLowerCase;
-import static java.lang.Character.isUpperCase;
-import static java.lang.Character.toLowerCase;
-
-public class ROT13  {
-
-    ROT13(Character cs, Character cf) {
-    }
-
-    ROT13() {
-    }
-
-
-    public String crypt(String text) throws UnsupportedOperationException {
-
-        return "";
-    }
-
-    public String encrypt(String text) {
-        return text;
-    }
-
-    public String decrypt(String text) {
-        return text;
-    }
-
-    public static String rotate(String s, Character c) {
-
-        return "";
-    }
-
-}

pom.xml

@@ -8,5 +8,16 @@
     <artifactId>SimpleCrypt</artifactId>
     <version>1.0-SNAPSHOT</version>
 
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+    </dependencies>
 
 </project>

src/main/java/AtbashCipher.java

@@ -0,0 +1,83 @@
+import java.io.*;
+
+import java.util.HashMap;
+import java.util.stream.Stream;
+
+
+public class AtbashCipher{
+
+    private static final String abc = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz";
+    private static final String cba = "ZzYyXxWwVvUuTtSsRrQqPpOoNnMmLlKkJjIiHhGgFfEeDdCcBbAa";
+    private static final HashMap<Character, Character> key = new HashMap<>();
+
+    public AtbashCipher() {
+        createKey();
+    }
+
+    private void createKey() {
+        char[] abcArr = abc.toCharArray();
+        char[] cbaArr = cba.toCharArray();
+
+        for (int i = 0; i < abcArr.length; i++) {
+            key.put(abcArr[i], cbaArr[i]);
+        }
+    }
+
+    public static String cipher(String s) {
+        char[] charArray = s.toCharArray();
+
+        for (int i = 0; i < charArray.length; i++) {
+            if (key.containsKey(charArray[i])) {
+                charArray[i] = key.get(charArray[i]);
+            }
+        }
+        return charArrayToString(charArray);
+    }
+
+    public  static String charArrayToString(char[] chars) {
+        StringBuilder sb = new StringBuilder();
+        for (char c: chars) {
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    public void cipherFile(String filePathIn, String filePathOut) throws FileNotFoundException {
+        String inFile = fileToString(filePathIn);
+
+        PrintStream file = new PrintStream(new File(filePathOut));
+        PrintStream console = System.out;
+
+        System.setOut(file);
+
+        String swappedChars = Stream.of(inFile)
+                .map(AtbashCipher::cipher)
+                .reduce("", String::concat);
+
+        System.out.println(swappedChars);
+        System.setOut(console);
+    }
+
+
+    private String fileToString(String filePath) throws FileNotFoundException {
+
+        File file = new File(filePath);
+
+        FileReader fReader = new FileReader(file);
+        BufferedReader bufferedReader = new BufferedReader(fReader);
+
+        StringBuilder sb = new StringBuilder();
+        String line;
+
+        try {
+            while ((line = bufferedReader.readLine()) != null) {
+                sb.append(line + "\n");
+            }
+        } catch (IOException e) {
+            System.out.println("Error reading file");
+        }
+
+        return sb.toString();
+    }
+
+}

src/main/java/CaeserCipher.java

@@ -0,0 +1,45 @@
+public class CaeserCipher extends ROT13 {
+    // takes in a shift and then returns an encoded string of the letter shift
+
+    public CaeserCipher(int shift) {
+        super.setShift(shift);
+    }
+
+    public String encrypt(String s) {
+        StringBuilder sb = new StringBuilder();
+
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (c >= 'a' && c <= 'z') {
+                sb.append((char) ((c - 'a' + getShift()) % 26 + 'a'));
+
+            } else if (c >= 'A'  && c <= 'Z') {
+                sb.append((char)((c - 'A' + getShift()) % 26 + 'A'));
+
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    public String decrypt(String s) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (c >= 'a' && c <= 'z') {
+                sb.append((char) ((c + 'a' - getShift()) % 26 + 'a'));
+
+            } else if (c >= 'A'  && c <= 'Z') {
+                sb.append((char)((c + 'A' - getShift()) % 26 + 'A'));
+
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+
+    }
+}

src/main/java/ROT13.java

@@ -0,0 +1,75 @@
+import static java.lang.Character.isLowerCase;
+import static java.lang.Character.isUpperCase;
+import static java.lang.Character.toLowerCase;
+
+public class ROT13  {
+    private int shift;
+
+    ROT13(Character cs, Character cf) {
+        shift = cf - cs;
+        // With this constructor, we are finding how much to rotate by
+        // UP TO CF, not including
+    }
+
+    ROT13() {
+        shift = 13;
+    }
+
+    public int getShift() {
+        return shift;
+    }
+
+    public void setShift(int shift) {
+        this.shift = shift;
+    }
+
+    public String crypt(String text) throws UnsupportedOperationException {
+        StringBuilder sb = new StringBuilder();
+        // only 26 letters in the alphabet, with the 13 shift, the crpt and encrypt are equal
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c >= 'a' && c <= 'm') {
+                c += shift;
+                sb.append(c);
+            } else if (c >= 'A' && c <= 'M') {
+                c += shift;
+                sb.append(c);
+            } else if (c >= 'n' && c <= 'z') {
+                c -= shift;
+                sb.append(c);
+            } else if (c >= 'N' && c <= 'Z') {
+                c -= shift;
+                sb.append(c);
+            } else {
+                sb.append(c);
+            }
+        }
+        // we are rotating each letter, not shifting
+        return sb.toString();
+    }
+
+    public String encrypt(String text) {
+        return crypt(text);
+    }
+
+    public String decrypt(String text) {
+        return crypt(text);
+    }
+
+    public static String rotate(String s, Character c) {
+        // shifting the string so that C is the first character
+        // Find where c is
+        int index = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == c) {
+                index = i;
+                break;
+            }
+        }
+
+        int rotation = index % s.length();
+
+        return s.substring(rotation) + s.substring(0, index);
+    }
+
+}

src/test/java/AtbashCipherTest.java

@@ -0,0 +1,47 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.BufferedReader;;
+import java.io.FileReader;
+import java.io.IOException;
+
+
+public class AtbashCipherTest {
+
+    @Test
+    public void testCipher() {
+        AtbashCipher cipher = new AtbashCipher();
+        String test = "ABCDEF";
+        String exp = "ZYXWVU";
+
+        String actual = cipher.cipher(test);
+
+        Assert.assertEquals(exp, actual);
+    }
+
+    @Test
+    public void testFiles() throws IOException {
+
+        AtbashCipher cipher = new AtbashCipher();
+
+        String inputFile = "sonnet18.txt";
+        String outputTest = "testFileOutput.txt";
+        String decryptTest = "decryptedTestFile.txt";
+
+        cipher.cipherFile(inputFile, outputTest);
+        cipher.cipherFile(outputTest, decryptTest);
+
+        BufferedReader bROriginal = new BufferedReader(new FileReader(inputFile));
+        BufferedReader bRDecyphered = new BufferedReader(new FileReader(decryptTest));
+
+        String originalLine;
+        String decrpytLine;
+
+        while ((originalLine = bROriginal.readLine()) != null) {
+            decrpytLine = bRDecyphered.readLine();
+            Assert.assertEquals(originalLine, decrpytLine);
+        }
+
+
+    }
+}

src/test/java/CaeserCipherTest.java

@@ -0,0 +1,36 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CaeserCipherTest {
+
+    @Test
+    public void testCaesar() {
+        CaeserCipher cc = new CaeserCipher(23);
+
+
+        String text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String expected = "XYZABCDEFGHIJKLMNOPQRSTUVW";
+
+        String actual = cc.encrypt(text);
+        System.out.println(actual);
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testDecrypt() {
+        CaeserCipher cc = new CaeserCipher(23);
+
+        String text = "XYZABCDEFGHIJKLMNOPQRSTUVW";
+        String exp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+        String actual = cc.decrypt(text);
+
+        Assert.assertEquals(exp, actual);
+
+
+
+    }
+}

Crypto/src/ROT13Test.java → src/test/java/ROT13Test.java

@@ -1,3 +1,4 @@
+import org.junit.Assert;
 import org.junit.Test;
 
 import static org.junit.Assert.*;
@@ -60,9 +61,10 @@ public class ROT13Test {
         String A2 = "To get to the other side!";
 
         // When
-        String actual = cipher.encrypt(Q1);
-        System.out.println(Q1);
-        System.out.println(A1);
+        String actual = cipher.crypt(Q1);
+        System.out.println("Actual: " + actual);
+        System.out.println("Q1: " + Q1);
+        System.out.println("A1: " + A1);
         // Then
         assertTrue(actual.equals(A1));
 
@@ -88,4 +90,10 @@ public class ROT13Test {
         assertTrue(actual.equals(Q1));
     }
 
+    @Test
+    public void testRotation() {
+        ROT13 cipher = new ROT13('a', 'n');
+        System.out.println(cipher.getShift());
+    }
+
 }