passing tests

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

@@ -23,21 +23,25 @@ public class Item {
     }
 
     public String getName() {
+
         return name;
     }
 
 
     public Double getPrice() {
+
         return price;
     }
 
 
     public String getType() {
+
         return type;
     }
 
 
     public String getExpiration() {
+
         return expiration;
     }
 

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

@@ -1,7 +1,12 @@
 package io.zipcoder;
 
+import java.lang.reflect.Array;
 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 {
 
@@ -13,19 +18,154 @@ public class ItemParser {
     }
 
     public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+
+        ArrayList<String> values = getValues(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(toLowerCase(name),price,toLowerCase(type),expiration);
+
     }
 
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
+        String stringPattern = "[^a-zA-Z0-9\\:\\.\\/]";
         ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
         return response;
     }
 
     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 rawItem) throws ItemParseException{
+        ArrayList<String> pairing = findKeyValuePairsInRawItemData(rawItem);
+        ArrayList<String> values = new ArrayList<String>();
+        for(String pair : pairing) {
+            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 lowercase = 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);
+                lowercase.append(lower[i]);
+            }else{
+                lowercase.append(character);
+            }
+        }
+        return lowercase.toString();
+    }
+
+    public boolean isUpper(String c){
+        Pattern pattern = Pattern.compile("[A-Z]");
+        Matcher matcher = pattern.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 findNumberOfErrors(String input){
+
+        ArrayList<String> badFormat = new ArrayList<String>();
+        ArrayList<String> rawData = parseRawDataIntoStringArray(input);
+
+        for(String data : rawData){
+            try{
+                Item item = parseStringIntoItem(data);
+
+
+            }catch(ItemParseException e ){
+                badFormat.add(data);
+
+            }
+        }
+      return badFormat.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);
+//                System.out.format("%s %.2f \n", item.getName(), item.getPrice());
+            }catch(ItemParseException e ){
+                e.printStackTrace();
+
+            }
+        }
+        return items;
+    }
+
+    public Map<String, Integer> getUniqueItemNames(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 += 1;
+                uniqueNames.put(item.getName(), amount);
+            }
+        }
+        return uniqueNames;
     }
 
 
+//    private String[] getKeyValue(String input){
+//        Pattern pattern = Pattern.compile("([a-zA-Z0-9\\:\\.\\/]+)(?=[^\\/])");
+//        Matcher matcher = pattern.matcher(input);
+//
+//    }
+//    public String toLowerCase(String test){
+//        ArrayList<String> characters = new ArrayList<String>();
+//
+//        Pattern pattern = Pattern.compile("\\w");
+//        Matcher matcher = pattern.matcher(test);
+//
+//
+//
+//    }
 
 }

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

@@ -2,18 +2,31 @@ 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 itm = 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{
+    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.
-    }
+
+        int errs = itm.findNumberOfErrors(output);
+    //    ArrayList<Item> items = itm.findItems(output);
+
+
+//            System.out.format("%s %.2f \n", item.getName(), item.getPrice());
+
+        }
+
+
 }

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

@@ -14,7 +14,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:Milk;price:3.23;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##"
@@ -59,4 +59,18 @@ public class ItemParserTest {
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void toLowerCaseTest(){
+        String test = "MILK";
+        String expect = "milk";
+        String actual = itemParser.toLowerCase(test);
+        Assert.assertEquals(expect,actual);
+    }
+
+    @Test
+    public void isUpperTest(){
+        String test = "E";
+        Assert.assertTrue(itemParser.isUpper(test));
+    }
 }