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

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

@@ -1,4 +1,15 @@
 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

@@ -1,31 +1,66 @@
 package io.zipcoder;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import java.io.*;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static io.zipcoder.LeetUtils.*;
 
 public class ItemParser {
 
+    public static boolean checkForValue(String itemString) {
+        Pattern pattern = Pattern.compile("(:;)|(:%)|(:\\*)|(:@)|(:!)");
+        Matcher m = pattern.matcher(itemString);
+
+        return m.find();
+    }
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    public static ArrayList<String> parseRawDataIntoStringArray(String rawData){
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
-        return response;
+        return splitStringWithRegexPattern(stringPattern , rawData);
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public static Item parseStringIntoItem(String rawItem) throws ItemParseException{
+
+        if (checkForValue(rawItem)) {
+            throw new ItemParseException();
+        } else {
+            String[] values = allValues(rawItem.toLowerCase()).split(",");
+            return new Item(fullManipulate(values[0]), Double.parseDouble(values[1]), fullManipulate(values[2]), values[3]);
+        }
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
-        return response;
+    public static String allValues(String rawItem) {
+        StringBuilder sb = new StringBuilder();
+        
+        ArrayList<String> pairs = findKeyValuePairsInRawItemData(rawItem);
+        for (String s: pairs ) {
+            sb.append((sb.toString().equals("")) ? returnValue(s) : "," + returnValue(s));
+        }
+        return sb.toString();
     }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
-        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+    public static String returnValue (String pair) {
+        return pair.substring(pair.lastIndexOf(":") + 1);
     }
 
+    public static ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
+        String stringPattern = "[;^%*@!]";
+        return splitStringWithRegexPattern(stringPattern , rawItem);
+    }
 
+    private static ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
+        return new ArrayList<>(Arrays.asList(inputString.split(stringPattern)));
+    }
+
+    public static void printToFile(String fileName, String rawItemData) throws FileNotFoundException, ItemParseException {
 
+        OutPutObject opo = new OutPutObject(parseRawDataIntoStringArray(rawItemData));
+        PrintStream file = new PrintStream(new File(fileName));
+        PrintStream console = System.out;
+
+        System.setOut(file);
+        System.out.println(opo.outputString());
+    }
 }

src/main/java/io/zipcoder/LeetUtils.java

@@ -0,0 +1,77 @@
+package io.zipcoder;
+
+import java.util.stream.Collectors;
+
+public class LeetUtils {
+
+    public static Character numToLetter(Character c) {
+        switch (c) {
+            case '0':
+                return 'o';
+            case '1':
+                return 'l';
+            case '3':
+                return 'e';
+            case '4':
+                return 'a';
+            case '5':
+                return 's';
+            case '7':
+                return 't';
+            default:
+                return c;
+
+        }
+    }
+
+    public static String capitalizeMe(String s) {
+        return Character.toUpperCase((s.charAt(0))) + s.substring(1);
+    }
+
+    public static String l33TToString(String cookies) {
+        StringBuilder letterString = new StringBuilder();
+
+        for (int i = 0; i < cookies.length(); i++) {
+            letterString.append(LeetUtils.numToLetter(cookies.charAt(i)));
+        }
+        return letterString.toString();
+    }
+
+    public static String sameCase(String s) {
+        StringBuilder result =  new StringBuilder(s);
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            result.setCharAt(i, ch >= 'A' && ch <= 'Z' ? (char) (ch + 'a' - 'A') : ch);
+        }
+
+        return result.toString();
+    }
+
+    public static String fullManipulate(String s) {
+        return sameCase(l33TToString(s));
+    }
+
+    public static String stringFormatName(String name, int count) {
+        String time = (count > 1) ? "times" : "time";
+        return (String.format("name: %7s%6sseen: %d " + time, capitalizeMe(name), "", count));
+    }
+
+    public static String stringFormatPrice(Double price, int count, String label1, String label2) {
+        String time = (count > 1) ? "times" : "time";
+        return String.format("%7s%6.2f%5s%7s%d " + time + "\n",label1 + ": ", price,"",label2 + ": ", count);
+    }
+
+    public static String errorLine(int count) {
+        String time = (count > 1) ? "times" : "time";
+        return (String.format("%s%19s%2d " + time, "Errors", "seen: ", count));
+    }
+
+    public static String doubleLine() {
+        return (String.format("\n%8s%6s%8s\n", "=============", "", "============="));
+    }
+
+    public static String singleLine() {
+        return (String.format("%8s%6s%8s\n\n", "-------------", "", "-------------"));
+    }
+
+}

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

@@ -14,6 +14,6 @@ public class Main {
     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.
+        ItemParser.printToFile("tariqsShoppingList.txt", output);
     }
 }

src/main/java/io/zipcoder/OutPutObject.java

@@ -0,0 +1,89 @@
+package io.zipcoder;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import static io.zipcoder.ItemParser.checkForValue;
+import static io.zipcoder.ItemParser.parseStringIntoItem;
+import static io.zipcoder.LeetUtils.*;
+import static io.zipcoder.LeetUtils.errorLine;
+
+public class OutPutObject {
+    private int errorCount;
+    private HashMap<String, SameItems> allItemCounts;
+    private ArrayList<String> rawInputArray;
+    private ArrayList<Item> allItems;
+
+    public OutPutObject(ArrayList<String> rawInputArray) throws ItemParseException {
+        this.rawInputArray = rawInputArray;
+        this.allItems = new ArrayList<>();
+        errorCount = 0;
+
+        errorsAndCounts();
+        sameItemCounter(this.allItems);
+        allItemCounts = sameItemCounter(this.allItems);
+    }
+
+    public int getErrorCount() {
+        return errorCount;
+    }
+
+    public HashMap<String, SameItems> getAllItemCounts() {
+        return allItemCounts;
+    }
+
+    private void addErrorCount() {
+        this.errorCount = getErrorCount() + 1;
+    }
+
+    private void errorsAndCounts() throws ItemParseException {
+        for (String s:this.rawInputArray) {
+            if (checkForValue(s)) {
+                addErrorCount();
+            } else {
+                allItems.add(parseStringIntoItem(s));
+            }
+        }
+    }
+
+    private HashMap<String, SameItems> sameItemCounter(ArrayList<Item> allItems) {
+
+        HashMap<String, SameItems> itemCounters = new HashMap<>();
+        for (Item i: allItems) {
+            SameItems temp;
+            if (!itemCounters.keySet().contains(i.getName())) {
+                temp = new SameItems(i.getName());
+                temp.getPrices().addNewPrice(i.getPrice());
+                itemCounters.put(i.getName(), temp);
+            } else {
+                temp = itemCounters.get(i.getName());
+                if (!temp.getPrices().getPrices().keySet().contains(i.getPrice())) {
+                    temp.getPrices().addNewPrice(i.getPrice());
+                } else {
+                    temp.getPrices().IncrementPriceCounter(i.getPrice());
+                }
+                temp.setCount(temp.getCount() + 1);
+                itemCounters.put(i.getName(),temp);
+            }
+        }
+        return itemCounters;
+    }
+
+    public String outputString() {
+        StringBuilder resultsOutput = new StringBuilder();
+        resultsOutput.append("Tariq's Messed up Grocery List...\n\n");
+
+        for (SameItems s : this.getAllItemCounts().values()) {
+            resultsOutput.append(stringFormatName(s.getName(), s.getCount()));
+            resultsOutput.append(doubleLine());
+
+            for (Double d:s.getPrices().getPrices().keySet()) {
+                resultsOutput.append(stringFormatPrice(d, s.getPrices().getCount(d), "Price", "seen"));
+                resultsOutput.append(singleLine());
+            }
+        }
+
+        resultsOutput.append(errorLine(this.getErrorCount()));
+        return resultsOutput.toString();
+    }
+}

src/main/java/io/zipcoder/Prices.java

@@ -0,0 +1,26 @@
+package io.zipcoder;
+
+import java.util.HashMap;
+
+public class Prices {
+    private HashMap<Double, Integer > prices = new HashMap<>();
+
+    public void IncrementPriceCounter(Double price) {
+        prices.put(price, prices.get(price) + 1);
+    }
+
+    public void addNewPrice(Double price) {
+        prices.put(price, 1);
+    }
+
+    public Integer getCount(Double price) {
+        return prices.get(price);
+    }
+
+
+    public HashMap<Double, Integer> getPrices() {
+        return prices;
+    }
+
+
+}

src/main/java/io/zipcoder/SameItems.java

@@ -0,0 +1,34 @@
+package io.zipcoder;
+
+public class SameItems {
+    private String name;
+    private int count;
+    private Prices prices;
+
+    public SameItems(String name) {
+        this.name = name;
+        count = 1;
+        prices = new Prices();
+    }
+
+
+    public String getName() {
+        return name;
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public void setCount(int count) {
+        this.count = count;
+    }
+
+    public Prices getPrices() {
+        return prices;
+    }
+
+    public void setPrices(Prices prices) {
+        this.prices = prices;
+    }
+}

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

@@ -14,7 +14,9 @@ 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##";
+    // This string isn't broken!
+//    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##"
@@ -31,13 +33,14 @@ public class ItemParserTest {
         Integer expectedArraySize = 3;
         ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
         Integer actualArraySize = items.size();
+//        items.forEach(System.out::println);
         assertEquals(expectedArraySize, actualArraySize);
     }
 
     @Test
     public void parseStringIntoItemTest() throws ItemParseException{
         Item expected = new Item("milk", 3.23, "food","1/25/2016");
-        Item actual = itemParser.parseStringIntoItem(rawSingleItem);
+        Item actual = itemParser.parseStringIntoItem(itemParser.parseRawDataIntoStringArray(rawSingleItem).get(0));
         assertEquals(expected.toString(), actual.toString());
     }