completed jerkson lab

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

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

@@ -1,11 +1,13 @@
 package io.zipcoder;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class ItemParser {
 
-
     public ArrayList<String> parseRawDataIntoStringArray(String rawData){
         String stringPattern = "##";
         ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
@@ -13,11 +15,18 @@ public class ItemParser {
     }
 
     public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+        ArrayList<String> values = getValues(rawItem);
+
+        String name = uppercase(correctSpelling(values.get(0)));
+        Double price = Double.valueOf(values.get(1));
+        String type = uppercase(values.get(2));
+        String expiration = values.get(3);
+
+        return new Item(name, price, type, expiration);
     }
 
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
+        String stringPattern = "[^a-zA-Z0-9\\:\\.\\/]";
         ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
         return response;
     }
@@ -26,6 +35,229 @@ public class ItemParser {
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
     }
 
+    //keys - (.+)(?=:)
+    //values - (?<=:)(.+)
+
+    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> KVPairs = findKeyValuePairsInRawItemData(rawItem);
+        ArrayList<String> values = new ArrayList<String>();
+        for(String pair : KVPairs){
+            String value = toLowerCase(getValue(pair));
+            if(value.equals("")){
+                throw new ItemParseException();
+            } else{
+                values.add(value);
+            }
+        }
+        return values;
+    }
+
+    public String toLowerCase(String input) {
+        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(input);
 
+        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);
+            }catch(ItemParseException e){
+                e.printStackTrace();
+            }
+        }
+        return items;
+    }
+
+    public Map<Object, Integer> getUniqueItemNames(ArrayList<Item> items, String methodname){
+
+        try {
+            Map<Object, Integer> uniqueNames = new HashMap<>();
+            for (Item item : items) {
+                Class<?> e = item.getClass();
+                Method method = e.getMethod(methodname);
+                if (!uniqueNames.containsKey(method.invoke(item))) {
+                    uniqueNames.put(method.invoke(item), new Integer(1));
+                } else {
+                    int amount = uniqueNames.get(method.invoke(item));
+                    amount = amount + 1;
+                    uniqueNames.put(method.invoke(item), amount);
+                }
+            }
+            return uniqueNames;
+
+        }catch(Exception e){
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public String correctSpelling(String test) {
+        String[] nums = {"0", "1", "3"};
+        String[] alpha = {"o", "l", "e"};
+
+        StringBuilder lowercase = new StringBuilder();
+
+        Pattern pattern = Pattern.compile(".");
+        Matcher matcher = pattern.matcher(test);
+
+        while(matcher.find()){
+            String character = matcher.group();
+            int index = indexOf(nums, character);
+            if(index != -1){
+                lowercase.append(alpha[index]);
+            } else{
+                lowercase.append(character);
+            }
+        }
+        return lowercase.toString();
+    }
+
+    public Map<String, Map<Double, Integer>> sortItems(ArrayList<Item> items){
+        Map<String, Map<Double, Integer>> uniqueItem = new HashMap<>();
+        Map<Object, Integer> names = getUniqueItemNames(items, "getName");
+
+        for(Object key : names.keySet()){
+            Map<Double, Integer> prices = new HashMap<>();
+            for(Item item : items){
+                if(item.getName().equals(key)){
+                    if(prices.containsKey(item.getPrice())){
+                        int amount = prices.get(item.getPrice());
+                        amount = amount + 1;
+                        prices.put(item.getPrice(), amount);
+                    } else {
+                        prices.put(item.getPrice(), 1);
+                    }
+                }
+                uniqueItem.put((String)key, prices);
+            }
+        }
+
+        return uniqueItem;
+    }
+
+    public String uppercase(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"};
+
+        ArrayList<String> answer = getCharList(test);
+
+        if(answer.size() > 0){
+            if(isUpper(answer.get(0))){
+                return listToString(answer);
+            } else {
+                int index = indexOf(lower, answer.get(0));
+                answer.remove(0);
+                answer.add(0, upper[index]);
+            }
+        }
+        return listToString(answer);
+    }
+
+    public ArrayList<String> getCharList(String input){
+        ArrayList<String> answer = new ArrayList<>();
+
+        Pattern pattern = Pattern.compile(".");
+        Matcher matcher = pattern.matcher(input);
+
+        while(matcher.find()){
+            answer.add(matcher.group());
+        }
+        return answer;
+    }
+
+    public String listToString(List<String> list){
+        StringBuilder stringBuilder = new StringBuilder();
+        for(String string : list){
+            stringBuilder.append(string);
+        }
+        return stringBuilder.toString();
+    }
+
+    public void print(String input){
+        int errs = findNumberOfErrors(input);
+        ArrayList<Item> items = findItems(input);
+        Map<Object, Integer> names = getUniqueItemNames(items, "getName");
+        Map<String, Map<Double, Integer>> uniqueItem = sortItems(items);
+
+        for(String name : uniqueItem.keySet()){
+            System.out.printf("name: %7s %20s \n", name, "seen: " + names.get(name) + " times");
+            System.out.println("=============     \t =============");
+            for(Double price : uniqueItem.get(name).keySet()){
+                System.out.printf("Price: %6s %20s \n", price, "seen: " + uniqueItem.get(name).get(price) + " times");
+            }
+            System.out.println("=============     \t =============");
+
+        }
+        System.out.printf("\nErrors %26s", "seen " + errs + " times" );
+    }
 }

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

@@ -2,9 +2,15 @@ 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"));
@@ -13,7 +19,7 @@ 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.print(output);
     }
 }

src/main/resources/RawDataEdit

@@ -0,0 +1,28 @@
+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##
+naMe:MiLK;price:3.23;type:Food^expiration:1/11/2016##
+naMe:Cookies;price:2.25;type:Food%expiration:1/25/2016##
+naMe:CoOkieS;price:2.25;type:Food*expiration:1/25/2016##
+naMe:COokIes;price:2.25;type:Food;expiration:3/22/2016##
+naMe:COOkieS;price:2.25;type:Food;expiration:1/25/2016##
+NAME:MilK;price:3.23;type:Food;expiration:1/17/2016##
+naMe:MilK;price:1.23;type:Food!expiration:4/25/2016##
+naMe:apPles;price:0.25;type:Food;expiration:1/23/2016##
+naMe:apPles;price:0.23;type:Food;expiration:5/02/2016##
+NAMe:BrEAD;price:1.23;type:Food;expiration:1/25/2016##
+naMe:;price:3.23;type:Food;expiration:1/04/2016##
+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##
+naMe:MiLK;priCe:;type:Food;expiration:1/11/2016##
+naMe:Cookies;price:2.25;type:Food;expiration:1/25/2016##
+naMe:Co0kieS;pRice:2.25;type:Food;expiration:1/25/2016##
+naMe:COokIes;price:2.25;type:Food;expiration:3/22/2016##
+naMe:COOkieS;Price:2.25;type:Food;expiration:1/25/2016##
+NAME:MilK;price:3.23;type:Food;expiration:1/17/2016##
+naMe:MilK;priCe:;type:Food;expiration:4/25/2016##
+naMe:apPles;prIce:0.25;type:Food;expiration:1/23/2016##
+naMe:apPles;pRice:0.23;type:Food;expiration:5/02/2016##
+NAMe:BrEAD;price:1.23;type:Food;expiration:1/25/2016##
+naMe:;price:3.23;type:Food^expiration:1/04/2016##

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:;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##"
@@ -30,6 +30,9 @@ public class ItemParserTest {
     public void parseRawDataIntoStringArrayTest(){
         Integer expectedArraySize = 3;
         ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        for(String string : items){
+            System.out.println(string);
+        }
         Integer actualArraySize = items.size();
         assertEquals(expectedArraySize, actualArraySize);
     }
@@ -50,6 +53,7 @@ public class ItemParserTest {
     public void findKeyValuePairsInRawItemDataTest(){
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItem).size();
+        System.out.println(itemParser.findKeyValuePairsInRawItemData(rawSingleItem));
         assertEquals(expected, actual);
     }
 
@@ -59,4 +63,37 @@ 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));
+    }
+
+    @Test
+    public void changeNumToAlphaTest(){
+        String test = "c00kies";
+        String expect = "cookies";
+
+        String actual = itemParser.correctSpelling(test);
+        Assert.assertEquals(expect, actual);
+
+    }
+
+    @Test
+    public void changeUpperTest(){
+        String test = "cookies";
+        String expect = "Cookies";
+
+        String actual = itemParser.uppercase(test);
+        Assert.assertEquals(expect, actual);
+    }
 }