Merge 1227677299f5648b85ba9f5765c537e08938f8dc 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/ItemParseException.java

@@ -1,4 +1,12 @@
 package io.zipcoder;
 
 public class ItemParseException extends Exception {
+    private static int count = 0;
+    public ItemParseException(){
+        count++;
+    }
+    public static int getCount(){
+        return count;
+    }
+
 }

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

@@ -2,30 +2,188 @@ package io.zipcoder;
 
 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 {
 
+    Map<String, ArrayList<Item>> realFoodList;
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    public ItemParser() {
+        realFoodList = new HashMap<>();
+    }
+
+    public Map<String, ArrayList<Item>> getRealFoodList() {
+        return realFoodList;
+    }
+
+    //feed data from string split into arrayList
+    public ArrayList<String> parseRawDataIntoStringArray(String rawData) {
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawData);
+        //naMe:Milk;price:3.23;type:Food;expiration:1/25/2016 these chunks stored at each index
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    //general method for splitting arraylists with regex
+    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString) {
+        return new ArrayList<>(Arrays.asList(inputString.split(stringPattern)));
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
+    //Splits arraylist that has chunks into the name:cake arraylist which gets used in testing
+    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
+        String stringPattern = "[;|^|!|%|*|@]";
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawItem);
+        //ex {name:cake,price:2.50, type:food, expiration:1/4/2018}
         return response;
+
+    }
+
+    //takes the raw data arraylist(item chunks) parses them into items and then adds the items to the map
+    public void addItemToList(ArrayList<String> itemList){
+            for (int i = 0; i < itemList.size(); i++) {
+                try{
+                Item newItem = (parseStringIntoItem(itemList.get(i)));
+                addNewItemToMap(realFoodList, newItem);
+            }catch (ItemParseException e){
+                    continue;
+                }
+
+        }
+    }
+
+    public void addNewItemToMap(Map<String, ArrayList<Item>> map, Item newItem) {
+        if (!map.keySet().contains(newItem.getName())) {
+            map.put(newItem.getName(), new ArrayList<>());
+            map.get(newItem.getName()).add(newItem);
+        } else {
+            map.get(newItem.getName()).add(newItem);
+        }
+    }
+
+    //gets all the prices for the items
+    public ArrayList<Double> getPrices(Map.Entry<String, ArrayList<Item>> itemMap) {
+        ArrayList<Double> prices = new ArrayList<>();
+        for (int i = 0; i < itemMap.getValue().size(); i++) {
+            if (!prices.contains(itemMap.getValue().get(i).getPrice())) {
+                prices.add(itemMap.getValue().get(i).getPrice());
+            }
+        }
+        return prices;
+    }
+
+    public int countNumberOfDifferentPrices(ArrayList<Item> itemList, Double price) {
+        int counter = 0;
+        for (int i = 0; i < itemList.size(); i++) {
+            if (itemList.get(i).getPrice().equals(price)) {
+                counter++;
+            }
+        }
+        return counter;
+    }
+
+        //Create new item
+    public Item parseStringIntoItem(String rawItem) throws ItemParseException {
+        String name = findName(rawItem);
+        Double price = Double.valueOf(findPrice(rawItem));
+        String type = findType(rawItem);
+        String expiration = findExpiration(rawItem);
+
+        return new Item(name, price, type, expiration);
+    }
+
+    //Cookie has a 0 in it so we fix it before parsing into the item
+    public String fixCo0kie(String input) {
+        String regexCo0kie = "[0]";
+        Pattern pattern = Pattern.compile(regexCo0kie);
+        Matcher matcher = pattern.matcher(input);
+        return matcher.replaceAll("o");
+    }
+
+    //We find the item name by searching for the name:item pair then return the group that has the item
+    public String findName(String name) throws ItemParseException {
+        String regexName = "([Nn]..[Ee]:)(\\w+)";
+        Pattern pattern = Pattern.compile(regexName);
+        Matcher matcher = pattern.matcher(name);
+        if (matcher.find()) {
+            if(matcher.group(2).contains("0")) {
+                return fixCo0kie(matcher.group(2).toLowerCase());
+            }else {
+                return matcher.group(2).toLowerCase();
+            }
+        } else {
+            throw new ItemParseException();
+        }
+
+    }
+
+    public String findPrice(String price) throws ItemParseException {
+        String regexPrice = "([Pp]...[Ee]:)(\\d\\.\\d{2})";
+        Pattern pattern = Pattern.compile(regexPrice);
+        Matcher matcher = pattern.matcher(price);
+
+        if (matcher.find()) {
+            return matcher.group(2);
+        } else {
+            throw new ItemParseException();
+        }
     }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
-        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+
+    public String findType(String type) throws ItemParseException {
+        String regexType = "([Tt]..[Ee]:)(\\w+)";
+        Pattern pattern = Pattern.compile(regexType);
+        Matcher matcher = pattern.matcher(type);
+
+        if (matcher.find()) {
+            return matcher.group(2).toLowerCase();
+        } else {
+            throw new ItemParseException();
+        }
+    }
+
+
+    public String findExpiration(String expiration) throws ItemParseException {
+        String regexExpiration = "([E|e]........[N|n]:)(\\d\\/\\d{2}\\/\\d{4})";
+        Pattern pattern = Pattern.compile(regexExpiration);
+        Matcher matcher = pattern.matcher(expiration);
+        if (matcher.find()) {
+            return matcher.group(2).toLowerCase();
+        } else {
+            throw new ItemParseException();
+        }
     }
 
+    public String printParsedJerkSON() {
+        StringBuilder print = new StringBuilder();
+        for (Map.Entry<String, ArrayList<Item>> entry : realFoodList.entrySet()) {
+            print.append("Name: ");
+            print.append(String.format("%-10s",entry.getKey()));
+            print.append("\t\tseen: " + entry.getValue().size() + " times\n");
+            print.append("================" + "\t\t" + "==================\n");
 
 
+
+            ArrayList<Double> priceList = getPrices(entry);
+
+            for (int i = 0; i < priceList.size(); i++) {
+                print.append("Price: ");
+                print.append(String.format("%-10s",priceList.get(i)));
+                print.append("\t\tseen: " + countNumberOfDifferentPrices(entry.getValue(), priceList.get(i)) + " times\n");
+                print.append("----------------" + "\t\t" + "------------------\n");
+
+            }
+            print.append("\n");
+        }
+
+        print.append("\nErrors" + "\t\t\t\t\tseen: " + ItemParseException.getCount() + " times\n");
+        return print.toString();
+    }
+
 }
+
+
+
+

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 {
 
@@ -12,8 +14,10 @@ public class Main {
     }
 
     public static void main(String[] args) throws Exception{
+        ItemParser itemParser = new ItemParser();
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
-        // TODO: parse the data in output into items, and display to console.
+        ArrayList<String> temp = itemParser.parseRawDataIntoStringArray(output);
+        itemParser.addItemToList(temp);
+        System.out.println(itemParser.printParsedJerkSON());
     }
 }

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

@@ -5,6 +5,7 @@ import org.junit.Before;
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Map;
 
 import static org.junit.Assert.*;
 
@@ -14,11 +15,13 @@ 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:;;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##";
+
+
     private ItemParser itemParser;
 
     @Before
@@ -59,4 +62,112 @@ public class ItemParserTest {
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void addNewItemToMapTest() {
+        //Given
+        boolean expected = true;
+        ArrayList<String> testList = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        //When
+        itemParser.addItemToList(testList);
+        boolean actual = itemParser.getRealFoodList().keySet().contains("milk");
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void addItemToListTest(){
+        //Given
+        boolean expected = true;
+        ArrayList<String> testList;
+        testList = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        itemParser.addItemToList(testList);
+        //When
+        boolean actual = itemParser.getRealFoodList().keySet().contains("milk");
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void countNumberOfDifferentPricesTest(){
+        //Given
+        int expected = 2;
+        ArrayList<Item> testList = new ArrayList<>();
+        Item cake = new Item("cake", 2.50, "Food", "1/24/18");
+        Item cake2 = new Item("cake", 2.50, "Food", "1/24/18");
+        Item pie = new Item("cie", 2.00, "Food", "1/18/18");
+        testList.add(cake);
+        testList.add(cake2);
+        testList.add(pie);
+        //When
+        int actual = itemParser.countNumberOfDifferentPrices(testList, 2.50);
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void fixCookieTest() throws ItemParseException {
+        //Given
+        String expected = "cookies";
+        String messedUpCookie = "c00kies";
+        //When
+       String actual = itemParser.fixCo0kie(messedUpCookie);
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void findNameTest() throws ItemParseException {
+        //Given
+        String expected = "cake";
+        String messedUpName = "NaME:cAkE";
+        //When
+        String actual = itemParser.findName(messedUpName);
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void findCo0kieName() throws ItemParseException {
+        //Given
+        String expected = "cookies";
+        String messedUpName = "NaME:co0kies";
+        //When
+        String actual = itemParser.findName(messedUpName);
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void findPriceTest() throws ItemParseException {
+        //Given
+        String expected = "2.50";
+        String messedUpPrice = "PriCe:2.50";
+        //When
+        String actual = itemParser.findPrice(messedUpPrice);
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void findTypeTest() throws ItemParseException {
+        //Given
+        String expected = "food";
+        String messedUpType = "TypE:FoOd";
+        //When
+        String actual = itemParser.findType(messedUpType);
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void findExpirationTest() throws ItemParseException {
+        //Given
+        String expected = "1/24/2018";
+        String messedUpExpiration = "expirATIOn:1/24/2018";
+        //When
+        String actual = itemParser.findExpiration(messedUpExpiration);
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
 }