Merge d5e75db into 335296d

flask_stupe/__init__.py

@@ -20,6 +20,11 @@
 except ImportError:  # pragma: no cover
     pymongo = False
 
+try:
+    from pymongo.collation import Collation
+except ImportError:  # pragma: no cover
+    Collation = False
+
 from flask_stupe.app import Stupeflask
 from flask_stupe.validation import *
 from flask_stupe.pagination import *

flask_stupe/pagination.py

@@ -2,13 +2,14 @@
 
 from flask import request
 
-from flask_stupe import pymongo
+from flask_stupe import Collation, pymongo
 
 __all__ = []
 
 
 if pymongo:
-    def _paginate(cursor, skip=None, limit=None, sort=None, count=True):
+    def _paginate(cursor, skip=None, limit=None, sort=None, count=True,
+                  collation=None):
         metadata = getattr(request, "metadata", None)
         if count and isinstance(metadata, dict):
             metadata.update(count=cursor.count())
@@ -32,19 +33,24 @@ def _paginate(cursor, skip=None, limit=None, sort=None, count=True):
                 if not isinstance(item, tuple):
                     sort[index] = (item, pymongo.ASCENDING)
             cursor.sort(sort)
+            if collation and Collation:
+                if not isinstance(collation, Collation):
+                    collation = Collation(locale=collation)
+                cursor = cursor.collation(collation)
         return cursor
 
     def paginate(function_or_cursor=None, skip=None, limit=None, sort=None,
-                 count=True):
+                 count=True, collation=False):
         """Apply pagination to the given MongoDB cursor or function"""
         if isinstance(function_or_cursor, pymongo.cursor.Cursor):
-            return _paginate(function_or_cursor, skip, limit, sort, count)
+            return _paginate(function_or_cursor, skip, limit, sort, count,
+                             collation)
 
         def __decorator(function):
             @functools.wraps(function)
             def __wrapper(*args, **kwargs):
                 cursor = function(*args, **kwargs)
-                return _paginate(cursor, skip, limit, sort, count)
+                return _paginate(cursor, skip, limit, sort, count, collation)
             return __wrapper
 
         if function_or_cursor:

tests/conftest.py

@@ -47,12 +47,23 @@ def limit(self, limit):
         return self.data
 
     def sort(self, sort):
+        self.sort_data = sort
         for sort_key, order in reversed(sort):
-            self.data = sorted(self.data, key=lambda d: d.get(sort_key, 0))
+
+            def get_key(d):
+                if hasattr(self, "collation_data"):
+                    return d.get(sort_key, 0).lower()
+                return d.get(sort_key, 0)
+
+            self.data = sorted(self.data, key=get_key)
             if order == -1:
                 self.data.reverse()
         return self.data
 
+    def collation(self, collation):
+        self.collation_data = collation
+        return self.sort(self.sort_data)
+
     def count(self):
         return len(self.data)
 

tests/pagination.py

@@ -1,7 +1,7 @@
 import pytest
 from flask import Flask, request
 
-from flask_stupe import Stupeflask, paginate
+from flask_stupe import Collation, Stupeflask, paginate
 from tests.conftest import Cursor
 
 
@@ -57,6 +57,23 @@ def foobar():
                                  {"foo": 1}, {"foo": 2}, {"foo": 3}]
 
 
+@pytest.mark.parametrize("app", [
+    Stupeflask(__name__),
+    Flask(__name__)
+])
+def test_paginate_collation(app):
+    with app.test_request_context():
+        @paginate(sort=["foo"], collation="en")
+        def paginate_1():
+            return Cursor([{"foo": "Ber"}, {"foo": "foo"}, {"foo": "bar"}])
+        if not Collation:
+            expected_result = [{"foo": "Ber"}, {"foo": "bar"}, {"foo": "foo"}]
+            assert paginate_1().data == expected_result
+        if Collation:
+            expected_result = [{"foo": "bar"}, {"foo": "Ber"}, {"foo": "foo"}]
+            assert paginate_1() == expected_result
+
+
 @pytest.mark.parametrize("app", [
     Stupeflask(__name__),
     Flask(__name__)