Need to format output

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>7</source>
+                    <target>7</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
     <dependencies>
         <dependency>

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

@@ -1,4 +1,20 @@
 package io.zipcoder;
 
 public class ItemParseException extends Exception {
+
+    private static int count = 0;
+
+    public ItemParseException(String message)
+    {
+        super(message);
+
+        {
+            count++;
+        }
+    }
+
+    public static int getCount()
+    {
+        return count;
+    }
 }

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

@@ -2,6 +2,8 @@ package io.zipcoder;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 
 public class ItemParser {
 
@@ -12,12 +14,41 @@ public class ItemParser {
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public Item parseStringIntoItem(HashMap<String, String> itemMap) throws ItemParseException {
+
+        String name = null;
+        Double price = null;
+        String type = null;
+        String expiration = null;
+
+        if(checkForEmptyValues(itemMap)) {
+            throw new ItemParseException("Missing Values");
+        } else {
+            for (String key : itemMap.keySet()) {
+                if (key.matches("(?i:.*NAME.*)")) {
+                    if (!itemMap.get(key).equals(""))
+                        name = identifyName(itemMap.get(key));
+                }
+                if (key.matches("(?i:.*PRICE.*)")) {
+                    if (!itemMap.get(key).equals(""))
+                        price = Double.parseDouble(itemMap.get(key));
+                }
+                if (key.matches("(?i:.*TYPE.*)")) {
+                    if (!itemMap.get(key).equals(""))
+                        type = itemMap.get(key);
+                }
+                if (key.matches("(?i:.*EXPIRATION.*)")) {
+                    if (!itemMap.get(key).equals(""))
+                        expiration = itemMap.get(key);
+                }
+            }
+        }
+
+        return new Item(name, price, type, expiration);
     }
 
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
+        String stringPattern = "[:!;^%*@!]";
         ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
         return response;
     }
@@ -26,6 +57,36 @@ public class ItemParser {
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
     }
 
+    public HashMap<String, String> mapKeysAndValuesOfItem(String rawItem) {
+        ArrayList<String> item = findKeyValuePairsInRawItemData(rawItem);
+        HashMap<String, String> itemMap = new HashMap<String, String>();
+        for (int i = 0; i < item.size(); i+=2) {
+            itemMap.put(item.get(i), item.get(i+1));
+        }
+        return itemMap;
+    }
 
+    public boolean checkForEmptyValues(HashMap<String, String> itemMap) {
+        for(String s: itemMap.keySet()) {
+        if(itemMap.get(s).equals("")) {
+            return true;
+            }
+        }
+        return false;
+    }
+
+
+    public String identifyName(String input) {
+        if(input.matches("(?i:.*bread.*)"))
+            return "bread";
+        if(input.matches("(?i:.*milk.*)"))
+            return "milk";
+        if(input.matches("(?i:.*apples.*)"))
+            return "apples";
+        if(input.matches("[Cc][Oo0]{2}(?i:.*kies.*)"))
+            return "cookies";
+
+        return null;
+    }
 
 }

src/main/java/io/zipcoder/Items.java

@@ -0,0 +1,97 @@
+package io.zipcoder;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class Items extends ArrayList<Item>{
+
+    public Items getMilks() {
+        Items milkItems = new Items();
+        for(Item item : this) {
+            if(item.getName().equalsIgnoreCase("Milk")) {
+                milkItems.add(item);
+            }
+        }
+        return milkItems;
+    }
+
+    public Items getBread() {
+        Items breadItems = new Items();
+        for(Item item : this) {
+            if(item.getName().equalsIgnoreCase("Bread")) {
+                breadItems.add(item);
+            }
+        }
+        return breadItems;
+    }
+
+    public Items getCookies() {
+        Items cookiesItems = new Items();
+        for(Item item : this) {
+            if(item.getName().equalsIgnoreCase("Cookies")) {
+                cookiesItems.add(item);
+            }
+        }
+        return cookiesItems;
+    }
+
+    public Items getApples() {
+        Items applesItems = new Items();
+        for(Item item : this) {
+            if(item.getName().equalsIgnoreCase("Apples")) {
+                applesItems.add(item);
+            }
+        }
+        return applesItems;
+    }
+
+    public HashMap<Double, Integer> getPriceCount() {
+
+        HashMap<Double, Integer> priceMap = new HashMap<>();
+
+        for(Item item : this) {
+            if(priceMap.containsKey(item.getPrice())) {
+                int count = priceMap.get(item.getPrice());
+                count = count + 1;
+                priceMap.put(item.getPrice(), count);
+            } else {
+                priceMap.put(item.getPrice(), 1);
+            }
+        }
+
+        return priceMap;
+    }
+
+    public static String prettyOutput(Items milk, HashMap<Double, Integer> milkPrices, Items bread, HashMap<Double, Integer> breadPrices, Items cookies, HashMap<Double, Integer> cookiesPrices, Items apples, HashMap<Double, Integer> applesPrices) {
+
+        String result = "name: " + "Milk " + "seen: " + milk.size() + " times\n" +
+                "====================\n";
+            for(Double priceM : milkPrices.keySet()) {
+                result += "Price: " + priceM + " seen: " + milkPrices.get(priceM) + " times\n" +
+                "---------------------\n";
+            }
+            result += "\nname: " + "Bread " + "seen: " + bread.size() + " times\n" +
+                    "====================\n";
+        for(Double priceB : breadPrices.keySet()) {
+            result += "Price: " + priceB + " seen: " + breadPrices.get(priceB) + " times\n" +
+                    "---------------------\n";
+        }
+        result += "\nname: " + "Cookies " + "seen: " + cookies.size() + " times\n" +
+                "====================\n";
+        for(Double priceC : cookiesPrices.keySet()) {
+            result += "Price: " + priceC + " seen: " + cookiesPrices.get(priceC) + " times\n" +
+                    "---------------------\n";
+        }
+        result += "\nname: " + "Apples " + "seen: " + apples.size() + " times\n" +
+                "====================\n";
+        for(Double priceA : applesPrices.keySet()) {
+            result += "Price: " + priceA + " seen: " + applesPrices.get(priceA) + " times\n" +
+                    "---------------------\n";
+        }
+        result += "\nErrors    seen: " + ItemParseException.getCount() + " times";
+
+        return result;
+
+    }
+
+}

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

@@ -2,6 +2,9 @@ package io.zipcoder;
 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+
 
 public class Main {
 
@@ -11,9 +14,33 @@ public class Main {
         return result;
     }
 
-    public static void main(String[] args) throws Exception{
+    public static void main(String[] args) throws Exception {
         String output = (new Main()).readRawDataToString();
+        ItemParser itemParser = new ItemParser();
+        ArrayList<String> strItems = itemParser.parseRawDataIntoStringArray(output);
+        Item item = null;
+        Items items = new Items();
+        for(String itemStr : strItems) {
+            HashMap<String, String> itemMap = itemParser.mapKeysAndValuesOfItem(itemStr);
+
+            try {
+                item = itemParser.parseStringIntoItem(itemMap);
+                items.add(item);
+            } catch (ItemParseException e) {
+            }
+
+        }
+        Items milkItems = items.getMilks();
+        HashMap<Double, Integer> milkPrices = milkItems.getPriceCount();
+        Items breadItems = items.getBread();
+        HashMap<Double, Integer> breadPrices = breadItems.getPriceCount();
+        Items cookieItems = items.getCookies();
+        HashMap<Double, Integer> cookiePrices = cookieItems.getPriceCount();
+        Items appleItems = items.getApples();
+        HashMap<Double, Integer> applePrices = appleItems.getPriceCount();
+
+        output = Items.prettyOutput(milkItems, milkPrices, breadItems, breadPrices, cookieItems, cookiePrices, appleItems, applePrices);
+
         System.out.println(output);
-        // TODO: parse the data in output into items, and display to console.
     }
 }

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:;price:3.23;type:Food;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##"
@@ -36,27 +36,30 @@ 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);
+        Item expected = new Item("milk", 3.23, "Food","1/25/2016");
+        ArrayList<String> itemArray = itemParser.parseRawDataIntoStringArray(rawSingleItem);
+        Item actual = itemParser.parseStringIntoItem(itemParser.mapKeysAndValuesOfItem(itemArray.get(0)));
         assertEquals(expected.toString(), actual.toString());
     }
 
     @Test(expected = ItemParseException.class)
     public void parseBrokenStringIntoItemTest() throws ItemParseException{
-        itemParser.parseStringIntoItem(rawBrokenSingleItem);
-    }
+        ArrayList<String> itemArray = itemParser.parseRawDataIntoStringArray(rawBrokenSingleItem);
+        Item actual = itemParser.parseStringIntoItem(itemParser.mapKeysAndValuesOfItem(itemArray.get(0)));    }
 
     @Test
     public void findKeyValuePairsInRawItemDataTest(){
-        Integer expected = 4;
-        Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItem).size();
+        Integer expected = 8;
+        ArrayList<String> itemArray = itemParser.parseRawDataIntoStringArray(rawBrokenSingleItem);
+        Integer actual = itemParser.findKeyValuePairsInRawItemData(itemArray.get(0)).size();
         assertEquals(expected, actual);
     }
 
     @Test
     public void findKeyValuePairsInRawItemDataTestIrregular(){
-        Integer expected = 4;
-        Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
+        Integer expected = 8;
+        ArrayList<String> itemArray = itemParser.parseRawDataIntoStringArray(rawSingleItemIrregularSeperatorSample);
+        Integer actual = itemParser.findKeyValuePairsInRawItemData(itemArray.get(0)).size();
         assertEquals(expected, actual);
     }
 }