Merge 33d3b2a8c1e0e9e25ec43e0b9bd2eb2986b7e0a0 into 23c2c01bf07b924ac9b860fa2771bf6ceb246ad5

src/main/java/io/zipcoder/Item.java

@@ -26,17 +26,12 @@ public class Item {
         return name;
     }
 
-
-    public Double getPrice() {
-        return price;
-    }
-
+    public Double getPrice() { return price; }
 
     public String getType() {
         return type;
     }
 
-
     public String getExpiration() {
         return expiration;
     }

src/main/java/io/zipcoder/ItemParseException.java

@@ -1,4 +1,8 @@
 package io.zipcoder;
 
 public class ItemParseException extends Exception {
+
+    public ItemParseException(){
+
+    }
 }

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

@@ -2,30 +2,112 @@ package io.zipcoder;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import static java.util.regex.Pattern.CASE_INSENSITIVE;
+import static java.util.regex.Pattern.LITERAL;
 
 public class ItemParser {
 
+    private static int exceptionCounter;
+
+    public ItemParser(){
+        exceptionCounter = 0;
+    }
+
+    public int getExceptionCounter(){
+        return exceptionCounter;
+    }
 
     public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+        String normalizedRawData = normalizeRawData(rawData);
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , normalizedRawData);
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public ArrayList<Item> stringArrayToItemArray(ArrayList<String> rawItems)throws ItemParseException{
+        ArrayList<Item> itemArray = new ArrayList<>();
+        for(String item: rawItems){
+            Item it = parseStringIntoItem(item);
+            if(!it.getName().equals("")) {
+                itemArray.add(it);
+            }
+        }
+        return itemArray;
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
-        return response;
+    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
+        String name = "";
+        String priceString = "";
+        Double price = 0.00;
+        String type = "";
+        String expiration = "";
+        Pattern pattern = Pattern.compile("name:(\\w*);price:(\\d*.\\d*\\d*);type:(\\w*);expiration:(\\w*/\\w*/\\w*)");
+        Matcher matcher = pattern.matcher(rawItem);
+        if(matcher.find()) {
+            try {
+                name = matcher.group(1);
+                priceString = matcher.group(2);
+                price = Double.parseDouble(priceString);
+                type = matcher.group(3);
+                expiration = matcher.group(4);
+                if (name.length() == 0 || priceString.length() == 0 || type.length() == 0 || expiration.length() == 0) {
+                    exceptionCounter++;
+                    throw new ItemParseException();
+                }
+            } catch (ItemParseException e) {
+                exceptionCounter++;
+            }
+        }
+        return new Item(name, price, type, expiration);
     }
 
     private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
     }
 
+    public String normalizeRawData(String rawData){
+        String normal = convertWeirdCharactersToSemiColon(rawData);
+        String normal2 = toLowerCaseString(normal);
+        return remove0FromCookie(normal2);
+    }
+
+    public String convertWeirdCharactersToSemiColon(String rawData) {
+        ArrayList<String> wierdCharacters = new ArrayList<>(Arrays.asList("^", "!", "*", "%"));
+        Pattern pattern = Pattern.compile("@");
+        Matcher matcher = pattern.matcher(rawData);
+        String unWeird = matcher.replaceAll(";");
+        for (String character : wierdCharacters) {
+            matcher.reset(unWeird);
+            matcher.usePattern(Pattern.compile(character, Pattern.LITERAL));
+            unWeird = matcher.replaceAll(";");
+        }
+        return unWeird;
+    }
+
+    public String toLowerCaseString(String rawData){
+        ArrayList<String> upperCase = new ArrayList<>(Arrays.asList("A","B","C","D","E","F","G","H","I","J",
+                "K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"));
+        ArrayList<String> lowerCase = new ArrayList<>(Arrays.asList("a","b","c","d","e","f","g","h","i","j",
+                "k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"));
+        Pattern pattern = Pattern.compile("A");
+        Matcher matcher = pattern.matcher(rawData);
+        String lower = matcher.replaceAll("a");
+        for(int i = 1; i<upperCase.size(); i++){
+            matcher.reset(lower);
+            matcher.usePattern(Pattern.compile(upperCase.get(i)));
+            lower = matcher.replaceAll(lowerCase.get(i));
+        }
+        return lower;
+    }
+
+    public String remove0FromCookie(String rawData){
+        Pattern pattern = Pattern.compile("c..kie");
+        Matcher matcher = pattern.matcher(rawData);
+        return matcher.replaceAll("cookie");
+
+    }
 
 
 }

src/main/java/io/zipcoder/ListCreation.java

@@ -0,0 +1,110 @@
+package io.zipcoder;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ListCreation {
+
+    private ItemParser parser;
+
+    public ListCreation() {
+        this.parser = new ItemParser();
+    }
+
+    public String rawStringToFinishedGroceryList(String raw) throws Exception {
+        ArrayList<String> rawItems = parser.parseRawDataIntoStringArray(raw);
+        ArrayList<Item> groceryList = parser.stringArrayToItemArray(rawItems);
+        return formattedGroceryListString(groceryList);
+    }
+
+    public String formattedGroceryListString(ArrayList<Item> groceryList) {
+        LinkedHashMap<Double,Integer> priceOccur = new LinkedHashMap<>();
+        String list = "";
+        for (String key : keySet(groceryList)) {
+            Pattern p = Pattern.compile(key);
+            Matcher matcher = p.matcher(keyString(groceryList));
+            int x = 0;
+            while (matcher.find()) {
+                x++;
+            }
+            if (x > 0) {
+                if(x == 1){
+                    list += String.format("name:%1$8s       seen: %2$d time \n=============       =============\n", key, x);
+                }else{
+                    list += String.format("name:%1$8s       seen: %2$d times\n=============       =============\n", key, x);
+                }
+                priceOccur = valueCount(groceryList, key);
+                list += printValues(priceOccur);
+            }
+        }
+        int errors = parser.getExceptionCounter();
+        list += String.format("Errors              seen: %d times",errors);
+        list = namesToCaps(list);
+        return list;
+    }
+
+    public LinkedHashSet<String> keySet(ArrayList<Item> groceryList) {
+        LinkedHashSet<String> keys = new LinkedHashSet<>();
+        for (Item item : groceryList) {
+            keys.add(item.getName());
+        }
+        return keys;
+    }
+
+    public String keyString(ArrayList<Item> groceryList) {
+        String keys = "";
+        for (Item item : groceryList) {
+            keys += item.getName();
+        }
+        return keys;
+    }
+
+    public LinkedHashMap<Double, Integer> valueCount(ArrayList<Item> groceryList,String key) {
+        LinkedHashMap<Double, Integer> priceOccurrences = new LinkedHashMap<>();
+        for (Item item : groceryList) {
+            Double price = item.getPrice();
+            if (key.equals(item.getName())) {
+                if (!priceOccurrences.containsKey(item.getPrice())) {
+                    priceOccurrences.put(price, 1);
+                } else if (priceOccurrences.containsKey(item.getPrice())) {
+                    priceOccurrences.replace(price, (priceOccurrences.get(price) + 1));
+                }
+            }
+        }
+        return priceOccurrences;
+    }
+
+    private String printValues(LinkedHashMap<Double, Integer> priceOccurrences) {
+        String valuesAndOccurrences = "";
+        for (Map.Entry<Double, Integer> entry : priceOccurrences.entrySet()) {
+            if(entry.getValue().equals(1)) {
+                valuesAndOccurrences += String.format("Price:   %1$.2f       seen: %2$d time \n", entry.getKey(), entry.getValue());
+            } else {
+                valuesAndOccurrences += String.format("Price:   %1$.2f       seen: %2$d times\n", entry.getKey(), entry.getValue());
+            }
+            valuesAndOccurrences += "-------------       -------------\n";
+
+        }
+        valuesAndOccurrences += "\n";
+        return valuesAndOccurrences;
+    }
+
+    public String namesToCaps(String groceryList){
+        String groceries = "";
+        ArrayList<String> itemsLower = new ArrayList<>(Arrays.asList("bread","cookies","apples"));
+        ArrayList<String> itemsUpper = new ArrayList<>(Arrays.asList("Bread","Cookies","Apples"));
+        Pattern p = Pattern.compile("milk");
+        Matcher m = p.matcher(groceryList);
+        groceries = m.replaceAll("Milk");
+        for(int i = 0; i<itemsLower.size(); i++){
+            m.reset(groceries);
+            m.usePattern(Pattern.compile(itemsLower.get(i)));
+            groceries = m.replaceAll(itemsUpper.get(i));
+        }
+        return groceries;
+    }
+
+}
+
+

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

@@ -2,12 +2,18 @@ package io.zipcoder;
 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+
 
 public class Main {
 
+    protected ListCreation listCreation = new ListCreation();
+
+
     public String readRawDataToString() throws Exception{
         ClassLoader classLoader = getClass().getClassLoader();
         String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
+        result = listCreation.rawStringToFinishedGroceryList(result);
         return result;
     }
 

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

@@ -14,7 +14,7 @@ public class ItemParserTest {
 
     private String rawSingleItemIrregularSeperatorSample = "naMe:MiLK;price:3.23;type:Food^expiration:1/11/2016##";
 
-    private String rawBrokenSingleItem =    "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+    private String rawBrokenSingleItem =    "naMe:Milk;price:3.23;type:;expiration:1/25/2016##";
 
     private String rawMultipleItems = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##"
                                       +"naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
@@ -26,6 +26,7 @@ public class ItemParserTest {
         itemParser = new ItemParser();
     }
 
+
     @Test
     public void parseRawDataIntoStringArrayTest(){
         Integer expectedArraySize = 3;
@@ -37,7 +38,8 @@ public class ItemParserTest {
     @Test
     public void parseStringIntoItemTest() throws ItemParseException{
         Item expected = new Item("milk", 3.23, "food","1/25/2016");
-        Item actual = itemParser.parseStringIntoItem(rawSingleItem);
+        String myNormalized = itemParser.normalizeRawData(rawSingleItem);
+        Item actual = itemParser.parseStringIntoItem(myNormalized);
         assertEquals(expected.toString(), actual.toString());
     }
 
@@ -47,16 +49,35 @@ public class ItemParserTest {
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTest(){
-        Integer expected = 4;
-        Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItem).size();
-        assertEquals(expected, actual);
+    public void testNormalizeRawData(){
+        String initial = "naMe:Co0kie@price:3.23%type:Food^expiration:1/11/2016##";
+        String expected = "name:cookie;price:3.23;type:food;expiration:1/11/2016##";
+        String actual = itemParser.normalizeRawData(initial);
+        Assert.assertEquals(expected, actual);
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTestIrregular(){
-        Integer expected = 4;
-        Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
-        assertEquals(expected, actual);
+    public void testToLowerCaseItem(){
+        String expected = rawSingleItem.toLowerCase();
+        String actual = itemParser.toLowerCaseString(rawSingleItem);
+        Assert.assertEquals(expected, actual);
     }
+
+    @Test
+    public void testConvertWeirdCharactersToSemiColon(){
+        String initial = "^!@*%";
+        String expected = ";;;;;";
+        String actual = itemParser.convertWeirdCharactersToSemiColon(initial);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testRemove0FromCookie(){
+        String initial = "c00kie";
+        String expected = "cookie";
+        String actual = itemParser.remove0FromCookie(initial);
+        Assert.assertEquals(expected, actual);
+    }
+
+
 }

src/test/java/io/zipcoder/ListCreationTest.java

@@ -0,0 +1,89 @@
+package io.zipcoder;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.*;
+
+public class ListCreationTest {
+
+    @Test
+    public void testRawToFinish() throws Exception {
+        ListCreation list = new ListCreation();
+        String raw = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016";
+        try {
+            String actual = list.rawStringToFinishedGroceryList(raw);
+            System.out.println(actual);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void testFormattedGroceryListString(){
+        //Given
+        ListCreation list = new ListCreation();
+        Item item1 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item2 = new Item("cookies", 2.50, "food", "12/03/2018");
+        Item item3 = new Item("apples", 0.35, "food","04/23/2018");
+        Item item4 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item5 = new Item("milk", 2.00, "food", "1/25/2016");
+        //When
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1,item2,item3,item4,item5));
+        //Then
+        String groceryList = list.formattedGroceryListString(itemObjects);
+        boolean expected = true;
+        boolean actual = groceryList.contains("Milk");
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testKeySet(){
+        ListCreation list = new ListCreation();
+        Item item1 = new Item("apples", 0.35, "food","04/23/2018");
+        Item item2 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item3 = new Item("milk", 2.00, "food", "1/25/2016");
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1,item2,item3));
+        LinkedHashSet<String> actual = list.keySet(itemObjects);
+        LinkedHashSet<String> expected = new LinkedHashSet<>(Arrays.asList("apples","milk"));
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testKeyString(){
+        ListCreation list = new ListCreation();
+        Item item1 = new Item("apples", 0.35, "food","04/23/2018");
+        Item item2 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item3 = new Item("milk", 2.00, "food", "1/25/2016");
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1, item2,item3));
+        String expected = "applesmilkmilk";
+        String actual = list.keyString(itemObjects);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testValueCount(){
+        ListCreation list = new ListCreation();
+        Item item1 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item2 = new Item("cookies", 2.50, "food", "12/03/2018");
+        Item item3 = new Item("apples", 0.35, "food","04/23/2018");
+        Item item4 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item5 = new Item("milk", 2.00, "food", "1/25/2016");
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1, item2, item3, item4, item5));
+        LinkedHashMap<Double,Integer> expected = new LinkedHashMap<>();
+        expected.put(3.23,2);
+        expected.put(2.00,1);
+        LinkedHashMap<Double,Integer> actual = list.valueCount(itemObjects, "milk");
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testNamesToCaps(){
+        ListCreation list = new ListCreation();
+        String initial = "cookies";
+        String expected = "Cookies";
+        String actual = list.namesToCaps(initial);
+        Assert.assertEquals(expected, actual);
+    }
+
+}

src/test/java/io/zipcoder/ListEntryPairTest.java

@@ -0,0 +1,18 @@
+package io.zipcoder;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ListEntryPairTest {
+
+    @Test
+    public void constructorTest(){
+        Item item = new Item("milk", 3.23, "food","1/25/2016");
+        String expectedName = "milk";
+        Double expectedPrice = 3.23;
+        String actualName = item.getName();
+        Double actualPrice = item.getPrice();
+        Assert.assertEquals(expectedName, actualName);
+        Assert.assertEquals(expectedPrice, actualPrice);
+    }
+}