Merge 4d91dc0b7cdd85ead5165de44538537c18d43060 into 23c2c01bf07b924ac9b860fa2771bf6ceb246ad5

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

@@ -1,4 +1,5 @@
 package io.zipcoder;
 
 public class ItemParseException extends Exception {
+
 }

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

@@ -1,31 +1,228 @@
 package io.zipcoder;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class ItemParser {
 
+    private Integer countExceptionsThrown = 0;
+    private Integer count = 0;
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString) {
+        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+    }
+
+    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 {
+            if (checkName(rawItem) == null || checkPrice(rawItem) == null || checkType(rawItem) == null
+                    || checkExpiration(rawItem) == null) {
+                throw new 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> createItemArrayList(String rawData) {
+        ArrayList<String> temp = parseRawDataIntoStringArray(rawData);
+        ArrayList<Item> itemArrayList = new ArrayList<Item>();
+
+        for (int i = 0; i <temp.size() ; i++) {
+            try {
+                itemArrayList.add(parseStringIntoItem(temp.get(i)));
+            } catch (ItemParseException e) {
+                count++;
+            }
+        }
+        return itemArrayList;
+    }
+
+    public ArrayList<Item> filterItemArrayList(ArrayList<Item> input, String filterType){
+        ArrayList<Item> filterItemArrayList = new ArrayList<Item>();
+        for (int i = 0; i <input.size() ; i++) {
+            if(input.get(i).getName().equals(filterType))
+            filterItemArrayList.add(input.get(i));
+        }
+        return filterItemArrayList;
+    }
+
+    public Map<Double, Integer> individualItemCount(ArrayList<Item> filteredArrayList) {
+        Map<Double, Integer> priceTotals = new TreeMap<Double, Integer>(Collections.reverseOrder());
+        for (int i = 0; i < filteredArrayList.size(); i++) {
+            Double key = filteredArrayList.get(i).getPrice();
+            Integer count = priceTotals.get(key);
+            if (count == null) {
+                priceTotals.put(key, 1);
+            } else {
+                priceTotals.put(key, count + 1);
+            }
+        }
+        return priceTotals;
+    }
+
+    public Map<Double, Integer> itemTypeMapWithCounts(String rawData, String filterType)  {
+        ArrayList<Item> itemArrayList = createItemArrayList(rawData);
+        ArrayList<Item> filterItemArrayList = filterItemArrayList(itemArrayList, filterType);
+        Map<Double, Integer> priceTotals = individualItemCount(filterItemArrayList);
+        return priceTotals;
+    }
+
+    public Integer totalTimesItemSeen(String rawData, String filterType)  {
+        ArrayList<Item> itemArrayList = createItemArrayList(rawData);
+        ArrayList<Item> filterItemArrayList = filterItemArrayList(itemArrayList, filterType);
+        return filterItemArrayList.size();
+    }
+
+    public ArrayList<String> filterTypeArrayList(String rawData)  {
+        ArrayList<Item> itemArrayList = createItemArrayList(rawData);
+        ArrayList<String> filterType = new ArrayList<String>();
+
+        for(int i = 0; i < itemArrayList.size(); i++) {
+            if (!filterType.contains(itemArrayList.get(i).getName())) {
+                filterType.add(itemArrayList.get(i).getName());
+            }
+        }
+        return filterType;
+    }
+
+    public String formatText(String rawData) throws ItemParseException {
+        ArrayList<String> filterType = filterTypeArrayList(rawData);
+        StringBuilder sb = new StringBuilder();
+
+            for (int i = 0; i < filterType.size(); i++) {
+                String name = filterType.get(i);
+                Integer total = totalTimesItemSeen(rawData, filterType.get(i));
+                String priceFormated = formatPriceField(rawData, filterType.get(i));
+                sb.append("name: ");
+                sb.append(String.format("%7s", name.substring(0, 1).toUpperCase() + name.substring(1)));
+                sb.append("\t \t");
+                sb.append(" seen: " + total + " times\n");
+                sb.append("============= \t \t =============\n");
+                sb.append(priceFormated + "\n");
+            }
+
+        sb.append("Errors              " + " seen: " + getExceptionsThrown(rawData) + " times");
+
+        return sb.toString();
+    }
+
+    public String formatPriceField(String rawData, String filterType)  {
+        Map<Double, Integer> priceTotals = itemTypeMapWithCounts(rawData, filterType);
+        StringBuilder sb = new StringBuilder();
+        Set mapSet = (Set) priceTotals.entrySet();
+        Iterator mapIterator = mapSet.iterator();
+        while (mapIterator.hasNext()) {
+            Map.Entry mapEntry = (Map.Entry) mapIterator.next();
+            // getKey Method of HashMap access a key of map
+            Object keyValue = mapEntry.getKey();
+            //getValue method returns corresponding key's value
+            Object value = mapEntry.getValue();
+            String time = (1 < (Integer)value) ?  " times": " time";
+            sb.append("Price:   " + keyValue + "\t\t seen: " + value + time + "\n");
+            if (mapIterator.hasNext()) sb.append(String.format("-------------        -------------\n"));
+            if(priceTotals.size() < 2) sb.append(String.format("-------------        -------------\n"));
+
+        }
+        return sb.toString();
+    }
+
+    public String checkName(String input) {
+        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 return null;
+    }
+
+    public String fixCookie(String input){
+        Pattern patternCookies = Pattern.compile("([Cc][0Oo][0Oo][Kk][Ii][Ee][Ss])");
+        Matcher matcherCookie= patternCookies.matcher(input);
+        return matcherCookie.replaceAll("cookies");
     }
 
+    public String checkPrice(String input) {
+        Pattern patternPrice = Pattern.compile("([Pp]...[Ee]:)(\\d\\.\\d{2})");
+        Matcher matcherPrice= patternPrice.matcher(input);
 
+        if (matcherPrice.find())
+            return matcherPrice.group(2);
+        else return null;
+    }
+
+    public String checkType(String input) {
+        Pattern patternType = Pattern.compile("([Tt]..[Ee]:)(\\w+)");
+        Matcher matcherType = patternType.matcher(input);
+
+        if (matcherType.find())
+            return matcherType.group(2).toLowerCase();
+        else return null;
+    }
+
+    public String checkExpiration(String input) {
+        Pattern patternExpiration = Pattern.compile("([Ee]........[Nn]:)(\\d\\/\\d{2}\\/\\d{4})");
+        Matcher matcherExpiration = patternExpiration.matcher(input);
 
+        if (matcherExpiration.find())
+            return matcherExpiration.group(2);
+        else return null;
+    }
+
+    public Integer getExceptionsThrown(String rawData)  {
+        ArrayList<String> parsedRawData = parseRawDataIntoStringArray(rawData);
+        for (int i = 0; i < parsedRawData.size(); i++)
+            try {
+                parseStringIntoItem(parsedRawData.get(i));
+            } catch (ItemParseException e){
+                countExceptionsThrown++;
+            }
+        return this.countExceptionsThrown;
+    }
 }
+
+
+//    public String checkName(String input) throws ItemParseException{
+//        Pattern patternName = Pattern.compile("([Nn]..[Ee]:)(\\w+)");
+//        Matcher matcherName= patternName.matcher(input);
+//
+//        if (matcherName.find())
+//            return matcherName.group(2).toLowerCase();
+//        else throw new ItemParseException();
+//    }
+
+//    Pattern[] patternName = new Pattern[4];
+//        patternName[0] = Pattern.compile("([Nn]..[Ee]:)([Mm]..[Kk])");
+//                patternName[1] = Pattern.compile("([Nn]..[Ee]:)([Bb]...[Dd])");
+//                patternName[2] = Pattern.compile("([Nn]..[Ee]:)([Cc].....[Ss])");
+//                patternName[3] = Pattern.compile("([Nn]..[Ee]:)([Aa]....[Ss])");
+//
+//                for (int i = 0; i < patternName.length; i++) {
+//        Matcher nameMatcher = patternName[i].matcher(input);
+//        if (nameMatcher.find()) {
+//        return "milk";
+//        } else if (nameMatcher.find()) {
+//        return "bread";
+//        } else if (nameMatcher.find()) {
+//        return "cookies";
+//        } else if (nameMatcher.find()) {
+//        return "apples";
+//        }
+//        }
+//        throw new ItemParseException();

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

@@ -13,7 +13,9 @@ public class Main {
 
     public static void main(String[] args) throws Exception{
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
+        ItemParser item = new ItemParser();
+        ItemParseException itemParseException = new ItemParseException();
+        System.out.println(item.formatText(output));
         // TODO: parse the data in output into items, and display to console.
     }
 }

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

@@ -14,11 +14,25 @@ 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##"
                                       +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
+    private String rawMultipleItems2 = "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:3.23;type:Food;expiration:2/25/2016##"
+                                    +"NAMe:BrEAD;price:3.23;type:Food;expiration:2/25/2016##"
+                                    +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##"
+                                    +"NAMe:BrEAD;price:2.23;type:Food;expiration:2/25/2016##";
+
+    private String rawMultipleItemsBroken = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##"
+            +"naME:;price:1.23;type:Food;expiration:1/02/2016##"
+            +"NAMe:BrEAD;price:3.23;type:Food;expiration:2/25/2016##"
+            +"NAMe:BrEAD;price:;type:Food;expiration:2/25/2016##"
+            +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##"
+            +"NAMe:BrEAD;price:2.23;type:Food;expiration:##";
+
     private ItemParser itemParser;
 
     @Before
@@ -59,4 +73,136 @@ public class ItemParserTest {
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void createItemArrayListTest() {
+        String expected ="name:milk price:3.23 type:food expiration:1/25/2016";
+        String actual  = itemParser.createItemArrayList(rawMultipleItems).get(0).toString();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void filterItemArrayListTest() {
+        ArrayList<Item> filterItemArrayListTester = itemParser.createItemArrayList(rawMultipleItems);
+        String expected ="[name:bread price:1.23 type:food expiration:1/02/2016, name:bread price:1.23 type:food expiration:2/25/2016]";
+        String actual  = itemParser.filterItemArrayList(filterItemArrayListTester,"bread").toString();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void individualItemCountTest1() {
+        ArrayList<Item> individualItemCountTester = itemParser.filterItemArrayList(itemParser.createItemArrayList(rawMultipleItems),"bread");
+        String expected ="{1.23=2}";
+        String actual  = itemParser.individualItemCount(individualItemCountTester).toString();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void individualItemCountTest2()  {
+        ArrayList<Item> individualItemCountTester = itemParser.filterItemArrayList(itemParser.createItemArrayList(rawMultipleItems2),"bread");
+        String expected ="{3.23=2, 2.23=1, 1.23=2}";
+        String actual  = itemParser.individualItemCount(individualItemCountTester).toString();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void itemTypeMapWithCountsTest() throws ItemParseException {
+        String expected ="{3.23=2, 2.23=1, 1.23=2}";
+        String actual  = itemParser.itemTypeMapWithCounts(rawMultipleItems2,"bread").toString();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void totalTimesItemSeen() throws ItemParseException {
+        Integer expected = 5;
+        Integer actual  = itemParser.totalTimesItemSeen(rawMultipleItems2, "bread");
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void filterTypeArrayListTest() throws ItemParseException {
+        String expected = "[milk, bread]";
+        String actual = itemParser.filterTypeArrayList(rawMultipleItems2).toString();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void formatTextTest() throws ItemParseException {
+        String expected = "name:    Milk\t \t seen: 1 times\n" +
+                "============= \t \t =============\n" +
+                "Price:   3.23\t\t seen: 1 time\n" +
+                "-------------        -------------\n" +
+                "\n" +
+                "name:   Bread\t \t seen: 5 times\n" +
+                "============= \t \t =============\n" +
+                "Price:   3.23\t\t seen: 2 times\n" +
+                "-------------        -------------\n" +
+                "Price:   2.23\t\t seen: 1 time\n" +
+                "-------------        -------------\n" +
+                "Price:   1.23\t\t seen: 2 times\n" +
+                "\n" +
+                "Errors               seen: 0 times";
+        String actual = itemParser.formatText(rawMultipleItems2).toString();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void formatPriceFieldTest() throws ItemParseException {
+        String expected = "Price:   3.23\t\t seen: 2 times\n" +
+                "-------------        -------------\n" +
+                "Price:   2.23\t\t seen: 1 time\n" +
+                "-------------        -------------\n" +
+                "Price:   1.23\t\t seen: 2 times\n";
+        String actual = itemParser.formatPriceField(rawMultipleItems2, "bread").toString();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void checkNameTest1() {
+        String rawItemTest = "naMe:c00kies;price:3.23;type:Food;expiration:1/25/2016##";
+        String expected = "cookies";
+        String  actual = itemParser.checkName(rawItemTest);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void checkNameTest2() {
+        String rawItemTest = "naMe:mIlk;price:3.23;type:Food;expiration:1/25/2016##";
+        String expected = "milk";
+        String  actual = itemParser.checkName(rawItemTest);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void checkPriceTest() throws ItemParseException{
+        String rawItemTest = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+        String expected = "3.23";
+        String  actual = itemParser.checkPrice(rawItemTest);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void checkTypeTest() throws ItemParseException{
+        String rawItemTest = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+        String expected = "food";
+        String  actual = itemParser.checkType(rawItemTest);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void checkExpirationTest() throws ItemParseException{
+        String rawItemTest = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+        String expected = "1/25/2016";
+        String  actual = itemParser.checkExpiration(rawItemTest);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void getExceptionsThrownTest() {
+        Integer expected = 3;
+        Integer  actual = itemParser.getExceptionsThrown(rawMultipleItemsBroken);
+        assertEquals(expected, actual);
+    }
 }