it works

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>
@@ -19,5 +31,12 @@
             <artifactId>org.apache.commons.io</artifactId>
             <version>2.4</version>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+        </dependency>
+
     </dependencies>
 </project>

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

@@ -1,11 +1,29 @@
 package io.zipcoder;
 
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
 public class Item {
     private String name;
     private Double price;
     private String type;
     private String expiration;
 
+    Field[] fields = Item.class.getFields();
+
+    public Item() {
+
+    }
+
+    public ArrayList<String> getFieldNames() {
+        ArrayList<String> fieldNames = new ArrayList<>();
+        for (Field field : fields) {
+            fieldNames.add(field.getName());
+        }
+        return fieldNames;
+    }
+
     /**
      * Item should not be created unless you have all of the elements, which is why you are forcing
      * it to be set in the constructor. In ItemParser, if you do not find all the elements of a Item,
@@ -45,4 +63,5 @@ public class Item {
     public String toString(){
         return "name:" + name + " price:" + price + " type:" + type + " expiration:" + expiration;
     }
+
 }

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

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

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

@@ -1,31 +1,118 @@
 package io.zipcoder;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.google.common.base.CharMatcher;
+import com.google.common.base.Splitter;
+
+import static java.util.stream.Collectors.groupingBy;
+
 
 public class ItemParser {
 
+    int errorCounter = 0;
+
+    public int getErrorCounter() {
+        return errorCounter;
+    }
+
+    public Map<String, Map<Double, List<Item>>> getItemsMap(ArrayList<Item> items) {
+        return items
+                .stream()
+                .collect(
+                        groupingBy(
+                                Item::getName,
+                                groupingBy(
+                                        Item::getPrice
+                                )
+                        )
+                );
+    }
 
     public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+        String fixedString = fixString(rawData);
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , fixedString);
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public Item parseStringIntoItem(String rawItem) {
+//        try {
+//            validateItem(rawItem);
+//        } catch (ItemParseException e) {
+//            //NO OP
+//        }
+        Map<String, String> itemMap = null;
+        try {
+            itemMap = itemStringToHashMap(rawItem);
+        } catch (ItemParseException e) {
+            errorCounter++;
+            return null;
+        }
+        return createItem(itemMap);
+    }
+
+    private Item createItem(Map<String, String> itemMap) {
+        return new Item(itemMap.get("name"), Double.parseDouble(itemMap.get("price")), itemMap.get("type"), itemMap.get("expiration"));
+    }
+
+//    public boolean validateItem(String rawItem) throws ItemParseException{
+//        boolean isValid = false;
+//        if (rawItem.contains("[:\\W]")) {
+//            throw new ItemParseException();
+//        } else isValid = true;
+//        return isValid;
+//    }
+
+    public String toLowerCase(String rawString) {
+        Matcher m = Pattern.compile("\\w").matcher(rawString);
+        StringBuilder sb = new StringBuilder();
+
+        int last = 0;
+        while (m.find()) {
+            sb.append(rawString, last, m.start());
+            sb.append(m.group(0).toLowerCase());
+            last = m.end();
+        }
+        sb.append(rawString.substring(last));
+
+        return sb.toString();
+    }
+
+    public String fixCo0kies(String rawString) {
+        Matcher m = Pattern.compile("co0kies").matcher(rawString);
+        String fixedString = m.replaceAll("cookies");
+        return fixedString;
+    }
+
+    public String fixString(String rawString) {
+        String lowerCased = toLowerCase(rawString);
+        String fixedString = fixCo0kies(lowerCased);
+        return fixedString;
     }
 
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
+        String stringPattern = "[;|\\^]";
         ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
+        //TODO
         return response;
     }
 
     private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
-        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+        return new ArrayList<>(Arrays.asList(inputString.split(stringPattern)));
     }
 
-
+    private Map<String, String> itemStringToHashMap(String rawItem) throws ItemParseException {
+        CharMatcher matcher = CharMatcher.anyOf(";^%*!@");
+        Map<String,String> itemMap = Splitter.on(matcher).withKeyValueSeparator(':').split(rawItem);
+        for (Map.Entry<String,String> entry : itemMap.entrySet()) {
+            if ( entry.getValue().equals("")) {
+                throw new ItemParseException();
+            }
+        }
+        return itemMap;
+    }
 
 }

src/main/java/io/zipcoder/ItemPrinter.java

@@ -0,0 +1,53 @@
+package io.zipcoder;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class ItemPrinter {
+
+    ItemParser parser = new ItemParser();
+    ArrayList<Item> itemsArray = new ArrayList<>();
+
+    public String prettyPrint(String rawData) {
+        ArrayList<String> itemStrings = parser.parseRawDataIntoStringArray(rawData);
+        for (String s : itemStrings) {
+            Item item = parser.parseStringIntoItem(s);
+            if (item != null) {
+                itemsArray.add(item);
+            }
+        }
+
+        Map<String, Map<Double, List<Item>>> itemsMap = parser.getItemsMap(itemsArray);
+
+        StringBuilder output = new StringBuilder();
+        itemsMap.forEach(
+                (str,value) -> {
+                    int itemCount = getItemCount(value);
+                    output.append(
+                            String.format("name: %7s     seen: %d times", str, itemCount)
+                            + ("\n") + ("=============     =============") + ("\n")
+                    );
+                    for (Map.Entry<Double, List<Item>> entry : value.entrySet()) {
+                        output.append(
+                                String.format("price: $%5.2f     seen: %d times", entry.getKey(), entry.getValue().size())
+                                        + ("\n") + ("-------------     -------------") + ("\n")
+                        );
+                    }
+                    output.append("\n");
+                }
+                );
+        return output.toString();
+    }
+
+    private int getItemCount(Map<Double, List<Item>> value) {
+        int itemCount = 0;
+        for (Map.Entry<Double, List<Item>> entry : value.entrySet()) {
+            Double price = entry.getKey();
+            List<Item> itemArray = entry.getValue();
+            itemCount += itemArray.size();
+        }
+        return itemCount;
+    }
+
+}

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

@@ -13,7 +13,8 @@ public class Main {
 
     public static void main(String[] args) throws Exception{
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
-        // TODO: parse the data in output into items, and display to console.
+        ItemPrinter printer = new ItemPrinter();
+        String improvedOutput = printer.prettyPrint(output);
+        System.out.println(improvedOutput);
     }
 }

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##"