pom.xml

     <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/Item.java

     public String toString(){
         return "name:" + name + " price:" + price + " type:" + type + " expiration:" + expiration;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        Item otherItem = (Item) o;
+        if(!this.getName().equalsIgnoreCase(((Item) o).getName()))
+            return false;
+        if(!this.getType().equalsIgnoreCase(((Item) o).getType()))
+            return false;
+        if(!this.getPrice().equals(((Item) o).getPrice()))
+            return false;
+        if(!this.getExpiration().equalsIgnoreCase(((Item) o).getExpiration()))
+            return false;
+
+        return true;
+    }
 }

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

 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

 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 
 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;
     }
         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

+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 = String.format("%-8s %4s %12s %d %6s", "name:", "Milk", "seen:", milk.size(), "times\n") +
+                String.format("%12s %6s %13s", "=============", "", "=============\n");
+        for(Double priceM : milkPrices.keySet()) {
+                result += String.format("%-8s %.2f %12s %d %6s", "Price:", priceM, "seen:", milkPrices.get(priceM), "times\n") +
+                        String.format("%12s %6s %13s", "-------------", "", "-------------\n");
+            }
+
+            result += String.format("%-8s %4s %12s %d %6s", "\nname:", "Bread", "seen:", bread.size(), "times\n") +
+                String.format("%12s %6s %13s", "=============", "", "=============\n");
+        for(Double priceB : breadPrices.keySet()) {
+            result += String.format("%-8s %.2f %12s %d %6s", "Price:", priceB, "seen:", breadPrices.get(priceB), "times\n") +
+                    String.format("%12s %6s %13s", "-------------", "", "-------------\n");
+        }
+
+        result += String.format("%-5s %4s %12s %d %6s", "\nname:", "Cookies", "seen:", cookies.size(), "times\n") +
+                String.format("%12s %6s %13s", "=============", "", "=============\n");
+        for(Double priceC : cookiesPrices.keySet()) {
+            result += String.format("%-8s %.2f %12s %d %6s", "Price:", priceC, "seen:", cookiesPrices.get(priceC), "times\n") +
+                    String.format("%12s %6s %13s", "-------------", "", "-------------\n");
+        }
+
+        result += String.format("%-7s %4s %12s %d %6s", "\nname:", "Apples", "seen:", apples.size(), "times\n") +
+                String.format("%12s %6s %13s", "=============", "", "=============\n");
+        for(Double priceA : applesPrices.keySet()) {
+            result += String.format("%-8s %.2f %12s %d %6s", "Price:", priceA, "seen:", applesPrices.get(priceA), "times\n") +
+                    String.format("%12s %6s %13s", "-------------", "", "-------------\n");
+        }
+
+        result += String.format("%-12s %14s %d %5s", "\nErrors", "seen:", ItemParseException.getCount(), "times");
+
+        return result;
+
+    }
+
+}

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

 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+
 
 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

 
     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##"
     @Test
     public void parseStringIntoItemTest() throws ItemParseException{
         Item expected = new Item("milk", 3.23, "food","1/25/2016");
-        Item actual = itemParser.parseStringIntoItem(rawSingleItem);
-        assertEquals(expected.toString(), actual.toString());
+        ArrayList<String> itemArray = itemParser.parseRawDataIntoStringArray(rawSingleItem);
+        Item actual = itemParser.parseStringIntoItem(itemParser.mapKeysAndValuesOfItem(itemArray.get(0)));
+        assertEquals(expected, actual);
     }
 
     @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);
+    }
+
+    @Test
+    public void identifyNameTestCookieWithZero(){
+        String expected = "cookies";
+        String actual = itemParser.identifyName("C0oKies");
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void identifyNameTestNull(){
+        String expected = null;
+        String actual = itemParser.identifyName("bob");
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void identifyNameTestApples(){
+        String expected = "apples";
+        String actual = itemParser.identifyName("aPpLEs");
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void identifyNameTestBread(){
+        String expected = "bread";
+        String actual = itemParser.identifyName("BReAD");
         assertEquals(expected, actual);
     }
 }

src/test/java/io/zipcoder/ItemsTest.java

+package io.zipcoder;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.HashMap;
+
+public class ItemsTest {
+
+    Items items = new Items();
+
+    @Before
+    public void setUp() throws Exception {
+        Item item1 = new Item("Milk", 3.40, "Food", "11/12/2020");
+        Item item2 = new Item("Milk", 1.45, "Food", "11/12/2020");
+        Item item3 = new Item("Milk", 3.40, "Food", "12/5/2020");
+        Item item4 = new Item("Cookies", 1.75, "Food", "11/12/2020");
+        Item item5 = new Item("Apples", 0.75, "Food", "11/12/2020");
+        Item item6 = new Item("Bread", 1.00, "Food", "11/12/2020");
+        Item item7 = new Item("Bread", 1.40, "Food", "11/12/2020");
+        Item item8 = new Item("Bread", 1.00, "Food", "11/12/2020");
+
+        items.add(item1);
+        items.add(item2);
+        items.add(item3);
+        items.add(item4);
+        items.add(item5);
+        items.add(item6);
+        items.add(item7);
+        items.add(item8);
+    }
+
+    @Test
+    public void testGetMilk() {
+        Items milkItems = items.getMilks();
+        int expected = 3;
+        int actual = milkItems.size();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetBread() {
+        Items breadItems = items.getBread();
+        int expected = 3;
+        int actual = breadItems.size();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetCookies() {
+        Items cookieItems = items.getCookies();
+        int expected = 1;
+        int actual = cookieItems.size();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetApples() {
+        Items appleItems = items.getApples();
+        int expected = 1;
+        int actual = appleItems.size();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetMilkPrices() {
+        Items milkItems = items.getMilks();
+        HashMap<Double, Integer> milkPrices = milkItems.getPriceCount();
+        Assert.assertEquals(2, (int) milkPrices.get(3.40));
+        Assert.assertEquals(1, (int) milkPrices.get(1.45));
+    }
+}