like 99% done

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

@@ -5,9 +5,7 @@ import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.lang.reflect.Array;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -15,6 +13,23 @@ public class ItemParser {
 
     private int numberOfExceptions;
 
+    public String readFromFile(String filePath) {
+        try {
+            File file = new File(filePath);
+            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
+            String stringFile = "";
+            String line;
+            while ((line = bufferedReader.readLine()) != null) {
+                stringFile += line + "\n";
+            }
+            bufferedReader.close();
+            return stringFile.trim();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
     public ArrayList<String> parseRawDataIntoStringArray(String rawData) {
         String stringPattern = "##";
         ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawData);
@@ -29,11 +44,11 @@ public class ItemParser {
         String type = findValue(keyValues.get(2));
         String expiration = findValue(keyValues.get(3));
 
-        return new Item(name, price, type, expiration);
+        return new Item(convertZeroTo0(name), price, type, expiration);
     }
 
-    public ArrayList<Item> parseRawDataIntoItems(String rawData) {
-        ArrayList<Item> itemList = new ArrayList<>();
+    public List<Item> parseRawDataIntoItems(String rawData) {
+        List<Item> itemList = new ArrayList<>();
 
         List<String> items = parseRawDataIntoStringArray(rawData);
 
@@ -47,7 +62,6 @@ public class ItemParser {
         return itemList;
     }
 
-
     public String findValue(String keyValue) throws ItemParseException {
         List<String> keyAndValue = splitStringWithRegexPattern(":", keyValue);
 
@@ -58,66 +72,90 @@ public class ItemParser {
         }
     }
 
-    public int countItem(ArrayList<Item> items, String name){
-        int count = 0;
+    public Map<String, Integer> itemCounts(List<Item> items) {
+        Map<String, Integer> itemMap = new HashMap<>();
 
-        for(Item item : items) {
-            if (name.equals(item.getName())) {
-                count++;
+        for (Item item : items) {
+            if (!itemMap.containsKey(item.getName())) {
+                itemMap.put(item.getName(), 1);
+            } else {
+                itemMap.put(item.getName(), itemMap.get(item.getName()) + 1);
             }
         }
 
-        return count;
+        return itemMap;
     }
 
-    public void printOutput(ArrayList<Item> items) {
-        ArrayList<Item> duplicateItems = new ArrayList<>();
+    public Map<Map<String, Double>, Integer> priceCounts(List<Item> items) {
+        Map<String, Double> namePrice = new HashMap<>();
+        Map<Map<String, Double>, Integer> itemMap = new HashMap<>();
 
         for (Item item : items) {
-            if (duplicateItems.size() == 0) {
-                System.out.println("name:    Milk\t\t seen: 6 times\n" +
-                        "=============\t\t =============\n" +
-                        "Price:   3.23\t\t seen: 5 times\n" +
-                        "-------------\t\t -------------\n" +
-                        "Price:   1.23\t\t seen: 1 time\n");
+            if (!namePrice.containsKey(item.getName())) {
+                namePrice.put(item.getName(), item.getPrice());
             }
         }
-
+        // im tired
+        return itemMap;
     }
 
-    public static void main(String[] args) {
-        ItemParser itemParser = new ItemParser();
-        File file = new File("src/main/resources/RawData.txt");
-
-        String rawData = itemParser.readFromFile(file);
+    public void printOutput(Map<String, Integer> itemMap) {
+        for (String name : itemMap.keySet()) {
+            System.out.println(String.format("name: %7s \t\t seen: %s times", capitalizeFirst(name), itemMap.get(name)));
+            System.out.println("============= \t\t =============");
+        }
+        System.out.println(String.format("\nErrors \t\t\t\t seen: %s times", getNumberOfExceptions()));
+    }
 
-        ArrayList<Item> items = itemParser.parseRawDataIntoItems(rawData);
+    public String convertToLowerCase(String input) {
+        String output = "";
 
-        itemParser.printOutput(items);
+        List<String> upperAlpha = splitStringWithRegexPattern("", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+        List<String> lowerAlpha = splitStringWithRegexPattern("", "abcdefghijklmnopqrstuvwxyz");
+        ArrayList<String> stringCharacters = stringToArrayList(input);
 
-//        System.out.println(itemParser.countItem(items, "milk"));
-//        System.out.println(itemParser.countItem(items, "bread"));
-//        System.out.println(itemParser.countItem(items, "cookies") + itemParser.countItem(items, "co0kies"));
-//        System.out.println(itemParser.countItem(items, "apples"));
-        System.out.println(itemParser.getNumberOfExceptions());
+        for (int i = 0; i < stringCharacters.size(); i++) {
+            for (int j = 0; j < upperAlpha.size(); j++) {
+                if (stringCharacters.get(i).equals(upperAlpha.get(j))) {
+                    stringCharacters.set(i, lowerAlpha.get(j));
+                }
+            }
+            output += stringCharacters.get(i);
+        }
+        return output;
+    }
 
-//        try {
-//            List<Item> items = itemParser.parseRawDataIntoItems(rawData);
-//
-//            for (Item item : items) {
-//                System.out.println(item);
-//            }
-//        } catch (ItemParseException e) {
-//            e.printStackTrace();
-//        }
+    public String convertZeroTo0(String input) {
+        String output = "";
+        ArrayList<String> stringCharacters = stringToArrayList(input);
 
+        for (int i = 0; i < stringCharacters.size(); i++) {
+            if (stringCharacters.get(i).equals("0")) {
+                stringCharacters.set(i, "o");
+            }
+            output += stringCharacters.get(i);
+        }
+        return output;
     }
 
-    public String convertToLowerCase(String input) {
+    public String capitalizeFirst(String input) {
         String output = "";
-
         List<String> upperAlpha = splitStringWithRegexPattern("", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
         List<String> lowerAlpha = splitStringWithRegexPattern("", "abcdefghijklmnopqrstuvwxyz");
+        ArrayList<String> stringCharacters = stringToArrayList(input);
+
+        for (int i = 0; i < stringCharacters.size(); i++) {
+            for (int j = 0; j < upperAlpha.size(); j++) {
+                if (stringCharacters.get(0).equals(lowerAlpha.get(j))) {
+                    stringCharacters.set(0, upperAlpha.get(j));
+                }
+            }
+            output += stringCharacters.get(i);
+        }
+        return output;
+    }
+
+    public ArrayList<String> stringToArrayList(String input) {
         ArrayList<String> stringCharacters = new ArrayList<>();
 
         Pattern pattern = Pattern.compile(".");
@@ -127,15 +165,7 @@ public class ItemParser {
             stringCharacters.add(matcher.group());
         }
 
-        for (int i = 0; i < stringCharacters.size(); i++) {
-            for (int j = 0; j < upperAlpha.size(); j++) {
-                if (stringCharacters.get(i).equals(upperAlpha.get(j))) {
-                    stringCharacters.set(i, lowerAlpha.get(j));
-                }
-            }
-            output += stringCharacters.get(i);
-        }
-        return output;
+        return stringCharacters;
     }
 
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
@@ -148,23 +178,19 @@ public class ItemParser {
         return new ArrayList<>(Arrays.asList(inputString.split(stringPattern)));
     }
 
-    public String readFromFile(File file) {
-        try {
-            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
-            String stringFile = "";
-            String line;
-            while ((line = bufferedReader.readLine()) != null) {
-                stringFile += line + "\n";
-            }
-            bufferedReader.close();
-            return stringFile.trim();
-        } catch (IOException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
     public int getNumberOfExceptions() {
         return numberOfExceptions;
     }
+
+    public static void main(String[] args) {
+        ItemParser itemParser = new ItemParser();
+
+        String rawData = itemParser.readFromFile("src/main/resources/RawData.txt");
+
+        List<Item> items = itemParser.parseRawDataIntoItems(rawData);
+
+        Map<String, Integer> itemMap = itemParser.itemCounts(items);
+
+        itemParser.printOutput(itemMap);
+    }
 }

src/main/resources/TestFile.txt

@@ -0,0 +1 @@
+meow meow

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

@@ -5,31 +5,32 @@ import org.junit.Before;
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Map;
 
 import static org.junit.Assert.*;
 
 public class ItemParserTest {
 
-    private String rawSingleItem =    "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+    private String rawSingleItem = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
 
     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;type:Food;expiration:1/25/2016##";
 
-    private String rawBrokenSingleItem1 =    "naMe:Milk;price:3.23;type:;expiration:1/25/2016##";
+    private String rawBrokenSingleItem1 = "naMe:Milk;price:3.23;type:;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##";
+            + "naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
+            + "NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
     private ItemParser itemParser;
 
     @Before
-    public void setUp(){
+    public void setUp() {
         itemParser = new ItemParser();
     }
 
     @Test
-    public void parseRawDataIntoStringArrayTest(){
+    public void parseRawDataIntoStringArrayTest() {
         Integer expectedArraySize = 3;
         ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
         Integer actualArraySize = items.size();
@@ -37,8 +38,8 @@ public class ItemParserTest {
     }
 
     @Test
-    public void parseStringIntoItemTest() throws ItemParseException{
-        Item expected = new Item("milk", 3.23, "food","1/25/2016");
+    public void parseStringIntoItemTest() throws ItemParseException {
+        Item expected = new Item("milk", 3.23, "food", "1/25/2016");
         Item actual = itemParser.parseStringIntoItem(rawSingleItem);
         assertEquals(expected.toString(), actual.toString());
     }
@@ -49,21 +50,102 @@ public class ItemParserTest {
 //    }
 
     @Test(expected = ItemParseException.class)
-    public void parseBrokenStringIntoItemTest1() throws ItemParseException{
+    public void parseBrokenStringIntoItemTest1() throws ItemParseException {
         itemParser.parseStringIntoItem(rawBrokenSingleItem1);
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTest(){
+    public void findKeyValuePairsInRawItemDataTest() {
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItem).size();
         assertEquals(expected, actual);
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTestIrregular(){
+    public void findKeyValuePairsInRawItemDataTestIrregular() {
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+
+    @Test
+    public void readFromFile() {
+        String expected = "meow meow";
+        String actual = itemParser.readFromFile("src/main/resources/TestFile.txt");
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void parseRawDataIntoItemsTest() {
+        int expected = 3;
+        int actual = itemParser.parseRawDataIntoItems(rawMultipleItems).size();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void findValue() throws ItemParseException {
+        String expected = "milk";
+        String actual = itemParser.findValue(itemParser.findKeyValuePairsInRawItemData(rawSingleItem).get(0));
+
+        Double expected1 = 3.23;
+        Double actual1 = Double.valueOf(itemParser.findValue(itemParser.findKeyValuePairsInRawItemData(rawSingleItem).get(1)));
+
+        String expected2 = "food";
+        String actual2 = itemParser.findValue(itemParser.findKeyValuePairsInRawItemData(rawSingleItem).get(2));
+
+        String expected3 = "1/25/2016";
+        String actual3 = itemParser.findValue(itemParser.findKeyValuePairsInRawItemData(rawSingleItem).get(3));
+
+        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(expected1, actual1);
+        Assert.assertEquals(expected2, actual2);
+        Assert.assertEquals(expected3, actual3);
+    }
+
+    @Test
+    public void countItem() {
+        Map<String, Integer> itemMap = itemParser.itemCounts(itemParser.parseRawDataIntoItems(rawMultipleItems));
+
+        int expected = 2;
+        int actual = itemMap.get("bread");
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void convertToLowerCase() {
+        String expected = "meow meow meow";
+        String actual = itemParser.convertToLowerCase("Meow mEOW meOw");
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void convertZeroTo0() {
+        String expected = "meow";
+        String actual = itemParser.convertZeroTo0("me0w");
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void capitalizeFirst() {
+        String expected = "Meow";
+        String actual = itemParser.capitalizeFirst("meow");
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void stringToArrayList() {
+        ArrayList<String> expected = new ArrayList<>();
+        expected.add("a");
+        expected.add("b");
+        expected.add("c");
+        ArrayList<String> actual = itemParser.stringToArrayList("abc");
+
+        Assert.assertEquals(expected, actual);
+    }
 }