dotintent · Banarim · Oct 25, 2016
diff --git a/...src/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/DataCellItem.java b/...src/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/DataCellItem.java
@@ -1,6 +1,6 @@
 package com.infullmobile.android.recyclerviewwithdynamicsubtitles;
 
-public class DataCellItem<T> implements ListItem {
+class DataCellItem<T> implements ListItem {
 
     private T data;
 

diff --git a/...com/infullmobile/android/recyclerviewwithdynamicsubtitles/DynamicRecyclerViewAdapter.java b/...com/infullmobile/android/recyclerviewwithdynamicsubtitles/DynamicRecyclerViewAdapter.java
@@ -57,16 +57,17 @@ public final int getItemViewType(int position) {
     public final int getItemCount() {
         return sectionedItemList.size();
     }
-
+    
     public final void setData(@Nullable Collection<DataObject> items,
                               @NonNull SectionEvaluator<DataObject> sectionEvaluator) {
-        setData(items, sectionEvaluator, Comparators.ASCENDING_COMPARATOR);
+        setData(items, sectionEvaluator, SectionComparators.ASCENDING_COMPARATOR, new EmptyItemComparator<DataObject>());
     }
 
     public final void setData(@Nullable Collection<DataObject> items,
                               @NonNull SectionEvaluator<DataObject> sectionEvaluator,
-                              @NonNull Comparator<Section> comparator) {
-        final SectionedItems<DataObject> sectionedItems = new SectionedItems<>(sectionEvaluator, items, comparator);
+                              @NonNull Comparator<Section> sectionComparator,
+                              @NonNull Comparator<DataObject> dataObjectComparator) {
+        final SectionedItems<DataObject> sectionedItems = new SectionedItems<>(sectionEvaluator, items, sectionComparator, dataObjectComparator);
         mapOfSections = sectionedItems.getSections();
         insertNewItems(sectionedItems);
     }

diff --git a/...n/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/EmptyItemComparator.java b/...n/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/EmptyItemComparator.java
@@ -0,0 +1,11 @@
+package com.infullmobile.android.recyclerviewwithdynamicsubtitles;
+
+import java.util.Comparator;
+
+public class EmptyItemComparator<DataObject> implements Comparator<DataObject> {
+
+    @Override
+    public int compare(DataObject lhs, DataObject rhs) {
+        return 0;
+    }
+}
diff --git a/...les/src/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/ListItem.java b/...les/src/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/ListItem.java
@@ -1,5 +1,5 @@
 package com.infullmobile.android.recyclerviewwithdynamicsubtitles;
 
-public interface ListItem {
+interface ListItem {
     boolean isHeader();
 }
diff --git a/...tles/src/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/Section.java b/...tles/src/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/Section.java
@@ -8,17 +8,17 @@
 import java.util.Collection;
 import java.util.List;
 
-public class Section<T> {
+class Section<T> {
 
     private final List<ListItem> items;
     private final List<T> dataItems;
     private final String title;
 
-    public Section(@NonNull T firstItem, @NonNull String title) {
+    Section(@NonNull T firstItem, @NonNull String title) {
         this(Arrays.asList(firstItem), title);
     }
 
-    public Section(@NonNull List<T> items, @NonNull String title) {
+    Section(@NonNull List<T> items, @NonNull String title) {
         this.title = title;
         dataItems = new ArrayList<>(items);
         this.items = createListItems(title, items);
@@ -33,22 +33,22 @@ private List<ListItem> createListItems(String title, List<T> items) {
         return listItems;
     }
 
-    public void addNewItem(@Nullable T item) {
+    void addNewItem(@Nullable T item) {
         if (item != null) {
             dataItems.add(item);
             items.add(new DataCellItem<>(item));
         }
     }
 
-    public String getTitle() {
+    String getTitle() {
         return title;
     }
 
-    public Collection<ListItem> getListItems() {
+    Collection<ListItem> getListItems() {
         return items;
     }
 
-    public Collection<T> getDataItems() {
+    Collection<T> getDataItems() {
         return dataItems;
     }
 }
diff --git a/...viewwithdynamicsubtitles/Comparators.java → ...hdynamicsubtitles/SectionComparators.java b/...viewwithdynamicsubtitles/Comparators.java → ...hdynamicsubtitles/SectionComparators.java
@@ -2,9 +2,9 @@
 
 import java.util.Comparator;
 
-public final class Comparators {
+public final class SectionComparators {
 
-    private Comparators() {
+    private SectionComparators() {
         throw new AssertionError("No instances.");
     }
 

diff --git a/...ain/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/SectionHeaderItem.java b/...ain/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/SectionHeaderItem.java
@@ -1,14 +1,14 @@
 package com.infullmobile.android.recyclerviewwithdynamicsubtitles;
 
-public class SectionHeaderItem implements ListItem {
+class SectionHeaderItem implements ListItem {
 
     private final String sectionName;
 
     SectionHeaderItem(String sectionName) {
         this.sectionName = sectionName;
     }
 
-    public String getSectionName() {
+    String getSectionName() {
         return sectionName;
     }
 

diff --git a/...c/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/SectionedItems.java b/...c/main/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/SectionedItems.java
@@ -12,39 +12,59 @@
 import java.util.List;
 import java.util.Map;
 
-public class SectionedItems<T> {
+class SectionedItems<T> {
 
     private final SectionEvaluator<T> sectionEvaluator;
     private List<Section<T>> listOfOrderedSections = Collections.emptyList();
 
     SectionedItems(@NonNull SectionEvaluator<T> sectionEvaluator,
                    @Nullable Collection<T> items,
-                   @NonNull Comparator<Section> comparator) {
+                   @NonNull Comparator<Section> sectionComparator,
+                   @NonNull Comparator<T> dataObjectComparator) {
         this.sectionEvaluator = sectionEvaluator;
-        setData(items, comparator);
+        setData(items, sectionComparator, dataObjectComparator);
     }
 
-    private void setData(@Nullable Collection<T> items, @NonNull Comparator<Section> comparator) {
+    private void setData(@Nullable Collection<T> items,
+                         @NonNull Comparator<Section> sectionComparator,
+                         @NonNull Comparator<T> dataObjectComparator) {
         listOfOrderedSections.clear();
-        listOfOrderedSections = itemsToSections(items, comparator);
+        listOfOrderedSections = itemsToSections(items, sectionComparator, dataObjectComparator);
     }
 
-    public List<ListItem> getItems() {
+    List<ListItem> getItems() {
         final List<ListItem> result = new ArrayList<>();
         for (Section<T> section : listOfOrderedSections) {
             result.addAll(section.getListItems());
         }
         return result;
     }
 
-    public Map<String, Section<T>> getSections() {
+    Map<String, Section<T>> getSections() {
         final Map<String, Section<T>> mapOfSections = new HashMap<>();
         for (Section<T> section : listOfOrderedSections) {
             mapOfSections.put(section.getTitle(), section);
         }
         return mapOfSections;
     }
 
+    @NonNull
+    private List<Section<T>> itemsToSections(@Nullable Collection<T> items,
+                                             @NonNull Comparator<Section> sectionComparator,
+                                             @NonNull Comparator<T> dataObjectComparator) {
+        return (items != null)
+                ? sortSections(getSectionsOfItems(sortItems(items, dataObjectComparator)), sectionComparator)
+                : Collections.<Section<T>>emptyList();
+    }
+
+    @NonNull
+    private List<T> sortItems(@NonNull Collection<T> items,
+                              @NonNull Comparator<T> comparator) {
+        final List<T> listOfItems = new LinkedList<>(items);
+        Collections.sort(listOfItems, comparator);
+        return listOfItems;
+    }
+
     @NonNull
     private List<Section<T>> sortSections(@NonNull Collection<Section<T>> sectionedItems,
                                           @NonNull Comparator<Section> comparator) {
@@ -53,13 +73,6 @@ private List<Section<T>> sortSections(@NonNull Collection<Section<T>> sectionedI
         return listOfSections;
     }
 
-    @NonNull
-    private List<Section<T>> itemsToSections(@Nullable Collection<T> items,
-                                             @NonNull Comparator<Section> comparator) {
-        return (items != null) ? sortSections(getSectionsOfItems(items), comparator)
-                                 : Collections.<Section<T>>emptyList();
-    }
-
     @NonNull
     private Collection<Section<T>> getSectionsOfItems(@Nullable Collection<T> items) {
         final Map<String, Section<T>> mapOfAllAddedSections = new HashMap<>();

diff --git a/...va/com/infullmobile/android/recyclerviewwithdynamicsubtitles/EmptyItemComparatorTest.java b/...va/com/infullmobile/android/recyclerviewwithdynamicsubtitles/EmptyItemComparatorTest.java
@@ -0,0 +1,35 @@
+package com.infullmobile.android.recyclerviewwithdynamicsubtitles;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EmptyItemComparatorTest {
+
+    private static final String lowest = "aTitle";
+    private static final String medium = "bTitle";
+    private static final String highest = "cTitle";
+
+    private List<String> listOfItems;
+
+    @Before
+    public void setUp() throws Exception {
+        listOfItems = Arrays.asList(lowest, medium, highest);
+    }
+
+    @Test
+    public void shouldReturnItemsInTheSameOrder() {
+        // when
+        Collections.sort(listOfItems, new EmptyItemComparator<String>());
+
+        // then
+        assertThat(listOfItems.get(0)).isEqualTo(lowest);
+        assertThat(listOfItems.get(1)).isEqualTo(medium);
+        assertThat(listOfItems.get(2)).isEqualTo(highest);
+    }
+}
diff --git a/...withdynamicsubtitles/ComparatorsTest.java → ...amicsubtitles/SectionComparatorsTest.java b/...withdynamicsubtitles/ComparatorsTest.java → ...amicsubtitles/SectionComparatorsTest.java
@@ -9,7 +9,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class ComparatorsTest {
+public class SectionComparatorsTest {
 
     private static final Section<String> lowest = new Section<>("item", "aTitle");
     private static final Section<String> medium = new Section<>("item", "bTitle");
@@ -25,7 +25,7 @@ public void setUp() throws Exception {
     @Test
     public void ascedingComparatorShouldCompareSectionsAscedning() {
         // when
-        Collections.sort(listOfSections, Comparators.ASCENDING_COMPARATOR);
+        Collections.sort(listOfSections, SectionComparators.ASCENDING_COMPARATOR);
 
         // then
         assertThat(listOfSections.get(0)).isEqualTo(lowest);
@@ -36,7 +36,7 @@ public void ascedingComparatorShouldCompareSectionsAscedning() {
     @Test
     public void descedingComparatorShouldCompareSectionsDescending() {
         // when
-        Collections.sort(listOfSections, Comparators.DESCENDING_COMPARATOR);
+        Collections.sort(listOfSections, SectionComparators.DESCENDING_COMPARATOR);
 
         // then
         assertThat(listOfSections.get(0)).isEqualTo(highest);

diff --git a/...st/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/SectionedItemsTest.java b/...st/java/com/infullmobile/android/recyclerviewwithdynamicsubtitles/SectionedItemsTest.java
@@ -4,6 +4,7 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 
@@ -17,17 +18,24 @@ public class SectionedItemsTest {
     private static final String FIRST_ITEM = "firstItem";
     private final static String SECOND_ITEM = "secondItem";
     private final static String SECOND_SECOND_ITEM = "secondsecondItem";
+    private static final String FIRST_IN_ALPHABETICAL_ORDER_ITEM = "A";
+    private static final String SECOND_IN_ALPHABETICAL_ORDER_ITEM = "B";
+    private static final String THIRD_IN_ALPHABETICAL_ORDER_ITEM = "C";
     private final static int TWO_HEADER_AND_THREE_ITEMS = 5;
 
     List<String> testItems = Arrays.asList(FIRST_ITEM, SECOND_ITEM, SECOND_SECOND_ITEM);
+    List<String> mixedUpTestItems = Arrays.asList(THIRD_IN_ALPHABETICAL_ORDER_ITEM,
+                                                  FIRST_IN_ALPHABETICAL_ORDER_ITEM,
+                                                  SECOND_IN_ALPHABETICAL_ORDER_ITEM);
 
     @Test
     public void shouldCreateCorrectSectionedItemsWithTwoSections() {
         // given
         sectionedItems = new SectionedItems<>(
                 new FirstLetterSectionEvaluator(),
                 testItems,
-                Comparators.ASCENDING_COMPARATOR);
+                SectionComparators.ASCENDING_COMPARATOR,
+                new EmptyItemComparator<String>());
 
         // when
         List<ListItem> listItems = sectionedItems.getItems();
@@ -53,7 +61,8 @@ public void shouldCreateCorrectSectionedItemsFromNullItems() {
         sectionedItems = new SectionedItems<>(
                 new FirstLetterSectionEvaluator(),
                 null,
-                Comparators.ASCENDING_COMPARATOR);
+                SectionComparators.ASCENDING_COMPARATOR,
+                new EmptyItemComparator<String>());
 
         // when
         List<ListItem> listItems = sectionedItems.getItems();
@@ -70,18 +79,36 @@ public void shouldCreateCorrectSectionedItemsFromEmptyList() {
         sectionedItems = new SectionedItems<>(
                 new FirstLetterSectionEvaluator(),
                 Collections.<String>emptyList(),
-                Comparators.ASCENDING_COMPARATOR);
+                SectionComparators.ASCENDING_COMPARATOR,
+                new EmptyItemComparator<String>());
 
         // when
         List<ListItem> listItems = sectionedItems.getItems();
         Map<String, Section<String>> mapOfSections = sectionedItems.getSections();
 
         // then
         assertThat(listItems).isEmpty();
-
         assertThat(mapOfSections).isEmpty();
     }
 
+    @Test
+    public void shouldReturnItemsInAlphabeticalOrder() {
+        // given
+        sectionedItems = new SectionedItems<>(
+                new FirstLetterSectionEvaluator(),
+                mixedUpTestItems,
+                SectionComparators.ASCENDING_COMPARATOR,
+                new AlphabeticalOrderItemComparator());
+
+        // when
+        List<ListItem> orderedItems = sectionedItems.getItems();
+
+        // then
+        assertThat(((SectionHeaderItem) orderedItems.get(0)).getSectionName()).isEqualTo(FIRST_IN_ALPHABETICAL_ORDER_ITEM);
+        assertThat(((SectionHeaderItem) orderedItems.get(2)).getSectionName()).isEqualTo(SECOND_IN_ALPHABETICAL_ORDER_ITEM);
+        assertThat(((SectionHeaderItem) orderedItems.get(4)).getSectionName()).isEqualTo(THIRD_IN_ALPHABETICAL_ORDER_ITEM);
+    }
+
     private static class FirstLetterSectionEvaluator implements SectionEvaluator<String> {
 
         @Override
@@ -91,4 +118,11 @@ public String evaluate(String string) {
                    : "/empty";
         }
     }
+
+    private static class AlphabeticalOrderItemComparator implements Comparator<String> {
+        @Override
+        public int compare(String lhs, String rhs) {
+            return lhs.compareTo(rhs);
+        }
+    }
 }