almost done

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,177 @@
 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 {
 
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    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 Item parseStringIntoItem(String rawItem) throws ItemParseException {
+
+        ArrayList<String> values = getValues(toLowerCase(rawItem));
+
+        String name = values.get(0);
+        Double price = Double.valueOf(values.get(1));
+        String type = values.get(2);
+        String expiration = values.get(3);
+        return new Item(name, price, type, expiration);
+
+
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
+
+    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
+        String stringPattern = "[^a-zA-Z0-9\\:\\.\\/]";
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawItem);
         return response;
     }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
+    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString) {
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
     }
 
 
+    public String getValue(String input) throws ItemParseException {
+        ArrayList<String> kv = splitStringWithRegexPattern(":", input);
+
+        if (kv.size() < 2) {
+            throw new ItemParseException();
+
+        } else if (kv.size() == 2) {
+            return kv.get(1);
+        }
+        return null;
+    }
+
+
+    public ArrayList<String> getValues(String rawItems) throws ItemParseException {
+        ArrayList<String> kvPairs = findKeyValuePairsInRawItemData(rawItems);
+        ArrayList<String> values = new ArrayList<String>();
+
+
+        for (String pair : kvPairs) {
+            String value = getValue(pair);
+
+            if (value.equals("")) {
+                throw new ItemParseException();
+            } else {
+                values.add(value);
+            }
+        }
+        return values;
+    }
+
+
+    public String toLowerCase(String test) {
+
+
+        String[] lower = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
+        String[] upper = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
+        StringBuilder builde = new StringBuilder();
+
+        Pattern pattern = Pattern.compile(".");
+        Matcher matcher = pattern.matcher(test);
+
+        while (matcher.find()) {
+
+            String character = matcher.group();
+
+            if (isUpper(character)) {
+                int i = indexOf(upper, character);
+                builde.append(lower[i]);
+
+            } else {
+                builde.append(character);
+
+            }
+
+
+        }
+        return builde.toString();
+    }
+
+
+    public boolean isUpper(String c) {
+        Pattern patern = Pattern.compile("[A-Z]");
+        Matcher matcher = patern.matcher(c);
+        return matcher.find();
+
+    }
+
+    public int indexOf(String[] array, String c) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].equals(c))
+                return i;
+
+        }
+        return -1;
+    }
+
+    public int findNuberOfErrors(String input) {
+        ArrayList<String> rawData = parseRawDataIntoStringArray(input);
+        ArrayList<String> batFormat = new ArrayList<String>();
+
+        for (String data : rawData) {
+            try {
+                Item item = parseStringIntoItem(data);
+
+
+            } catch (ItemParseException e) {
+                batFormat.add(data);
+
+            }
+
+        }
+         return batFormat.size();
+    }
+
+
+    public ArrayList <Item> findItems(String input){
+        ArrayList<Item> items = new ArrayList<Item>();
+        ArrayList<String> rawData = parseRawDataIntoStringArray(input);
+
+        for (String data: rawData)  {
+            try {
+                Item item= parseStringIntoItem(data) ;
+                        items.add(item) ;
+            } catch (ItemParseException e) {
+                e.printStackTrace();
+            }
+        }
+        return items;
+    }
+
+    public Map<String, Integer> getUniqueNames(ArrayList<Item> items){
+        Map<String, Integer> uniqueNames = new HashMap<String, Integer>();
+
+        for (Item item: items) {
+            if(!uniqueNames.containsKey(item.getName())) {
+                uniqueNames.put(item.getName(),1);
+
+            } else {
+                int amount =uniqueNames.get(item.getName());
+                amount = amount +1;
+                uniqueNames.put(item.getName(),amount);
+            }
+
+        }
+        return uniqueNames;
+    }
 
-}
+}

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

@@ -2,18 +2,32 @@ package io.zipcoder;
 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
 
 public class Main {
+    private static ItemParser itemParser = new ItemParser();
 
     public String readRawDataToString() throws Exception{
+
         ClassLoader classLoader = getClass().getClassLoader();
         String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
         return result;
     }
 
     public static void main(String[] args) throws Exception{
+
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
+        int err= itemParser.findNuberOfErrors(output);
+        ArrayList <Item>  items= itemParser.findItems(output);
+
+
+
+
+
+
         // TODO: parse the data in output into items, and display to console.
     }
 }

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

@@ -14,7 +14,8 @@ 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##"
@@ -46,6 +47,7 @@ public class ItemParserTest {
         itemParser.parseStringIntoItem(rawBrokenSingleItem);
     }
 
+
     @Test
     public void findKeyValuePairsInRawItemDataTest(){
         Integer expected = 4;
@@ -59,4 +61,19 @@ public class ItemParserTest {
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+    @Test
+    public void toLowercase(){
+        String test = "MILK";
+        String expected = "milk";
+
+        String actual = itemParser.toLowerCase(test);
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void isUpperTest(){
+        String test = "Y";
+
+        Assert.assertTrue(itemParser.isUpper(test));
+    }
 }