about to delete some methods

pom.xml

@@ -7,6 +7,18 @@
     <groupId>io.zipcoder</groupId>
     <artifactId>PainfullAfternoon</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
     <dependencies>
         <dependency>

src/main/java/io/zipcoder/ItemParser.java

@@ -2,30 +2,202 @@ package io.zipcoder;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class ItemParser {
 
+    private Pattern pattern;
+    private Matcher matcher;
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    public ArrayList<String> parseRawDataIntoStringArray(String rawData) {
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawData);
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public ArrayList<ArrayList<String>> splitIntoPairs(ArrayList<String> list) {
+        ArrayList<ArrayList<String>> finalArray = new ArrayList<>();
+        for (int i = 0; i < list.size(); i++) {
+            ArrayList<String> tempArrayList = new ArrayList<>();
+            String[] tempArray = list.get(i).split("[;^!@%]");
+            for (int j = 0; j < tempArray.length; j++){
+                tempArrayList.add(tempArray[j]);
+            }
+            finalArray.add(tempArrayList);
+//            tempArrayList.addAll(Arrays.asList(tempArray));
+//            finalArray.get(i).addAll(tempArrayList);
+        }
+        return finalArray;
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
-        return response;
-    }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
-        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
-    }
+//    public ArrayList<String> splitPairs(ArrayList<String> textList) {
+//        ArrayList<String> tempList = new ArrayList<>();
+//        pattern = Pattern.compile("$[a-zA-Z0-9]");
+//
+//        for (String string : textList) {
+//             tempList.add(string.replace("$[a-zA-Z0-9]", ""));
+//        }
+//        return tempList;
+//    }
+
+        public ArrayList<String> splitPairs2 (ArrayList < String > textList) {
+            ArrayList<String> tempList = new ArrayList<>();
+            for (String string : textList) {
+                String[] tempArray = string.split(":");
+                tempList.addAll(Arrays.asList(tempArray));
+            }
+            return tempList;
+        }
+
+
+        public HashMap<String, String> createMap (ArrayList < String > list) {
+            HashMap<String, String> map = new HashMap<>();
+            pattern = Pattern.compile(":");
+            for (String item : list) {
+                correctSpelling(item);
+                String[] tempArray = pattern.split(item);
+                map.put(tempArray[0], tempArray[1]);
+            }
+            return map;
+        }
+
+        public Item parseStringIntoItem (String rawItem) throws ItemParseException {
+            return null;
+        }
+
+        public ArrayList<String> findKeyValuePairsInRawItemData (String rawItem){
+            String stringPattern = "[;|^]";
+            ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawItem);
+            return response;
+        }
+
+        public HashMap<String, String> mapKeyValuePairs (String rawItem){
+            ArrayList<String> groceryArrayList = parseRawDataIntoStringArray(rawItem);
+            pattern = Pattern.compile(":");
+//        matcher = pattern.matcher(rawItem);
+            HashMap<String, String> groceryListValues = new HashMap<>();
+            for (String item : groceryArrayList) {
+                matcher = pattern.matcher(item);
+                try {
+                    groceryListValues.put(matcher.group(), matcher.group());
+                } catch (IllegalStateException e) {
+                    e.printStackTrace();
+                }
+            }
+            return groceryListValues;
+        }
+
+        private ArrayList<String> splitStringWithRegexPattern (String stringPattern, String inputString){
+            return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+        }
+
+        public String correctSpelling (String text){
+            SpellingCorrector spellingCorrector = new SpellingCorrector();
+            return spellingCorrector.correctAllSpelling(text);
+        }
+
+        class SpellingCorrector {
 
+            String correctMilk(String text) {
+                pattern = Pattern.compile("Milk", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                return matcher.replaceAll("Milk");
+            }
 
+            String correctBread(String text) {
+                pattern = Pattern.compile("Bread", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                return matcher.replaceAll("Bread");
+            }
 
-}
+            String correctCookies(String text) {
+                pattern = Pattern.compile("Cookies|Co0kies", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                return matcher.replaceAll("Cookies");
+            }
+
+            String correctApples(String text) {
+                pattern = Pattern.compile("Apples", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                return matcher.replaceAll("Apples");
+            }
+
+            String correctName(String text) {
+                pattern = Pattern.compile("Name", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                return matcher.replaceAll("Name");
+            }
+
+            String correctPrice(String text) {
+                pattern = Pattern.compile("Price", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                return matcher.replaceAll("Price");
+            }
+
+            String correctAllSpelling(String text) {
+                String corrected = correctBread(text);
+                corrected = correctName(corrected);
+                corrected = correctApples(corrected);
+                corrected = correctCookies(corrected);
+                corrected = correctMilk(corrected);
+                corrected = correctPrice(corrected);
+                return corrected;
+            }
+        }
+
+        class OccurenceCounter {
+
+            int countOccurencesOfMilk(String text) {
+                int count = 0;
+                pattern = Pattern.compile("Milk", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                while (matcher.find()) {
+                    count++;
+                }
+                return count;
+            }
+
+            int countOccurencesOfBread(String text) {
+                int count = 0;
+                pattern = Pattern.compile("Bread", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                while (matcher.find()) {
+                    count++;
+                }
+                return count;
+            }
+
+            int countOccurencesOfApples(String text) {
+                int count = 0;
+                pattern = Pattern.compile("Apples", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                while (matcher.find()) {
+                    count++;
+                }
+                return count;
+            }
+
+            int countOccurencesOfCookies(String text) {
+                int count = 0;
+                pattern = Pattern.compile("Cookies| Co0kies|C00kies|C0okies", Pattern.CASE_INSENSITIVE);
+                matcher = pattern.matcher(text);
+                while (matcher.find()) {
+                    count++;
+                }
+                return count;
+            }
+
+            int[] countOccurencesOfAllItemsAlphabeticalOrder(String text) {
+                int[] itemArray = new int[4];
+                itemArray[0] = countOccurencesOfApples(text);
+                itemArray[1] = countOccurencesOfBread(text);
+                itemArray[2] = countOccurencesOfCookies(text);
+                itemArray[3] = countOccurencesOfMilk(text);
+                return itemArray;
+            }
+        }
+
+    }

src/main/java/io/zipcoder/Main.java

@@ -2,6 +2,12 @@ package io.zipcoder;
 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 
 public class Main {
 
@@ -13,7 +19,55 @@ public class Main {
 
     public static void main(String[] args) throws Exception{
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
+        ItemParser itemParser = new ItemParser();
+        ArrayList<String> whatever = itemParser.parseRawDataIntoStringArray(output);
+//        whatever.forEach(System.out::println);
+        HashMap<String, String> map = new HashMap<>();
+        ArrayList<ArrayList<String>> newList = itemParser.splitIntoPairs(whatever);
+//        ArrayList<String> parsed = itemParser.splitPairs2(newList);
+//        parsed.forEach(System.out::println);
+        System.out.println(newList.get(0).get(0));
+        System.out.println();
+        newList.forEach(System.out::println);
+
+
+//        map = itemParser.createMap(newList);
+//        map.entrySet().iterator().forEachRemaining(System.out::println);
+//        System.out.println(map.keySet());
+
+//        System.out.println(itemParser.splitIntoPairs(whatever));
+//        Pattern pattern = Pattern.compile("[:;@^*%]");
+//        Matcher matcher = pattern.matcher(output);
+//        HashMap<String, String> map = new HashMap<>();
+//        String[] temp = pattern.split(whatever.get(0));
+//        map.put(temp[0], temp[1]);
+//        map.put(temp[2], temp[3]);
+//        map.put(temp[4], temp[5]);
+//        map.put(temp[6], temp[7]);
+//        map.forEach((s, s2) -> System.out.println(s + ": " + s2));
+//        System.out.println();
+//        Pattern pattern2 = Pattern.compile("[;@^*%]");
+//        Matcher matcher2 = pattern.matcher(output);
+//        whatever.forEach(s -> { String[] temp2 = pattern2.split(whatever.get(whatever.indexOf(s)));
+//        for (String string : temp2) {
+//            map.put(temp2[0], temp2[1]);
+////            System.out.println(itemParser.correctSpelling(string));
+////            System.out.println();
+//        } });
+//        System.out.println(itemParser.correctSpelling(map.entrySet().toString()));
+//        for (int i = 0; i < temp.length; i++) {
+//
+//        }
+//        for (String string : temp) {
+//            System.out.println(string);
+//        }
+//        while (matcher.find()) {
+//            System.out.println(output.charAt(matcher.start()+1));
+//        }
+//        HashMap<String, String> pairs = itemParser.mapKeyValuePairs(output);
+//        pairs.forEach((s, s2) -> System.out.println(s + " " + s2));
+//        whatever.forEach(System.out::println);
+//        System.out.println(output);
         // TODO: parse the data in output into items, and display to console.
     }
 }

src/test/java/io/zipcoder/ItemParserTest.java

@@ -59,4 +59,112 @@ public class ItemParserTest {
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void correctBreadTest1() {
+        ItemParser.SpellingCorrector spellingCorrector = itemParser.new SpellingCorrector();
+        String text = "NAMe:BrEAD;price:1.23;type:Food;expiration:1/25/2016";
+        String expected = "NAMe:Bread;price:1.23;type:Food;expiration:1/25/2016";
+        String actual = spellingCorrector.correctBread(text);
+        assertEquals(expected,actual);
+    }
+
+    @Test
+    public void correctBreadTest2() {
+        ItemParser.SpellingCorrector spellingCorrector = itemParser.new SpellingCorrector();
+        String text = "BREAD";
+        String expected = "Bread";
+        String actual = spellingCorrector.correctBread(text);
+        assertEquals(expected,actual);
+    }
+
+    @Test
+    public void correctBreadNameTest1() {
+        ItemParser.SpellingCorrector spellingCorrector = itemParser.new SpellingCorrector();
+        String text = "NAME";
+        String expected = "Name";
+        String actual = spellingCorrector.correctName(text);
+        assertEquals(expected,actual);
+    }
+
+    @Test
+    public void correctBreadNameTest2() {
+        ItemParser.SpellingCorrector spellingCorrector = itemParser.new SpellingCorrector();
+        String text = "NAMe:BrEAD;price:1.23;type:Food;expiration:1/25/2016";
+        String expected = "Name:BrEAD;price:1.23;type:Food;expiration:1/25/2016";
+        String actual = spellingCorrector.correctName(text);
+        assertEquals(expected,actual);
+    }
+
+    @Test
+    public void correctAllSpellingTest() {
+        String text = "NAMe:BrEAD;price:1.23;type:Food;expiration:1/25/2016##naMe:appLEs;" +
+                "PRICE:2.50;name:COOKIES;PRicE:2.25;nAMe:MIlK";
+        String expected = "Name:Bread;Price:1.23;type:Food;expiration:1/25/2016##Name:Apples;" +
+                "Price:2.50;Name:Cookies;Price:2.25;Name:Milk";
+        String actual = itemParser.correctSpelling(text);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countOccurencesOfMilkTest() {
+        ItemParser.OccurenceCounter occurenceCounter = itemParser.new OccurenceCounter();
+        String text = "NAMe:milk;price:1.23;type:Food;expiration:1/25/2016##naMe:appLEs;" +
+                "PRICE:2.50;name:COOKIES;PRicE:2.25;nAMe:MIlK";
+        int expected = 2;
+        int actual = occurenceCounter.countOccurencesOfMilk(text);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countOccurencesOfBreadTest() {
+        ItemParser.OccurenceCounter occurenceCounter = itemParser.new OccurenceCounter();
+        String text = "NAMe:Bread;price:1.23;type:Food;expiration:1/25/2016##naMe:appLEs;" +
+                "PRICE:2.50;name:COOKIES;PRicE:2.25;nAMe:MIlK;name:BREAD;name:BrEAd";
+        int expected = 3;
+        int actual = occurenceCounter.countOccurencesOfBread(text);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countOccurencesOfApplesTest() {
+        ItemParser.OccurenceCounter occurenceCounter = itemParser.new OccurenceCounter();
+        String text = "NAMe:Bread;price:1.23;type:Food;expiration:1/25/2016##naMe:appLEs;" +
+                "PRICE:2.50;name:COOKIES;PRicE:2.25;nAMe:MIlK;name:BREAD;name:BrEAd";
+        int expected = 1;
+        int actual = occurenceCounter.countOccurencesOfApples(text);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countOccurencesOfCookiesTest() {
+        ItemParser.OccurenceCounter occurenceCounter = itemParser.new OccurenceCounter();
+        String text = "NAMe:Bread;price:1.23;type:Food;expiration:1/25/2016##naMe:appLEs;" +
+                "PRICE:2.50;name:COOKIES;PRicE:2.25;nAMe:MIlK;name:BREAD;name:cookies;name:c00kies";
+        int expected = 3;
+        int actual = occurenceCounter.countOccurencesOfCookies(text);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countOccurencesOfAllItemsTest1() {
+        ItemParser.OccurenceCounter occurenceCounter = itemParser.new OccurenceCounter();
+        String text = "NAMe:Bread;price:1.23;type:Food;expiration:1/25/2016##naMe:appLEs;" +
+                "PRICE:2.50;name:COOKIES;PRicE:2.25;nAMe:MIlK;name:BREAD;name:cookies;name:c00kies";
+        int expected = 3;
+        int actual = occurenceCounter.countOccurencesOfAllItemsAlphabeticalOrder(text)[2];
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countOccurencesOfAllItemsTest2() {
+        ItemParser.OccurenceCounter occurenceCounter = itemParser.new OccurenceCounter();
+        String text = "NAMe:Bread;price:1.23;type:Food;expiration:1/25/2016##naMe:appLEs;" +
+                "PRICE:2.50;name:COOKIES;PRicE:2.25;nAMe:MIlK;name:BREAD;name:cookies;name:c00kies";
+        int expected = 2;
+        int actual = occurenceCounter.countOccurencesOfAllItemsAlphabeticalOrder(text)[1];
+        assertEquals(expected, actual);
+    }
+
+
 }