complete

src/main/java/io/zipcoder/ErrorLogger.java

@@ -0,0 +1,23 @@
+package io.zipcoder;
+
+public class ErrorLogger {
+
+    private int errorCount = 0;
+
+    public void incrementError() {
+        errorCount++;
+    }
+
+    public String getFormattedError(){
+        StringBuilder sb = new StringBuilder();
+        sb.append("Errors\t\t\t\tseen: " + errorCount);
+        if (ItemParseException.errorCount > 1) {
+            sb.append(" times");
+        }
+        else {
+            sb.append(" time");
+        }
+        sb.append("\n");
+        return sb.toString();
+    }
+}

src/main/java/io/zipcoder/ItemOrganizer.java

@@ -0,0 +1,21 @@
+package io.zipcoder;
+
+import java.util.HashMap;
+
+public class ItemOrganizer {
+
+    public Iterable<OrganizedItemData> organizeItems(Iterable<Item> items) {
+        HashMap<String, OrganizedItemData> organizedItemsMap = new HashMap<String, OrganizedItemData>();
+        for (Item item : items) {
+            if(organizedItemsMap.containsKey(item.getName())) {
+                OrganizedItemData organizedItemData = organizedItemsMap.get(item.getName());
+                organizedItemData.addPrice(item.getPrice());
+            } else {
+                OrganizedItemData organizedItemData = new OrganizedItemData(item.getName());
+                organizedItemData.addPrice(item.getPrice());
+                organizedItemsMap.put(item.getName(), organizedItemData);
+            }
+        }
+        return organizedItemsMap.values();
+    }
+}

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

@@ -1,4 +1,7 @@
 package io.zipcoder;
 
 public class ItemParseException extends Exception {
+
+    public static int errorCount = 0;
+
 }

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

@@ -10,6 +10,14 @@ import java.util.regex.Pattern;
 
 public class ItemParser {
 
+    private ErrorLogger errorLogger;
+
+    public ItemParser(ErrorLogger errorLogger) {
+        this.errorLogger = errorLogger;
+    }
+    public  ItemParser(){
+
+    }
 
     private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString) {
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
@@ -42,95 +50,23 @@ public class ItemParser {
         ArrayList<String> temp = parseRawDataIntoStringArray(rawData);
         ArrayList<Item> itemArrayList = new ArrayList<Item>();
         for (int i = 0; i < temp.size(); i++) {
-            itemArrayList.add(parseStringIntoItem(temp.get(i)));
-        }
-        return itemArrayList;
-    }
+            Item item;
+            try {
+                item = parseStringIntoItem(temp.get(i));
+                itemArrayList.add(item);
 
-
-    public HashMap<String, Integer> findBasedOnName(String rawData, String whatToSearch) throws ItemParseException {
-        HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
-        ArrayList<Item> tempItems = findRawItemToArrayList(rawData);
-        for (int i = 0; i < tempItems.size(); i++) {
-            if (tempItems.get(i).getName().equalsIgnoreCase(whatToSearch)) {
-                incrementValue(hashMap, String.valueOf(tempItems.get(i).getPrice()));
+            } catch (ItemParseException e) {
+                errorLogger.incrementError();
             }
-        }
-        return hashMap;
-    }
-
-    public void incrementValue(Map<String, Integer> map, String key) {
-        Integer count = map.get(key);
-        if (count == null) {
-            count = 0;
-        }
-        map.put(key, count + 1);
-    }
 
-    public Integer getTotalCount (String rawData, String whatToSearch) throws ItemParseException {
-        HashMap<String, Integer> hashMap = findBasedOnName(rawData,whatToSearch);
-        Integer totalCount = 0;
-        for (Map.Entry<String, Integer> entry: hashMap.entrySet()){
-            totalCount += entry.getValue();
-        }
-        return totalCount;
-
-    }
-
-    public String printOut (String rawData) throws ItemParseException {
-        ArrayList<Item> tempItems = findRawItemToArrayList(rawData);
-        HashMap<String, Integer> milk = findBasedOnName(rawData, "milk");
-        HashMap<String, Integer> bread = findBasedOnName(rawData, "bread");
-        HashMap<String, Integer> cookies = findBasedOnName(rawData, "cookies");
-        HashMap<String, Integer> apples = findBasedOnName(rawData, "apples");
-
-        StringBuilder sb = new StringBuilder();
-        sb.append("name:\tMilk\t\tseen: "+ )
-//
-//        name:    Milk 		 seen: 6 times
-//                ============= 	 	 =============
-//        Price: 	 3.23		 seen: 5 times
-//                -------------		 -------------
-//                Price:   1.23		 seen: 1 time
-//
-//        name:   Bread		 seen: 6 times
-//                =============		 =============
-//        Price:   1.23		 seen: 6 times
-//                -------------		 -------------
-//
-//                name: Cookies     	 seen: 8 times
-//                =============     	 =============
-//        Price:   2.25        seen: 8 times
-//                -------------        -------------
-//
-//                name:  Apples     	 seen: 4 times
-//                =============     	 =============
-//        Price:   0.25     	 seen: 2 times
-//                -------------     	 -------------
-//                Price:   0.23  	 	 seen: 2 times
-//
-//        Errors         	 	 seen: 4 times
-
-
-        return rawData;
-    }
 
 
-    public static void main(String[] args) throws ItemParseException {
-        String rawMultipleItems = "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##"
-                + "NAMe:BrEAD;price:1.25;type:Food;expiration:2/25/2016##"
-                + "NAMe:chocolate;price:1.25;type:Food;expiration:2/25/2016##";
-        ;
-        ItemParser itemParser = new ItemParser();
-        System.out.println(itemParser.findBasedOnName(rawMultipleItems, "bread"));
-        System.out.println(itemParser.getTotalCount(rawMultipleItems, "bread"));
 
+        }
+        return itemArrayList;
     }
 
 
-
     public String fixCookie(String input) {
         Pattern patternCookies = Pattern.compile("[Cc][Oo0][Oo0][Kk][Ii][Ee][Ss]");
         Matcher matcherCookies = patternCookies.matcher(input);
@@ -144,35 +80,105 @@ public class ItemParser {
 
         if (matcherName.find())
             return matcherName.group(2).toLowerCase();
-        else throw new ItemParseException();
-    }
+        else {
+            throw new ItemParseException();
+        }    }
 
     public String checkPrice(String input) throws ItemParseException {
         Pattern patternPrice = Pattern.compile("([Pp]...[Ee]:)(\\d\\.\\d{2})");
         Matcher matcherPrice = patternPrice.matcher(input);
-
-        if (matcherPrice.find())
+        if (matcherPrice.find()){
             return matcherPrice.group(2).toLowerCase();
-        else throw new ItemParseException();
+        }
+        else {
+            throw new ItemParseException();
+        }
     }
 
     public String checkType(String input) throws ItemParseException {
         Pattern patternType = Pattern.compile("([Tt]..[Ee]:)(\\w+)");
         Matcher matcherType = patternType.matcher(input);
 
-        if (matcherType.find())
+        if (matcherType.find()) {
             return matcherType.group(2).toLowerCase();
-        else throw new ItemParseException();
+        }
+        else {
+            throw new ItemParseException();
+        }
     }
 
     public String checkExpiration(String input) throws ItemParseException {
         Pattern patternExpiration = Pattern.compile("([Ee]........[Nn]:)(\\d\\/\\d{2}\\/\\d{4})");
         Matcher matcherExpiration = patternExpiration.matcher(input);
 
-        if (matcherExpiration.find())
+        if (matcherExpiration.find()) {
             return matcherExpiration.group(2).toLowerCase();
-        else throw new ItemParseException();
+        }
+        else {
+            throw new ItemParseException();
+        }
     }
+
+
+//    public HashMap<String, Integer> findBasedOnName(String rawData, String whatToSearch) throws ItemParseException {
+//        HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
+//        ArrayList<Item> tempItems = findRawItemToArrayList(rawData);
+//        for (int i = 0; i < tempItems.size(); i++) {
+//            if (tempItems.get(i).getName().equalsIgnoreCase(whatToSearch)) {
+//                incrementValue(hashMap, String.valueOf(tempItems.get(i).getPrice()));
+//            }
+//        }
+//        return hashMap;
+//    }
+//
+//    public void incrementValue(Map<String, Integer> map, String key) {
+//        Integer count = map.get(key);
+//        if (count == null) {
+//            count = 0;
+//        }
+//        map.put(key, count + 1);
+//    }
+//
+//    public Integer getTotalCount (String rawData, String whatToSearch) throws ItemParseException {
+//        HashMap<String, Integer> hashMap = findBasedOnName(rawData,whatToSearch);
+//        Integer totalCount = 0;
+//        for (Map.Entry<String, Integer> entry: hashMap.entrySet()){
+//            totalCount += entry.getValue();
+//        }
+//        return totalCount;
+//
+//    }
+//
+//    public String printOut (String rawData) throws ItemParseException {
+//        ArrayList<Item> tempItems = findRawItemToArrayList(rawData);
+//        HashMap<String, Integer> milk = findBasedOnName(rawData, "milk");
+//        HashMap<String, Integer> bread = findBasedOnName(rawData, "bread");
+//        HashMap<String, Integer> cookies = findBasedOnName(rawData, "cookies");
+//        HashMap<String, Integer> apples = findBasedOnName(rawData, "apples");
+//
+//        StringBuilder sb = new StringBuilder();
+//        sb.append("name:\tMilk\t\tseen: "+ 1(rawData, "milk") + " times\n")
+//
+//        return sb.toString();
+//    }
+//
+//
+//    public static void main(String[] args) throws ItemParseException {
+//        String rawMultipleItems = "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##"
+//                + "NAMe:BrEAD;price:1.25;type:Food;expiration:2/25/2016##"
+//                + "NAMe:chocolate;price:1.25;type:Food;expiration:2/25/2016##";
+//        ;
+//        ItemParser itemParser = new ItemParser();
+//        System.out.println(itemParser.findBasedOnName(rawMultipleItems, "bread"));
+//        System.out.println(itemParser.getTotalCount(rawMultipleItems, "bread"));
+//
+//    }
+
+
+
+
 }
 
 

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

@@ -15,12 +15,27 @@ public class Main {
 
     public static void main(String[] args) throws Exception{
         String output = (new Main()).readRawDataToString();
-        ItemParser itemParser = new ItemParser();
-        ArrayList<Item> temp = itemParser.findRawItemToArrayList(output);
-        System.out.println(temp.toString());
+        System.out.println(output);;
+        ErrorLogger errorData = new ErrorLogger();
+
+        ItemParser itemParser = new ItemParser(errorData);
+
+        ArrayList<Item> itemList = itemParser.findRawItemToArrayList(output);
+
+
+        ItemOrganizer itemOrganizer = new ItemOrganizer();
+        Iterable<OrganizedItemData> organizedItems = itemOrganizer.organizeItems(itemList);
+
+        for(OrganizedItemData organizedItemData : organizedItems) {
+            System.out.println(organizedItemData.getFormattedData());
+        }
+        String errorOutput= errorData.getFormattedError();
+        System.out.println(errorOutput);
+
+        }
         // TODO: parse the data in output into items, and display to console.
 
 
 
-    }
+
 }

src/main/java/io/zipcoder/OrganizedItemData.java

@@ -0,0 +1,78 @@
+package io.zipcoder;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public class OrganizedItemData {
+//take list of items and organize data in the way we need them of item name, price and count of prices
+    private String itemName;
+    private HashMap<Double, Integer> priceAndOccurrence = new HashMap<Double, Integer>();
+
+
+    public OrganizedItemData(String itemName) {
+        this.itemName = itemName;
+    }
+
+    public String getItemName() {
+        return itemName;
+    }
+
+    public void addPrice(double price) {
+        if(priceAndOccurrence.containsKey(price)) {
+            int count = priceAndOccurrence.get(price) + 1;
+            priceAndOccurrence.put(price, count);
+        } else {
+            priceAndOccurrence.put(price, 1);
+        }
+
+    }
+
+    private int getTotalCount() {
+        int count = 0;
+        for(Integer value : priceAndOccurrence.values()) {
+            count+=value;
+        }
+        return count;
+    }
+//
+//    public Iterable<Map.Entry<Double, Integer>> getPriceAndOccurrences() {
+//        return priceAndOccurrence.entrySet();
+//    }
+
+    public String getFormattedData() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("name:\t" + itemName);
+        sb.append("\t\tseen: " + getTotalCount());
+        if (getTotalCount() > 1) {
+            sb.append(" times\n");
+        } else {
+            sb.append(" time\n");
+        }
+        sb.append("=============\t\t=============\n");
+        int count = priceAndOccurrence.entrySet().size();
+        for(Map.Entry<Double, Integer> entry: priceAndOccurrence.entrySet()) {
+            if (count > 0) {
+                sb.append("Price:\t" + entry.getKey());
+                sb.append("\t\tseen: " + entry.getValue());
+                if (entry.getValue() > 1) {
+                    sb.append(" times\n");
+                }
+                else {
+                    sb.append(" time\n");
+                }
+                if(count > 0) {
+                    sb.append("-------------\t\t-------------\n");
+                    count--;
+                }
+            }
+        }
+        sb.append("\n");
+        return sb.toString();
+    }
+
+
+
+}
+

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

@@ -71,23 +71,4 @@ public class ItemParserTest {
         assertEquals(expected, actual);
     }
 
-    @Test
-    public void fixCookie() {
-    }
-
-    @Test
-    public void checkName() {
-    }
-
-    @Test
-    public void checkPrice() {
-    }
-
-    @Test
-    public void checkType() {
-    }
-
-    @Test
-    public void checkExpiration() {
-    }
 }