Merge 19cde2b0154cf2aee37c0b0d06ed7f7bd50e920f into 23c2c01bf07b924ac9b860fa2771bf6ceb246ad5

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

 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class ItemParser {
 
+    private Pattern pattern;
+    private Matcher matcher;
+    private int exceptionCount = 0;
+    private HashMap<String, ArrayList<Item>> groceries;
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    public ItemParser() {
+        groceries = new HashMap<String, ArrayList<Item>>();
+    }
+
+    public String parse(String aString) {
+        ArrayList<String> groceries = parseRawDataIntoStringArray(aString);
+        addGroceriesToList(groceries);
+        return printGroceries();
+    }
+
+    protected 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;
+    protected void addGroceriesToList(ArrayList<String> jerkList) {
+        for (int i = 0; i < jerkList.size(); i++) {
+            try {
+                Item temp = (parseStringIntoItem(jerkList.get(i)));
+                incrementItem(this.groceries, temp);
+            } catch (ItemParseException ipe) {
+                exceptionCount++;
+            }
+        }
+    }
+
+    protected Item parseStringIntoItem(String rawItem) throws ItemParseException {
+        String aName = findName(rawItem);
+        Double aPrice = findPrice(rawItem);
+        String aType = findType(rawItem);
+        String anExpiration = findExpiration(rawItem);
+
+        if (findName(rawItem) == null || findPrice(rawItem) == null) {
+            throw new ItemParseException();
+        }
+
+        return new Item(aName, aPrice, aType, anExpiration);
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
+    protected ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
         String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
-        return response;
+        return splitStringWithRegexPattern(stringPattern, rawItem);
     }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
+    public HashMap<String, ArrayList<Item>> getGroceries() {
+        return groceries;
+    }
+
+
+    // private methods
+
+    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString) {
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
     }
 
+    private String printGroceries() {
+        StringBuilder display = new StringBuilder();
+        for (Map.Entry<String, ArrayList<Item>> entry : groceries.entrySet()) {
+            displayItemInfo(display, entry);
+            displayPriceInfo(display, entry);
+        }
+        display.append("\n\n").append(exceptionCount).append("  errors\n");
+        return display.toString();
+    }
+
+    private void displayItemInfo(StringBuilder aBuilder, Map.Entry<String, ArrayList<Item>> anEntry) {
+        aBuilder.append("\nname:");
+        aBuilder.append(String.format("%9s", anEntry.getKey().substring(0, 1).toUpperCase() + anEntry.getKey().substring(1)));
+        aBuilder.append("          seen:  " + anEntry.getValue().size() + "  times\n");
+        aBuilder.append("==============" + "\t\t\t" + "===============\n");
+    }
+
+    private void displayPriceInfo(StringBuilder aBuilder, Map.Entry<String, ArrayList<Item>> anEntry) {
+        ArrayList<Double> uniquePriceArrayList = getUniquePrices(anEntry);
+        for (Double aPrice : uniquePriceArrayList) {
+            aBuilder.append("Price:").append(String.format("%8s", aPrice));
+            aBuilder.append("          seen:  " + priceOccurences(anEntry.getValue(), aPrice) + "  times\n");
+            aBuilder.append("--------------" + "\t\t\t" + "---------------\n");
+        }
+    }
+
+    private ArrayList<Double> getUniquePrices(Map.Entry<String, ArrayList<Item>> entry) {
+        ArrayList<Double> prices = new ArrayList<Double>();
 
+        for (int i = 0; i < entry.getValue().size(); i++) {
+            if (!prices.contains(entry.getValue().get(i).getPrice())) {
+                prices.add(entry.getValue().get(i).getPrice());
+            }
+        }
+        return prices;
+    }
+
+    private int priceOccurences(ArrayList<Item> aList, Double aPrice) {
+        int count = 0;
+        for (Item anAList : aList) {
+            if (anAList.getPrice().equals(aPrice)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private void incrementItem(Map<String, ArrayList<Item>> aMap, Item anItem) {
+        if (aMap.keySet().contains(anItem.getName())) {
+            aMap.get(anItem.getName()).add(anItem);
+        } else {
+            aMap.put(anItem.getName(), new ArrayList<Item>());
+            aMap.get(anItem.getName()).add(anItem);
+        }
+    }
+
+    private String findName(String aString) {
+        String search = "(?<=([n|N][a|A][m|M][e|E][^a-zA-z])).*?(?=[^a-zA-z0])";
+        pattern = Pattern.compile(search);
+        matcher = pattern.matcher(aString);
+
+        if (matcher.find()) {
+            if (matcher.group().length() > 0) {
+                return replaceZeros(matcher.group().toLowerCase());
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    private String replaceZeros(String aString) {
+        pattern = Pattern.compile("[0]");
+        matcher = pattern.matcher(aString);
+        return matcher.replaceAll("o");
+    }
+
+    private Double findPrice(String aString) {
+        pattern = Pattern.compile("(?<=([p|P][r|R][i|I][c|C][e|E][^a-zA-Z])).*?(?=[^0-9.])");
+        matcher = pattern.matcher(aString);
+
+        if (matcher.find()) {
+            if (matcher.group().length() > 0) {
+                return Double.parseDouble(matcher.group());
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    private String findType(String aString) {
+        pattern = Pattern.compile("(?<=([t|T][y|Y][p|P][e|E][^a-zA-z])).*?(?=[^a-zA-Z0])");
+        matcher = pattern.matcher(aString);
+
+        if (matcher.find()) {
+            if (matcher.group().length() > 0) {
+                return matcher.group().toLowerCase();
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    private String findExpiration(String aString) {
+        String search = "(?<=([e|E][x|X][p|P][i|I][r|R][a|A][t|T][i|I][o|O][n|N][^a-zA-z]))(.)+[^#]";
+        pattern = Pattern.compile(search);
+        matcher = pattern.matcher(aString);
+
+        if (matcher.find()) {
+            if (matcher.group().length() > 0) {
+                return matcher.group();
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
 
 }

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

 
 public class Main {
 
+    static ItemParser parser = new ItemParser();
+
     public String readRawDataToString() throws Exception{
         ClassLoader classLoader = getClass().getClassLoader();
         String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
 
     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.
+        System.out.println(parser.parse(output));
     }
 }

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

 
 public class ItemParserTest {
 
-    private String rawSingleItem =    "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+    private String rawSingleItem = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
 
     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##"
-                                      +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
+            + "naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
+            + "NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
+
+    private String rawMultipleItemsMore = "naMe:;price:3.23;type:Food;expiration:1/25/2016##"
+            + "naME:MILK;price:2.75;type:Food;expiration:1/02/2016##"
+            + "NAMe:miLK;price:2.75;type:Food;expiration:2/25/2016##"
+            + "naME:c00kIEs;price:1.23;type:Food;expiration:1/02/2013##"
+            + "naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
+            + "naME:milk;price:1.50;type:Food;expiration:3/02/2012##"
+            + "naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
+            + "naME:COOKIES;price:1.75;type:Food;expiration:1/02/2014##"
+            + "naME:BreaD;price:1.50;type:Food;expiration:1/02/2016##";
+
     private ItemParser itemParser;
 
+
     @Before
-    public void setUp(){
+    public void setUp() {
         itemParser = new ItemParser();
     }
 
     @Test
-    public void parseRawDataIntoStringArrayTest(){
+    public void parseRawDataIntoStringArrayTest() {
         Integer expectedArraySize = 3;
         ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
         Integer actualArraySize = items.size();
     }
 
     @Test
-    public void parseStringIntoItemTest() throws ItemParseException{
-        Item expected = new Item("milk", 3.23, "food","1/25/2016");
+    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());
     }
 
     @Test(expected = ItemParseException.class)
-    public void parseBrokenStringIntoItemTest() throws ItemParseException{
+    public void parseBrokenStringIntoItemTest() throws ItemParseException {
         itemParser.parseStringIntoItem(rawBrokenSingleItem);
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTest(){
+    public void findKeyValuePairsInRawItemDataTest() {
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItem).size();
         assertEquals(expected, actual);
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTestIrregular(){
+    public void findKeyValuePairsInRawItemDataTestIrregular() {
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
-}
+
+    @Test
+    public void addGroceriesToListTest1() {
+        ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        itemParser.addGroceriesToList(items);
+        int expected = 2;
+        int actual = itemParser.getGroceries().size();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void addGroceriesToListTest2() {
+        ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        itemParser.addGroceriesToList(items);
+        int expected = 2;
+        int actual = itemParser.getGroceries().get("bread").size();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void addGroceriesToListTest3() {
+        ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        itemParser.addGroceriesToList(items);
+        String expected = "[bread, milk]";
+        String actual = itemParser.getGroceries().keySet().toString();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void parseTest1() {
+        String expected = "\nname:    Bread          seen:  3  times\n" +
+                "==============\t\t\t===============\n" +
+                "Price:    1.23          seen:  2  times\n" +
+                "--------------\t\t\t---------------\n" +
+                "Price:     1.5          seen:  1  times\n" +
+                "--------------\t\t\t---------------\n" +
+                "\n" +
+                "name:     Milk          seen:  3  times\n" +
+                "==============\t\t\t===============\n" +
+                "Price:    2.75          seen:  2  times\n" +
+                "--------------\t\t\t---------------\n" +
+                "Price:     1.5          seen:  1  times\n" +
+                "--------------\t\t\t---------------\n" +
+                "\n" +
+                "name:  Cookies          seen:  2  times\n" +
+                "==============\t\t\t===============\n" +
+                "Price:    1.23          seen:  1  times\n" +
+                "--------------\t\t\t---------------\n" +
+                "Price:    1.75          seen:  1  times\n" +
+                "--------------\t\t\t---------------\n" +
+                "\n" +
+                "\n" +
+                "1  errors\n";
+        String actual = itemParser.parse(rawMultipleItemsMore);
+        Assert.assertEquals(expected, actual);
+    }
+
+}