Merge 9262de7c5ee1ef3bf4cafabbd14e23d8779e2eec into 23c2c01bf07b924ac9b860fa2771bf6ceb246ad5

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>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
     <dependencies>
         <dependency>

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

@@ -1,5 +1,7 @@
 package io.zipcoder;
 
+import java.util.HashMap;
+
 public class Item {
     private String name;
     private Double price;
@@ -16,6 +18,7 @@ public class Item {
      * @param expiration
      */
     public Item(String name, Double price, String type, String expiration){
+
         this.name = name;
         this.price = price;
         this.type = type;
@@ -45,4 +48,6 @@ 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,8 @@
 package io.zipcoder;
 
+import static java.lang.Float.NaN;
+
 public class ItemParseException extends Exception {
-}
+
+
+    }

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

@@ -1,21 +1,193 @@
 package io.zipcoder;
 
+
+
+import jdk.nashorn.internal.objects.Global;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+
+public final class ItemParser {
+
+    private PrintWriter writer ;
+    private Map<String,ArrayList<Item>> groceryMap;
+
+    //counts exceptions
+    int exception = 0;
+
+    public ItemParser() {
+
+        groceryMap = new HashMap<>();
+        //add printWriter in constructor so that there is only ONE
+        try {
+            writer= new PrintWriter("/Users/karoushafennimore/Dev/PainfulAfternoon/src/main/resources/errors.txt");
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public String printGroceryList(){
+
+        StringBuilder sb = new StringBuilder();
+        //for every new entry - put the Key and how many times you saw it
+        for (Map.Entry<String , ArrayList<Item> > item : groceryMap.entrySet()) {
+            sb.append(String.format("\nname: %9s", item.getKey().substring(0, 1).toUpperCase() + item.getKey().substring(1)));
+            sb.append("\t\t\tseen:  " + item.getValue().size() + "  times\n" + "===============" + "\t\t\t" + "===============\n");
 
-public class ItemParser {
+            ArrayList<Double> tempList = uniquePrices(item);
 
+            for(int i = 0; i < tempList.size(); i++) {
+                sb.append(String.format("Price: %8s", tempList.get(i)));
+                sb.append("\t\t\tseen:  " + priceCount(item.getValue(), tempList.get(i)) + "  times\n---------------" + "\t\t\t" + "---------------\n");
+            }
+        }
+        sb.append("\nErrors" + "\t\t\t\t\tseen:  " + exception + "  times\n");
+
+        return sb.toString();
+    }
+
+
+
+    public ArrayList<Double> uniquePrices(Map.Entry<String , ArrayList<Item> > item) {
+
+        //returning unique Prices from the array list
+        ArrayList<Double> uniquePrice = new ArrayList<>();
+        //loop through and check if the price has been repeated...if it hasn't then add it
+        for (int i = 0; i < item.getValue().size(); i++) {
+            if (!uniquePrice.contains(item.getValue().get(i).getPrice())) {
+                uniquePrice.add(item.getValue().get(i).getPrice());
+            }
+        }
+        //output ArrayList of Doubles
+        return uniquePrice;
+
+    }
+
+    public int priceCount(ArrayList<Item> item, Double price) {
+        int count = 0;
+        //loop through items and look for the price to see how many times it is there
+        for(int i = 0; i < item.size(); i++) {
+            if(item.get(i).getPrice().equals(price)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public Map<String, ArrayList<Item>> getMap() {
+        return this.groceryMap;
+    }
 
     public ArrayList<String> parseRawDataIntoStringArray(String rawData){
-        String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
-        return response;
+        return splitStringWithRegexPattern("##" , rawData);
+    }
+
+    private void incrementList(Map<String, ArrayList<Item>> myMap, Item myItem) {
+        //if the Key is already in the Map
+        if(myMap.keySet().contains(myItem.getName())) {
+            //giving the map the item name and then adding the value to THAT key
+            myMap.get(myItem.getName()).add(myItem);
+        }else {
+            //if the key is not in the map then add it
+            myMap.put(myItem.getName(), new ArrayList<Item>());
+            //then add the value to that added KEY!
+            myMap.get(myItem.getName()).add(myItem);
+        }
+
+    }
+
+    public void addItemToList(ArrayList<String> groceryList) {
+
+        for(int i = 0; i < groceryList.size(); i++) {
+            try {
+                Item tryItem = (parseStringIntoItem(groceryList.get(i)));
+                incrementList(groceryMap, tryItem);
+            } catch (ItemParseException e) {
+                exception++;
+                try {
+                    printErrorToFile(e);
+                } catch (FileNotFoundException e1) {
+                    e1.printStackTrace();
+                }
+            }
+        }
+    }
+
+    public Item parseStringIntoItem(String rawItem) throws ItemParseException {
+        String itemName = findName(rawItem);
+        Double itemPrice = itemPrice(rawItem);
+        String itemType = itemType(rawItem);
+        String itemExpiration = itemExpiration(rawItem);
+
+        //if item does not have a name or item Price - dont create it bc its irrelevant data.
+        if(findName(rawItem) == null || itemPrice(rawItem) == null) {
+            throw new ItemParseException();
+        }
+        return new Item (itemName, itemPrice, itemType, itemExpiration);
+    }
+
+
+    //getting all the values from string for
+    private String findName(String rawItem) {
+        Pattern namePattern = Pattern.compile("(?<=([Nn][Aa][Mm][Ee][^A-Za-z])).*?(?=[^A-Za-z0])");
+        Matcher regex = namePattern.matcher(rawItem);
+
+        if (regex.find()) {
+            if (regex.group().length() > 0) {
+                return replaceZeros(regex.group().toLowerCase());
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    public Double itemPrice(String rawItem) {
+        Pattern pricePattern = Pattern.compile("(?<=([Pp][Rr][Ii][Cc][Ee][^A-Za-z])).*?(?=[^0-9.])");
+        Matcher regex1 = pricePattern.matcher(rawItem);
+        if (regex1.find()) {
+            if (regex1.group().length() > 0) {
+                return Double.parseDouble(regex1.group().toLowerCase());
+            }
+        }
+        return null;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
+    public String itemType(String rawItem) {
+        Pattern typePattern = Pattern.compile("(?<=([Tt][Yy][Pp][Ee][^A-Za-z])).*?(?=[^A-Za-z0])");
+        Matcher regex2 = typePattern.matcher(rawItem);
+        if (regex2.find()) {
+            return regex2.group().toLowerCase();
+        }
+        return null;
+    }
+    public String itemExpiration(String rawItem) {
+        Pattern expirationPattern = Pattern.compile("(?<=([Ee][Xx][Pp][Ii][Rr][Aa][Tt][Ii][Oo][Nn][^A-Za-z]))(.)*[^#]");
+        Matcher regex3 = expirationPattern.matcher(rawItem);
+        if (regex3.find()) {
+            return regex3.group();
+        }
         return null;
     }
 
+    //this is to catch the 0's in cookie and replace with a o instead
+    private String replaceZeros(String rawItem) {
+
+        Pattern pattern = Pattern.compile("[0]");
+        Matcher regexName2 = pattern.matcher(rawItem);
+        return regexName2.replaceAll("o");
+    }
+
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
         String stringPattern = "[;|^]";
         ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
@@ -23,9 +195,16 @@ public class ItemParser {
     }
 
     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)));
     }
 
+    public void printErrorToFile(ItemParseException e) throws FileNotFoundException {
+        //getting entire stack report on the errors that I am getting.
+        writer.write(Arrays.stream(e.getStackTrace()).map(Object::toString).collect(Collectors.joining("\n")));
 
+    }
 
+    public void flushExceptionsToFile() {
+        writer.close();
+    }
 }

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

@@ -2,18 +2,29 @@ package io.zipcoder;
 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.Map;
+
 
 public class Main {
 
-    public String readRawDataToString() throws Exception{
+    public static ItemParser itemParser = new ItemParser();
+
+    public String readRawDataToString() throws Exception {
         ClassLoader classLoader = getClass().getClassLoader();
-        String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
-        return result;
+
+        return IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
     }
 
-    public static void main(String[] args) throws Exception{
+    public static void main(String[] args) throws Exception {
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
+        ArrayList<String> temp = itemParser.parseRawDataIntoStringArray(output);
+        itemParser.addItemToList(temp);
+        System.out.println(itemParser.printGroceryList());
+        //close the file when you're done writing to it!
+        itemParser.flushExceptionsToFile();
+
         // TODO: parse the data in output into items, and display to console.
     }
 }
+

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

@@ -4,6 +4,7 @@ import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
+import java.io.FileNotFoundException;
 import java.util.ArrayList;
 
 import static org.junit.Assert.*;
@@ -14,7 +15,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:;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##"
@@ -23,6 +24,7 @@ public class ItemParserTest {
 
     @Before
     public void setUp(){
+
         itemParser = new ItemParser();
     }
 
@@ -59,4 +61,47 @@ public class ItemParserTest {
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void addItemToListTest() {
+        //Given
+        ArrayList<String> testList;
+        //When
+        testList = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        itemParser.addItemToList(testList);
+        //SIZE IS TWO BECAUSE BREAD IS REPEATED TWICE AND ITS A UNIQUE KEY!!!
+        int expected = 2;
+        int actual = itemParser.getMap().size();
+        //Then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void addItemToListTest2() {
+        //Given
+        ArrayList<String> testList;
+        //When
+        testList = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        itemParser.addItemToList(testList);
+        String expected = "[bread, milk]";
+        String actual = itemParser.getMap().keySet().toString();
+        //Then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void addItemToListTest3() {
+        //Given
+        ArrayList<String> testList;
+        //When
+        testList = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        itemParser.addItemToList(testList);
+        boolean expected = true;
+        boolean actual = itemParser.getMap().keySet().contains("bread");
+        System.out.println(itemParser.printGroceryList());
+        //Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
 }