Ticket #1115: paginate.py.diff.1

Index: paginate.py
===================================================================
--- paginate.py (revision 1888)
+++ paginate.py (working copy)
@@ -1,3 +1,5 @@
+import re
+import types
 from math import ceil
 import logging
 
@@ -2,4 +4,12 @@
 import cherrypy
+import sqlobject
 from sqlobject.main import SelectResults
 
+try:
+    # Can't depend on sqlalchemy being available.
+    import sqlalchemy
+    from sqlalchemy.ext.selectresults import SelectResults as SASelectResults
+except ImportError:
+    SASelectResults = None
+
 import turbogears
@@ -16,15 +26,19 @@
         def decorated(func, *args, **kw):
             page = int(kw.pop('tg_paginate_no', 1))
             limit_ = int(kw.pop('tg_paginate_limit', limit))
-            order = kw.pop('tg_paginate_order', default_order)
-            reversed = kw.pop('tg_paginate_reversed', None)
-            
+            order = kw.pop('tg_paginate_order', None)
+            ordering = kw.pop('tg_paginate_ordering', None)
+
+            # Convert ordering str to a dict.
+            if ordering:
+                ordering = convert_ordering(ordering)
+
             if not allow_limit_override:
                 limit_ = limit
+
+            log.debug("Pagination params: page=%s, limit=%s, order=%s "
+                      "", page, limit_, order)
             
-            log.debug("Pagination params: page=%s, limit=%s, order=%s, "
-                      "reversed=%s", page, limit_, order, reversed)
-            
             # get the output from the decorated function    
             output = func(*args, **kw)
             if not isinstance(output, dict):
@@ -37,18 +51,32 @@
             if order and not default_order:
                 raise "If you want to enable ordering you need " \
                       "to provide a default_order" 
-            
+            elif default_order and not ordering:
+                ordering = {default_order:[0, True]}
+            elif ordering and order:
+                sort_ordering(ordering, order)
+            log.info('ordering %s' % ordering)
+
             row_count = 0
-            if isinstance(var_data, SelectResults):
+            if isinstance(var_data, SelectResults) or \
+                    (SASelectResults and isinstance(var_data, SASelectResults)):
                 row_count = var_data.count()
-                col = getattr(var_data.sourceClass.q, order, None)
-                if default_order:
-                    if col:
-                        var_data = var_data.orderBy(col)
+                if ordering:
+                    # Build order_by list.
+                    order_cols = range(len(ordering))
+                    for (colname, order_opts) in ordering.items():
+                        col = sql_get_column(colname, var_data)
+                        if not col:
+                            raise StandardError, "The order column (%s) doesn't exist" % colname
+                        order_by_expr = sql_order_col(col, order_opts[1])
+                        order_cols[order_opts[0]] = order_by_expr
+                    # May need to address potential of ordering already
+                    # existing in var_data.
+                    # SO and SA differ on this method name.
+                    if hasattr(var_data, 'orderBy'):
+                        var_data = var_data.orderBy(order_cols)
                     else:
-                        raise "The order column (%s) doesn't exist" % order
-                    if reversed:
-                        var_data = var_data.reversed()
+                        var_data = var_data.order_by(order_cols)
             elif isinstance(var_data, list):
                 row_count = len(var_data)
             else:
@@ -69,15 +97,15 @@
             #input_values = cherrypy.request.input_values.copy()
             input_values = kw.copy()
             input_values.pop('self', None)
-            
+
             cherrypy.request.paginate = Paginate(current_page=page,
-                                                 limit=limit_, 
-                                                 pages=pages_to_show, 
-                                                 page_count=page_count, 
-                                                 input_values=input_values, 
-                                                 order=order,
-                                                 reversed=reversed)
-                                                 
+                                             limit=limit_, 
+                                             pages=pages_to_show, 
+                                             page_count=page_count, 
+                                             input_values=input_values, 
+                                             order=order,
+                                             ordering=ordering)
+                                             
             # we replace the var with the sliced one
             endpoint = offset + limit_
             log.debug("slicing data between %d and %d", offset, endpoint)
@@ -98,18 +126,30 @@
 class Paginate:
     """class for variable provider"""
     def __init__(self, current_page, pages, page_count, input_values, 
-                 limit, order, reversed):
+                 limit, order, ordering):
+        # If we have a nested dict from a form, it must be denormalized before
+        # it can be put into a GET URL.
+        #     {'form_field':{'text':'hello', 'hidden':''}
+        # Goes to:
+        #     {'form_field.text':'hello', 'form_field.hidden':''}
+        # I'm going to be specific so as to minimize breakage.
+        for (ikey, ivalue) in input_values.items():
+            if isinstance(ivalue, dict) and len(ivalue) > 1:
+                del input_values[ikey]
+                for (sub_ikey, sub_ivalue) in ivalue.items():
+                    new_key = '%s.%s' % (ikey, sub_ikey)
+                    input_values[new_key] = sub_ivalue
+                 
         self.pages = pages
         self.limit = limit
         self.page_count = page_count
         self.current_page = current_page
         self.input_values = input_values
         self.order = order
-        self.reversed = reversed
-        
+        self.ordering = ordering
+             
         self.input_values.update(dict(tg_paginate_limit=limit,
-                                      tg_paginate_order=order,
-                                      tg_paginate_reversed=reversed))
+                                      tg_paginate_ordering=ordering))
         if current_page < page_count:
             self.input_values.update(dict(
                                 tg_paginate_no=current_page+1,
@@ -136,31 +176,17 @@
             self.href_prev = None
             self.href_first = None
             
-    def get_href(self, page, order=None, reverse_order=None):
+    def get_href(self, page, order=None, reversed=None):
+        # Note that reversed is not used.  It should be cleaned up here and in
+        # the template.  I'm not removing it now because I don't want to break
+        # the API.
+        order = order or None
+        self.input_values['tg_paginate_no'] = page
         if order:
-            if order == self.order:
-                if self.reversed:
-                    reversed = None
-                else:
-                    reversed = True
-            else:
-                reversed = None
-                if reverse_order:
-                    if reversed:
-                        reversed = None
-                    else:
-                        reversed = True
-        else:
-            order = self.order
-            reversed = self.reversed
-        
-        self.input_values.update(dict(tg_paginate_no=page, 
-                                      tg_paginate_order=order,
-                                      tg_paginate_reversed=reversed))
-        
+            self.input_values['tg_paginate_order'] = order
+
         return turbogears.url('', self.input_values)
 
-
 def _select_pages_to_show(current_page, page_count, max_pages):
     pages_to_show = []
     
@@ -186,3 +212,70 @@
         end = page_count
         
     return range(start, end+1)
+
+def sort_ordering(ordering, sort_name):
+    """Rearrange ordering based on sort_name."""
+    log.info('sort called with %s and %s' % (ordering, sort_name))
+    if sort_name not in ordering:
+        ordering[sort_name] = [-1, True] 
+    if ordering[sort_name][0] == 0:
+        # Flip
+        ordering[sort_name][1] = not ordering[sort_name][1]
+    else:
+        ordering[sort_name][0] = 0
+        for key in ordering.keys():
+            if key != sort_name and ordering[key][0] < len(ordering) - 1:
+                ordering[key][0] += 1
+
+def sql_get_column(colname, var_data):
+    """Return a column from var_data based on colname."""
+    if isinstance(var_data, SelectResults):
+        col = getattr(var_data.sourceClass.q, colname, None)
+    elif isinstance(var_data, SASelectResults):
+        col = getattr(var_data._query.table.c, colname, None)
+    else:
+        raise StandardError, 'expected SelectResults'
+    return col
+
+def sql_order_col(col, ascending=True):
+    """Return an ordered col for col."""
+    if isinstance(col, sqlalchemy.schema.Column):
+        if ascending:
+            order_col = sqlalchemy.sql.asc(col)
+        else:
+            order_col = sqlalchemy.sql.desc(col)
+    elif isinstance(col, types.InstanceType):
+        # I don't like using InstanceType, but that's what sqlobject col type
+        # is.
+        if ascending:
+            order_col = col
+        else:
+            order_col = sqlobject.DESC(col)
+    else:
+        raise StandardError, 'expected Column, but got %s' % str(type(col))
+    return order_col
+   
+# Ordering re:
+ordering_expr = re.compile(r"('\w+'): ?\[(\d+), ?(True|False)\]")
+
+def convert_ordering(ordering):
+    """Covert ordering unicode string to dict."""
+
+    # eval would be simple, but insecure.
+    if not isinstance(ordering, (str, unicode)):
+        raise ValueError, "ordering should be string or unicode."
+    new_ordering = {}
+    try:
+        ordering_info_find = ordering_expr.findall(ordering)
+        emsg = "Didn't match ordering for %s." % str(ordering)
+        assert len(ordering_info_find) > 0, emsg
+        for ordering_info in ordering_info_find:
+            ordering_key = str(ordering_info[0]).strip("'")
+            ordering_order = int(ordering_info[1])
+            ordering_reverse = bool(ordering_info[2])
+            new_ordering[ordering_key] = [ordering_order,
+                                          ordering_reverse]
+    except StandardError, e:
+        log.debug('FAILED to convert ordering.')
+        new_ordering = None
+    return new_ordering