Correct pagination logic on SortedCollection

Closes #4.

Author: jhgg

epoxy/contrib/relay/connections/sorted_collection.py

@@ -5,74 +5,6 @@
 
 
 class SortedCollection(object):
-    """Sequence sorted by a key function.
-
-    SortedCollection() is much easier to work with than using bisect() directly.
-    It supports key functions like those use in sorted(), min(), and max().
-    The result of the key function call is saved so that keys can be searched
-    efficiently.
-
-    Instead of returning an insertion-point which can be hard to interpret, the
-    five find-methods return a specific item in the sequence. They can scan for
-    exact matches, the last item less-than-or-equal to a key, or the first item
-    greater-than-or-equal to a key.
-
-    Once found, an item's ordinal position can be located with the index() method.
-    New items can be added with the insert() and insert_right() methods.
-    Old items can be deleted with the remove() method.
-
-    The usual sequence methods are provided to support indexing, slicing,
-    length lookup, clearing, copying, forward and reverse iteration, contains
-    checking, item counts, item removal, and a nice looking repr.
-
-    Finding and indexing are O(log n) operations while iteration and insertion
-    are O(n).  The initial sort is O(n log n).
-
-    The key function is stored in the 'key' attribute for easy introspection or
-    so that you can assign a new key function (triggering an automatic re-sort).
-
-    In short, the class was designed to handle all of the common use cases for
-    bisect but with a simpler API and support for key functions.
-
-    >>> from pprint import pprint
-    >>> from operator import itemgetter
-
-    >>> s = SortedCollection(key=itemgetter(2))
-    >>> for record in [
-    ...         ('roger', 'young', 30),
-    ...         ('angela', 'jones', 28),
-    ...         ('bill', 'smith', 22),
-    ...         ('david', 'thomas', 32)]:
-    ...     s.insert(record)
-
-    >>> pprint(list(s))         # show records sorted by age
-    [('bill', 'smith', 22),
-     ('angela', 'jones', 28),
-     ('roger', 'young', 30),
-     ('david', 'thomas', 32)]
-
-    >>> s.find_le(29)           # find oldest person aged 29 or younger
-    ('angela', 'jones', 28)
-    >>> s.find_lt(28)           # find oldest person under 28
-    ('bill', 'smith', 22)
-    >>> s.find_gt(28)           # find youngest person over 28
-    ('roger', 'young', 30)
-
-    >>> r = s.find_ge(32)       # find youngest person aged 32 or older
-    >>> s.index(r)              # get the index of their record
-    3
-    >>> s[3]                    # fetch the record at that index
-    ('david', 'thomas', 32)
-
-    >>> s.key = itemgetter(0)   # now sort by first name
-    >>> pprint(list(s))
-    [('angela', 'jones', 28),
-     ('bill', 'smith', 22),
-     ('david', 'thomas', 32),
-     ('roger', 'young', 30)]
-
-    """
-
     def __init__(self, key=None):
         self._given_key = key
         key = (lambda x: x) if key is None else key
@@ -178,38 +110,32 @@ def get_connection(self, relay, type_name, args):
         if not count:
             return self.empty_connection(relay, type_name)
 
-        begin_key = cursor.get_offset(after, None) or self._keys[0]
-        end_key = cursor.get_offset(before, None) or self._keys[-1]
-
-        begin = self.bisect_left(begin_key)
-        end = self.bisect_right(end_key)
+        begin_key = cursor.get_offset(after, None)
+        end_key = cursor.get_offset(before, None)
 
-        if begin >= count or begin >= end:
-            return self.empty_connection(relay, type_name)
+        lower_bound = begin = self.bisect_left(begin_key) + 1 if begin_key else 0
+        upper_bound = end = self.bisect_right(end_key) - 1 if end_key else count
 
-        first_preslice_cursor = cursor.from_offset(self._keys[begin])
-        last_preslice_cursor = cursor.from_offset(self._keys[min(end, count) - 1])
+        if upper_bound < count and self._keys[upper_bound] != end_key:
+            upper_bound = end = count
 
         if first is not None:
             end = min(begin + first, end)
         if last is not None:
             begin = max(end - last, begin)
 
-        if begin >= count or begin >= end:
-            return self.empty_connection(relay, type_name)
-
         sliced_data = self._items[begin:end]
 
         edges = [Edge(node=node, cursor=cursor.from_offset(self._key(node))) for node in sliced_data]
-        first_edge = edges[0]
-        last_edge = edges[-1]
+        first_edge = edges[0] if edges else None
+        last_edge = edges[-1] if edges else None
 
         return Connection(
             edges=edges,
             page_info=relay.PageInfo(
-                start_cursor=first_edge.cursor,
-                end_cursor=last_edge.cursor,
-                has_previous_page=(first_edge.cursor != first_preslice_cursor),
-                has_next_page=(last_edge.cursor != last_preslice_cursor)
+                start_cursor=first_edge and first_edge.cursor,
+                end_cursor=last_edge and last_edge.cursor,
+                has_previous_page=begin > lower_bound,
+                has_next_page=end < upper_bound
             )
         )