Merge ecb72d30a0552e197e5b9b2a7076f51370b46e48 into 23c2c01bf07b924ac9b860fa2771bf6ceb246ad5

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

@@ -1,31 +1,184 @@
 package io.zipcoder;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import com.sun.org.apache.xerces.internal.impl.xpath.regex.Match;
+import com.sun.xml.internal.bind.v2.runtime.reflect.Lister;
+
+import java.lang.reflect.Array;
+import java.util.*;
+import java.util.regex.Matcher;
+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)));
+    }
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    public ArrayList<String> parseRawDataIntoStringArray(String rawData) {
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawData);
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
+        String stringPattern = "[@|^|*|%|!|;]";
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawItem);
+        return response;
     }
 
-    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 = checkName(rawItem);
+        Double price = Double.valueOf(checkPrice(rawItem));
+        String type = checkType(rawItem);
+        String expiration = checkExpiration(rawItem);
+
+        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 ArrayList<Item> findRawItemToArrayList(String rawData) throws ItemParseException {
+        ArrayList<String> temp = parseRawDataIntoStringArray(rawData);
+        ArrayList<Item> itemArrayList = new ArrayList<Item>();
+        for (int i = 0; i < temp.size(); i++) {
+            Item item;
+            try {
+                item = parseStringIntoItem(temp.get(i));
+                itemArrayList.add(item);
+
+            } catch (ItemParseException e) {
+                errorLogger.incrementError();
+            }
+
+
+
+
+        }
+        return itemArrayList;
     }
 
 
+    public String fixCookie(String input) {
+        Pattern patternCookies = Pattern.compile("[Cc][Oo0][Oo0][Kk][Ii][Ee][Ss]");
+        Matcher matcherCookies = patternCookies.matcher(input);
+        return matcherCookies.replaceAll("cookies");
+    }
+
+    public String checkName(String input) throws ItemParseException {
+        String newInput = fixCookie(input);
+        Pattern patternName = Pattern.compile("([Nn]..[Ee]:)(\\w+)");
+        Matcher matcherName = patternName.matcher(newInput);
+
+        if (matcherName.find())
+            return matcherName.group(2).toLowerCase();
+        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()){
+            return matcherPrice.group(2).toLowerCase();
+        }
+        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()) {
+            return matcherType.group(2).toLowerCase();
+        }
+        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()) {
+            return matcherExpiration.group(2).toLowerCase();
+        }
+        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

@@ -2,6 +2,8 @@ package io.zipcoder;
 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+
 
 public class Main {
 
@@ -13,7 +15,27 @@ public class Main {
 
     public static void main(String[] args) throws Exception{
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
+        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

@@ -14,7 +14,10 @@ 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: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##"
@@ -59,4 +62,13 @@ public class ItemParserTest {
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void findRawItem() throws ItemParseException {
+        String expected ="name:milk price:3.23 type:food expiration:1/25/2016";
+        String actual  = itemParser.findRawItemToArrayList(rawMultipleItems).get(0).toString();
+        System.out.println(itemParser.findRawItemToArrayList(rawMultipleItems).get(0));
+        assertEquals(expected, actual);
+    }
+
 }