sorted 0.3.8 → 0.3.9

data/.document

@@ -1,5 +1,3 @@
 README.rdoc
 lib/**/*.rb
-bin/*
-features/**/*.feature
 LICENSE

data/README.rdoc

@@ -1,87 +1,109 @@
 = sorted
 
-Sorted is a simple object that will take an sql order string and a url sort string to let you sort large datasets over many pages (using {will_paginate}[http://github.com/mislav/will_paginate]) without loosing state.
+Sorted is a simple object that will take an sql order string and a url
+sort string to let you sort large datasets over many pages (using
+{will_paginate}[http://github.com/mislav/will_paginatea] or
+{kaminari}[https://github.com/amatsuda/kaminari]) without loosing state.
 
-Using Rails master it will create a sorted scope and a two view helpers
-
-== Example
+If you would like to see it in action clone the
+{example app}[https://github.com/mynameisrufus/sorted_app]
 
 === Gemfile
 
-  gem sorted
+  gem 'sorted' '~> 0.3.9'
 
 === View
 
   link_to_sorted "Email", :email
 
-This will make a url like this:
+This will generate a link with a url like this:
 
   http://myapp/users?sort=email_asc
 
-or on the next page load when you then sort by something else....
+and on the next page load when you then sort by something else....
 
   http://myapp/users?sort=name_asc!email_asc
 
 === Model
 
-This will initially sort by email ascending:
+This will initially sort by email ascending with the optional second
+default order argument:
+
+  @users = User.sort(params[:sort], "email ASC").page(params[:page])
+
+==== Joins and includes
+
+If you want to sort by a belongs to relationship add the table name to
+the order argument. For example assuming a user belongs to a company:
+
+  @users = User.joins(:company).sort(params[:sort], "companies.name ASC").page(params[:page])
+
+When generating links using the +link_to_sorted+ method you should
+specify the table for every attribute you use as well otherwise you
+will probably get an ambiguous column name error.
+
+  <th class="ui-state-default"><%= link_to_sorted "Company name", 'companies.name' %></th>
+  <th class="ui-state-default"><%= link_to_sorted "Users name", 'users.name' %></th>
+
+==== Typecasting and DB functions
 
-  @users = User.sorted(:order => "email ASC", :sort => params[:sort]).paginate(:page => params[:page])
+Do your type casting and function calls in your select statement with an
+alias, for example:
 
-Or you can just clone the example app https://github.com/mynameisrufus/sorted_app.
+  # controller
+  @users = User.select("income::BigInt as bg_income").sort(params[:sort], "bg_income ASC")
+  
+  # view
+  <th class="ui-state-default"><%= link_to_sorted "Income", 'bg_income' %></th>
 
-If you want to sort by a belongs_to relationship, just provide sort order as "RELATIONS.COLUMN ASC|DESC" where
-RELATIONS is the name of the relationship table and COLUMN is an attribute in that table.  For example, 
-assuming the User model belongs_to a :company.
+or using a DB function:
 
-  @users = User.sorted(:order => "companies.name asc", :sort => params[:sort]).paginate(:page => params[:page])
+  # controller
+  @users = User.select("inet_aton(`ip_address`) AS in_ip").sort(params[:sort], "in_ip ASC")
+
+  # view
+  <th class="ui-state-default"><%= link_to_sorted "IP address", 'in_ip' %></th>
 
 == Presentation
 
-You might want to roll your own link_to_sorted method to use jQuery ui css classes for example, all you need is the sorted object.
+You might want to roll your own +link_to_sorted+ method to use jQuery ui
+css classes for example, all you need is the sorted object.
 
   def link_to_sorted(name, order)
-    sorter    = sorted(order)
-    css_class = case sorter.to_css
-                when "sorted asc"
-                  "ui-icon ui-icon-triangle-1-n"
-                when "sorted desc"
-                  "ui-icon ui-icon-triangle-1-s"
-                when "sorted"
-                  "ui-icon ui-icon-carat-2-n-s"
-                end
+    dup_params = (request.get? && !params.nil?) ? params.dup : nil
+    sorter     = ActionView::Base::SortedViewHelper.new(order, dup_params)
+    css_class  = case sorter.css
+                 when "sorted asc"
+                   "ui-icon ui-icon-triangle-1-n"
+                 when "sorted desc"
+                   "ui-icon ui-icon-triangle-1-s"
+                 when "sorted"
+                   "ui-icon ui-icon-carat-2-n-s"
+                 end
     link_to(content_tag(:span, nil, {:class => css_class}) + name.to_s, sorter.params)
   end
 
-Tables are best displayed with alternating shades for each row, so put this in your helper:
-
-  def odd_even
-    @odd_even ||= 0
-    @odd_even += 1
-    (@odd_even % 2) == 1 ? 'odd' : 'even'
-  end
-
-Then in your table do something like this:
+Tables are best displayed with alternating shades for each row, so add
+an alternating class to you table rows using the rails +cycle+ method:
 
-  <tr class="<%= odd_even %>">
+  <tr class="<%= cycle 'odd', 'even' %>">
 
 == Rails 2.3.x
 
-This gem works with rails 2.3.x but you will have to roll your own scope and view helper.
+Sorted works with rails 2.3.x but you will have to roll your own scope
+and view helper.
 
 Here is the named scope for your model(s):
 
-  named_scope :sorted, lambda { |params|
-    { :order =>  Sorted::Sorter.new(params[:order], {:sort => params[:sort]}).to_sql }
+  named_scope :sort, lambda { |sort, order|
+    { :order =>  Sorted::Parser.new(sort, order).to_sql }
   }
 
-and the the application helper methods:
+and the application helper method:
 
-  def sorted(order)
-    Sorted::Sorter.new(order, (request.get? && !params.nil?) ? params.dup : nil).toggle
-  end
-
-  def link_to_sorted(name, order)
-    sorter = sorted(order)
-    link_to(name, sorter.params, {:class => sorter.to_css})
+  def link_to_sorted(name, order, options = {})
+    dup_params      = (request.get? && !params.nil?) ? params.dup : nil
+    sorter          = Sorted::ViewHelpers::ActionView::SortedViewHelper.new(order, dup_params)
+    options[:class] = [options[:class], sorter.css].join(' ').strip
+    link_to(name.to_s, sorter.params, options)
   end

data/lib/sorted.rb

@@ -1,5 +1,4 @@
-require 'sorted/sorter'
-require 'sorted/toggler'
+require 'sorted/parser'
 
 module Sorted
 end

data/lib/sorted/orms/active_record.rb

@@ -0,0 +1,17 @@
+require 'active_record'
+require 'sorted'
+
+module Sorted
+  module Orms
+    module ActiveRecord
+      def self.enable!
+        ::ActiveRecord::Base.class_eval do
+          def self.sort(sort, order = nil)
+            sorter = ::Sorted::Parser.new(sort, order)
+            order sorter.to_sql
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorted/parser.rb

@@ -0,0 +1,79 @@
+require 'sorted/toggler'
+
+module Sorted
+  # Takes a sort query string and an SQL order string and parses the
+  # values to produce key value pairs.
+  #
+  # Example:
+  #  Sorted::Parser.new('phone_desc', 'name ASC').to_s #-> "phone_desc!name_asc"
+  class Parser
+    attr_reader :sort, :order, :sorts, :orders
+
+    # Regex to make sure we only get valid names and not injected code.
+    SORTED_QUERY_REGEX  = /([a-zA-Z0-9._]+)_(asc|desc)$/
+    SQL_REGEX           = /(([a-z0-9._]+)\s([asc|desc]+)|[a-z0-9._]+)/i
+
+    def initialize(sort, order = nil)
+      @sort   = sort
+      @order  = order
+      @sorts  = parse_sort
+      @orders = parse_order
+    end
+
+    def parse_sort
+      sort.to_s.split(/!/).map do |sort_string|
+        if m = sort_string.match(SORTED_QUERY_REGEX)
+          [m[1], m[2].downcase]
+        end
+      end.compact
+    end
+
+    def parse_order
+      order.to_s.split(/,/).map do |order_string|
+        if m = order_string.match(SQL_REGEX)
+          [(m[2].nil? ? m[1] : m[2]),(m[3].nil? ? "asc" : m[3].downcase)]
+        end
+      end.compact
+    end
+   
+    def to_hash
+      array.inject({}){|h,a| h.merge(Hash[a[0],a[1]])}
+    end
+    
+    def to_sql
+      array.map{|a| "#{a[0]} #{a[1].upcase}" }.join(', ')
+    end
+
+    def to_s
+      array.map{|a| a.join('_') }.join('!')
+    end
+
+    def to_a
+      array
+    end
+    
+    def toggle
+      @array = Toggler.new(sorts, orders).to_a
+      self
+    end
+    
+    def reset
+      @array = default
+      self
+    end
+
+    private
+
+    def array
+      @array ||= default
+    end
+
+    def default
+      sorts_new = sorts.dup
+      orders.each do |o|
+        sorts_new << o unless sorts_new.flatten.include?(o[0])
+      end
+      sorts_new
+    end
+  end
+end

data/lib/sorted/railtie.rb

@@ -4,8 +4,8 @@ module Sorted
   class Railtie < Rails::Railtie
     initializer "sorted.active_record" do |app|
       if defined? ::ActiveRecord
-        require 'sorted/finders/active_record'
-        Sorted::Finders::ActiveRecord.enable!
+        require 'sorted/orms/active_record'
+        Sorted::Orms::ActiveRecord.enable!
       end
     end
     

data/lib/sorted/toggler.rb

@@ -1,6 +1,13 @@
 module Sorted
+  # Takes a parsed arrays of sorts and orders, it then will reorder the
+  # pairs and flip the assendance of the first sort pair.
+  #
+  # Example:
+  #   sorts  = [['name', 'asc'], ['phone', 'desc']]
+  #   oredrs = [['name', 'asc']]
+  #   Sorted::Toggler.new(sorts, orders).to_a #-> [['name', 'desc'], ['phone', 'desc']]
   class Toggler
-    def initialize(orders, sorts)
+    def initialize(sorts, orders)
       @array = []
       @sorts      = sorts
       @orders     = orders

data/lib/sorted/version.rb

@@ -1,3 +1,3 @@
 module Example
-  VERSION = "0.3.8"
+  VERSION = "0.3.9"
 end

data/lib/sorted/view_helpers/action_view.rb

@@ -4,13 +4,28 @@ require 'sorted'
 module Sorted
   module ViewHelpers
     module ActionView
-      def sorted(order)
-        ::Sorted::Sorter.new(order, (request.get? && !params.nil?) ? params.dup : nil).toggle
+      class SortedViewHelper
+        attr_reader :params
+
+        def initialize(order, params)
+          sort = params.delete :sort
+          @params = params
+          @parser = ::Sorted::Parser.new(sort, order).toggle
+          @params[:sort] = @parser.to_s
+        end
+
+        def css
+          if @parser.sorts.flatten.include? @parser.orders[0][0]
+            "sorted #{@parser.sorts.assoc(@parser.orders[0][0]).last}"
+          else
+            "sorted"
+          end
+        end
       end
 
       def link_to_sorted(name, order, options = {})
-        sorter          = sorted(order)
-        options[:class] = [options[:class], sorter.to_css].join(' ').strip
+        sorter          = SortedViewHelper.new(order, ((request.get? && !params.nil?) ? params.dup : nil))
+        options[:class] = [options[:class], sorter.css].join(' ').strip
         link_to(name.to_s, sorter.params, options)
       end
     end

data/sorted.gemspec

@@ -15,10 +15,9 @@ Gem::Specification.new do |s|
   s.rubyforge_project         = "sorted"
 
   s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "rails", ">= 3.0.0"
+  s.add_development_dependency "rails", ">= 3.1.2"
   s.add_development_dependency "rspec", ">= 2.0.0"
 
-
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
   s.require_path = 'lib'

data/spec/sorted/orms/active_record_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Sorted::Orms::ActiveRecord do
+  before(:each) do
+    Sorted::Orms::ActiveRecord.enable!
+  end
+
+  it "should integrate with ActiveRecord::Base" do
+    ActiveRecord::Base.should respond_to(:sort)
+  end
+end

data/spec/sorted/parser_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Sorted::Parser, "params parsing" do
+  it "should not raise if pased nil arguments" do
+    lambda { Sorted::Parser.new(nil, nil).toggle }.should_not raise_error
+  end
+
+  it "should return a nice array from the order sql" do
+    sort   = nil
+    order  = "email ASC, phone ASC, name DESC"
+    result = [["email", "asc"], ["phone", "asc"], ["name", "desc"]]
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.orders.should eq result
+  end
+
+  it "should return a nice array from the sort params" do
+    sort   = "email_desc!name_desc"
+    order  = nil
+    result = [["email", "desc"], ["name", "desc"]]
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.sorts.should eq result
+  end
+
+  it "should combine sort and order params with sort params being of higer importance" do
+    sort   = "email_desc!name_desc"
+    order  = "email ASC, phone ASC, name DESC"
+    result = [["email", "desc"], ["name", "desc"], ["phone", "asc"]]
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.to_a.should eq result
+  end
+
+  it "should allow numbers, underscores and full stops in sort params" do
+    sort   = "assessmentsTable.name_desc!users_300.name_5_desc"
+    order  = nil
+    result = [["assessmentsTable.name", "desc"], ["users_300.name_5", "desc"]]
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.sorts.should eq result
+  end
+
+  it "should allow numbers, underscores and full stops in order params" do
+    sort   = nil
+    order  = "assessmentsTable.name ASC, users_300.name_5 ASC"
+    result = [["assessmentsTable.name", "asc"], ["users_300.name_5", "asc"]]
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.orders.should eq result
+  end
+
+  it "should default to asc if sort params order is ommited" do
+    sort   = nil
+    order  = :email
+    result = [["email", "asc"]]
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.orders.should eq result
+  end
+end
+
+describe Sorted::Parser, "return types" do
+  it "should return an sql sort string" do
+    sort   = "email_desc!name_desc"
+    order  = "email ASC, phone ASC, name DESC"
+    result = "email DESC, name DESC, phone ASC"
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.to_sql.should eq result
+  end
+
+  it "should return an hash" do
+    sort   = "email_desc!name_desc"
+    order  = "email ASC, phone ASC, name DESC"
+    result = {"email" => "desc", "name" => "desc", "phone" => "asc"}
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.to_hash.should eq result
+  end
+
+  it "should return an the encoded sort string" do
+    sort   = "email_desc!name_desc"
+    order  = "email ASC, phone ASC, name DESC"
+    result = "email_desc!name_desc!phone_asc"
+
+    sorter = Sorted::Parser.new(sort, order)
+    sorter.to_s.should eq result
+  end
+end

data/spec/sorted/toggler_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Sorted::Toggler do
+  it "should bring phone to first order importance but not toggle ascendance" do
+    orders = [["email", "asc"], ["phone", "asc"]]
+    sorts  = [["phone", "asc"]]
+    result = [["phone", "asc"], ["email", "asc"]]
+
+    toggler = Sorted::Toggler.new(sorts, orders)
+    toggler.to_a.should eq result
+  end
+
+  it "should toggle ascendance of email" do
+    orders = [["email", "desc"]]
+    sorts  = [["email", "asc"]]
+    result = [["email", "desc"]]
+
+    toggler = Sorted::Toggler.new(sorts, orders)
+    toggler.to_a.should eq result
+  end
+
+  it "should return both order params un-toggled with no sort param" do
+    orders = [["email", "asc"], ["phone", "asc"]]
+    sorts  = []
+    result = [["email", "asc"], ["phone", "asc"]]
+
+    toggler = Sorted::Toggler.new(sorts, orders)
+    toggler.to_a.should eq result
+  end
+
+  it "should toggle the email ascendance" do
+    orders = [["email", "asc"]]
+    sorts  = [["email", "asc"], ["phone", "asc"]]
+    result = [["email", "desc"], ["phone", "asc"]]
+
+    toggler = Sorted::Toggler.new(sorts, orders)
+    toggler.to_a.should eq result
+  end
+
+  it "should toggle the email ascendance" do
+    orders = [["email", "desc"]]
+    sorts  = [["email", "asc"], ["phone", "asc"]]
+    result = [["email", "desc"], ["phone", "asc"]]
+
+    toggler = Sorted::Toggler.new(sorts, orders)
+    toggler.to_a.should eq result
+  end
+
+  it "should toggle two 1..n sort values" do
+    orders = [["email", "asc"], ["phone", "asc"]]
+    sorts  = [["email", "asc"], ["phone", "asc"]]
+    result = [["email", "desc"], ["phone", "desc"]]
+
+    toggler = Sorted::Toggler.new(sorts, orders)
+    toggler.to_a.should eq result
+  end
+end

data/spec/sorted/view_helpers/action_view_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Sorted::ViewHelpers::ActionView do
+  it "should integrate with ActiveRecord::Base" do
+    ActionView::Base.send(:include, Sorted::ViewHelpers::ActionView)
+    ActionView::Base.new.should respond_to(:link_to_sorted)
+  end
+end
+
+describe Sorted::ViewHelpers::ActionView::SortedViewHelper do
+  it "should return the default sort order and preserve the existing params" do
+    order  = :email
+    params = { :page => 10 }
+    result = { :page => 10, :sort => "email_asc" }
+
+    sorter = Sorted::ViewHelpers::ActionView::SortedViewHelper.new order, params
+    sorter.params.should eq result
+  end
+
+  it "should only return the sorted css class if email has not yet been sorted" do
+    order  = :email
+    params = {}
+    result = "sorted"
+
+    sorter = Sorted::ViewHelpers::ActionView::SortedViewHelper.new order, params
+    sorter.css.should eq result
+  end
+
+  it "should only return the sorted css class if email has not yet been sorted" do
+    order  = :email
+    params = { :sort => "email_asc" }
+    result = "sorted asc"
+
+    sorter = Sorted::ViewHelpers::ActionView::SortedViewHelper.new order, params
+    sorter.css.should eq result
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'sorted/finders/active_record'
+require 'sorted'
+require 'sorted/orms/active_record'
 require 'sorted/view_helpers/action_view'
 require 'rspec'
-require 'rspec/autorun'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorted
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-04 00:00:00.000000000Z
+date: 2011-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70138519878420 !ruby/object:Gem::Requirement
+  requirement: &70134746957060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,21 +21,21 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *70138519878420
+  version_requirements: *70134746957060
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70138519876540 !ruby/object:Gem::Requirement
+  requirement: &70134746956600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.1.2
   type: :development
   prerelease: false
-  version_requirements: *70138519876540
+  version_requirements: *70134746956600
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70138519874500 !ruby/object:Gem::Requirement
+  requirement: &70134746956100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *70138519874500
+  version_requirements: *70134746956100
 description: lets you sort large data sets using view helpers and a scope
 email:
 - rufuspost@gmail.com
@@ -53,23 +53,23 @@ extra_rdoc_files: []
 files:
 - .document
 - .gitignore
-- .watchr
 - Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
 - lib/sorted.rb
-- lib/sorted/finders/active_record.rb
+- lib/sorted/orms/active_record.rb
+- lib/sorted/parser.rb
 - lib/sorted/railtie.rb
-- lib/sorted/sorter.rb
 - lib/sorted/toggler.rb
 - lib/sorted/version.rb
 - lib/sorted/view_helpers/action_view.rb
 - sorted.gemspec
-- spec/sorted_spec.rb
-- spec/sorter_spec.rb
+- spec/sorted/orms/active_record_spec.rb
+- spec/sorted/parser_spec.rb
+- spec/sorted/toggler_spec.rb
+- spec/sorted/view_helpers/action_view_spec.rb
 - spec/spec_helper.rb
-- spec/toggler_spec.rb
 homepage: http://rubygems.org/gems/sorted
 licenses: []
 post_install_message: 
@@ -84,7 +84,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1254694282220959241
+      hash: -354722037037653326
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: sorted
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: sort data with a database

data/.watchr

@@ -1,24 +0,0 @@
-module WatchrActions
-  def self.run_spec(file)
-    unless File.exist?(file)
-      puts "#{file} does not exist"
-      return
-    end
-
-    puts "Running #{file}"
-    system "rspec #{file}"
-  end
-end
-
-watch(/^lib\/(?:sorted\/)?(.*).rb/) do |m|
-  WatchrActions.run_spec("spec/#{m[1]}_spec.rb")
-end
-
-watch(/^spec\/.*_spec.rb/) do |m|
-  WatchrActions.run_spec(m[0])
-end
-
-watch(/^lib\/sorted\/finders\/active_record.rb/) do |m|
-  WatchrActions.run_spec('spec/sorted_spec.rb')
-end
-

data/lib/sorted/finders/active_record.rb

@@ -1,41 +0,0 @@
-require 'active_record'
-require 'sorted'
-
-module Sorted
-  module Finders
-    module ActiveRecord
-      def self.enable!
-        ::ActiveRecord::Base.class_eval do
-          # Define a symbolic sort column. This allows mapping a simple column name
-          # to a more complex sql order clause.
-          #  class Model < ActiveRecord::Base
-          #    symbolic_sort :ip_address, 'inet_aton(`ip_address`)'
-          #  end
-          def self.symbolic_sort(key, sql)
-            symbolic_sorts[key] = sql
-          end
-
-          def self.sorted(params)
-            sorter = ::Sorted::Sorter.new(params[:order], :sort => params[:sort], :symbolic_sorts => symbolic_sorts)
-            # Check if we parsed some relationship includes and apply them
-            # before applying the order
-            relation = self
-            if sorter.includes.size > 0
-              # Remove self.name from includes
-              my_name = self.name.to_sym
-              real_includes = sorter.includes.delete_if{|include_name| include_name == my_name}
-              relation = includes(real_includes) if real_includes.size > 0
-            end
-            relation.order(sorter.to_sql)
-          end
-
-          private
-
-          def self.symbolic_sorts
-            @symbolic_sorts ||= {}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sorted/sorter.rb

@@ -1,122 +0,0 @@
-module Sorted
-  class Sorter
-    attr_reader :includes
-    def initialize(order, params = nil)
-      @includes = []
-      @symbolic_sorts = {}
-
-      if order.is_a?(String) || order.is_a?(Symbol)
-        parse_order(order)
-      end
-      if params.is_a?(Hash)
-        @params = params
-        if @params[:sort].is_a?(String) 
-          parse_sort @params[:sort]
-        end
-        @symbolic_sorts = @params[:symbolic_sorts] || {}
-      end
-    end
-    
-    def parse_sort(sort_string)
-      sort_string.split(/!/).each do |sort|
-        if parsed = parse_query(sort)
-          sorts << parsed
-        end 
-      end
-    end
-
-    def parse_order(order_string_or_symbol)
-      order_string_or_symbol.to_s.split(/,/).each do |order|
-        if parsed = parse_sql(order)
-          orders << parsed
-        end
-      end
-    end
-    
-    def parse_query(sort)
-      if m = sort.match(/([a-zA-Z0-9._]+)_(asc|desc)$/)
-        parse_include(m[1])
-        [m[1],m[2]]
-      end
-    end
-
-    def parse_sql(order)
-      if m = order.match(/(([a-zA-Z._:][a-zA-Z._:0-9]*)\s([asc|ASC|desc|DESC]+)|[a-zA-Z._:][a-zA-Z._:0-9]*)/)
-        sort_column = (m[2].nil? ? m[1] : m[2])
-        parse_include(sort_column)
-        [sort_column,(m[3].nil? ? "asc" : m[3].downcase)]
-      end
-    end
-
-    def parse_include(order)
-      if match_data = /^([^\.]+)\..+/.match(order)
-        include_name = match_data[1].singularize.to_sym
-        @includes << include_name unless @includes.include?(include_name)
-      end
-    end
-
-    def toggle
-      @array = Toggler.new(orders, sorts).to_a
-      self
-    end
-
-    def reset
-      @array = default
-      self
-    end
-
-    def to_hash
-      array.inject({}){|h,a| h.merge(Hash[a[0],a[1]])}
-    end
-    
-    def to_sql
-      array.map do |a|
-        column = @symbolic_sorts[a[0].to_sym] || a[0]
-        "#{column} #{a[1].upcase}"
-      end.join(', ')
-    end
-
-    def to_s
-      array.map{|a| a.join('_')}.join('!')
-    end
-
-    def to_a
-      array
-    end
-    
-    def to_css
-      if sorts.flatten.include?(orders[0][0])
-        "sorted #{sorts.assoc(orders[0][0]).last}"
-      else
-        "sorted"
-      end
-    end
-
-    def params
-      @params ||= {}
-      @params[:sort] = to_s
-      @params
-    end
-
-    def orders
-      @orders ||= []
-    end
-
-    def sorts
-      @sorts ||= []
-    end
-    
-    private
-    def default
-      sorts_new = sorts.dup
-      orders.each do |order|
-          sorts_new << order unless sorts_new.flatten.include?(order[0])
-      end
-      sorts_new
-    end
-    
-    def array
-      @array ||= default
-    end
-  end
-end

data/spec/sorted_spec.rb

@@ -1,122 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'action_controller'
-require 'sorted'
-
-describe Sorted::Finders::ActiveRecord do
-  before(:each) do
-    Sorted::Finders::ActiveRecord.enable!
-  end
-
-  it "should integrate with ActiveRecord::Base" do
-    ActiveRecord::Base.should respond_to(:sorted)
-  end
-
-  it "should define a symbolic_sorts method" do
-    ActiveRecord::Base.should respond_to(:symbolic_sort)
-  end
-
-  it "should define symbolic_sorts" do
-    a = Class.new(ActiveRecord::Base)
-    b = Class.new(ActiveRecord::Base)
-
-    a.symbolic_sort(:foo, 'foo')
-    b.symbolic_sort(:bar, 'bar')
-
-    a.instance_variable_get(:@symbolic_sorts).should == {:foo => 'foo'}
-    b.instance_variable_get(:@symbolic_sorts).should == {:bar => 'bar'}
-  end
-
-  it "should add orders to the relation" do
-    a = Class.new(ActiveRecord::Base)
-    relation = a.sorted(:order => nil, :sort => 'a_asc')
-    relation.order_values.should == ["a ASC"]
-  end
-
-  it "should add orders to the relation using symbolic_sorts" do
-    a = Class.new(ActiveRecord::Base)
-    a.symbolic_sort(:ip, 'inet_aton(`ip`)')
-    relation = a.sorted(:order => nil, :sort => 'ip_asc')
-    relation.order_values.should == ["inet_aton(`ip`) ASC"]
-  end
-end
-
-describe Sorted::ViewHelpers::ActionView do
-  before(:each) do
-    class TestController
-      def params
-        @params ||= {}
-      end
-
-      def params=(params)
-        @params = params
-      end
-
-      def request
-        Request.new
-      end
-      
-      def _prefixes
-      end
-    end
-    class Request
-      def get?; true end
-    end
-    @controller = TestController.new
-    ActionView::Base.send(:include, Sorted::ViewHelpers::ActionView)
-  end
-  
-  it "should integrate with ActionView::Base" do
-    ActionView::Base.new.should respond_to(:sorted)
-  end
-
-  it "should integrate with ActionView::Base" do
-    ActionView::Base.new.should respond_to(:link_to_sorted)
-  end
-
-  it "should not change the direction of name using view helper" do
-    @controller.params = {:sort => "name_desc!email_asc"}
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
-    sorter.toggle.to_a.should == [["email", "asc"], ["name", "desc"]]
-  end
-
-  it "should reverse email direction using view helper" do
-    @controller.params = {:sort => "email_asc!name_desc"}
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
-    sorter.toggle.to_a.should == [["email", "desc"], ["name", "desc"]]
-  end
-
-  it "should reverse email direction using view helper" do
-    @controller.params = {:sort => "email_desc!name_desc!phone_desc"}
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
-    sorter.toggle.params.should == {:sort => "email_asc!name_desc!phone_desc"}
-    @controller.params = sorter.params
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
-    sorter.toggle.params.should == {:sort => "email_desc!name_desc!phone_desc"}
-  end
-
-  it "should not reverse order when made first again" do
-    @controller.params = {:sort => "phone_desc!name_desc!email_desc"}
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
-    sorter.toggle.params.should == {:sort => "email_desc!phone_desc!name_desc"}
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:name)
-    sorter.toggle.params.should == {:sort => "name_desc!phone_desc!email_desc"}
-  end
-
-  it "should order correctly" do
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
-    sorter.toggle.params.should == {:sort => "email_asc"}
-    @controller.params = sorter.params
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:name)
-    sorter.toggle.params.should == {:sort => "name_asc!email_asc"}
-  end
-
-  it "should return a hash of options for url builder with sorted query string" do
-    @controller.params = {:sort => "email_asc!name_desc", :page => 2}
-    ActionView::Base.new([], {}, @controller).sorted(:email).params.should == {:sort => "email_desc!name_desc", :page => 2}
-  end
-
-  it "should not die if params nil" do
-    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
-    sorter.params.should == {:sort => "email_asc"}
-  end
-end

data/spec/sorter_spec.rb

@@ -1,65 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'action_controller'
-require 'sorted'
-
-describe Sorted::Sorter, "parse methods" do
-  it "should not die if pased dumb things" do
-    lambda { Sorted::Sorter.new(false, Time.now).should_not }.should_not raise_error
-  end
-
-  it "should return a nice array from the order sql" do
-    sorter = Sorted::Sorter.new("email ASC, phone ASC, name DESC", {:sort => "email_desc!name_desc"})
-    sorter.orders.should == [["email", "asc"], ["phone", "asc"], ["name", "desc"]]
-  end
-
-  it "should return a nice array from the sort params" do
-    sorter = Sorted::Sorter.new("email ASC, phone ASC, name DESC", {:sort => "email_desc!name_desc"})
-    sorter.sorts.should == [["email", "desc"], ["name", "desc"]]
-  end
-
-  it "should allow numbers, underscores, full stops and colons in" do
-    sorter = Sorted::Sorter.new('users.email ASC, users.phone_number DESC, assessments.name ASC, assessments.number_as_string::BigInt, assessments.column_with_number_123', {:sort => "users.email_desc!users.first_name_desc"})
-    sorter.to_sql.should == "users.email DESC, users.first_name DESC, users.phone_number DESC, assessments.name ASC, assessments.number_as_string::BigInt ASC, assessments.column_with_number_123 ASC"
-    sorter.includes.size.should == 2
-  end
-end
-
-describe Sorted::Sorter, "logic:" do
-  it "should not toggle the sort order and include any sql orders not in sort params" do
-    sorter = Sorted::Sorter.new("email ASC, phone ASC, name DESC", {:sort => "email_desc!name_desc"})
-    sorter.to_a.should == [["email", "desc"], ["name", "desc"], ["phone", "asc"]]
-    sorter.includes.size.should == 0
-  end
-
-  it "should return an sql sort string" do
-    Sorted::Sorter.new(:email).to_sql.should == "email ASC"
-    Sorted::Sorter.new(:email, {:sort => "name_desc!email_desc"}).to_sql.should == "name DESC, email DESC"
-  end
-
-  it "should handle a large initial order string" do
-    sorter = Sorted::Sorter.new('email ASC, name DESC, phone ASC', {:sort => "email_desc!name_desc"})
-    sorter.to_sql.should == "email DESC, name DESC, phone ASC"
-  end
-
-  it "should handle a large initial order string" do
-    sorter = Sorted::Sorter.new('email ASC, phone DESC, name ASC', {:sort => "email_desc!name_desc"})
-    sorter.to_sql.should == "email DESC, name DESC, phone DESC"
-  end
-
-  it "should substitute symbolic sorts" do
-    sorter = Sorted::Sorter.new('ip_address', :symbolic_sorts => {:ip_address => 'inet_aton(`ip_address`)'})
-    sorter.to_sql.should == "inet_aton(`ip_address`) ASC"
-  end
-end
-
-describe Sorted::Sorter, "to_css" do
-  it "should return css base class for to_css if not in sort params" do
-    sorter = Sorted::Sorter.new(:email)
-    sorter.to_css.should == "sorted"
-  end
-
-  it "should return css class for to_css" do
-    sorter = Sorted::Sorter.new(:email, {:sort => "email_desc"})
-    sorter.to_css.should == "sorted desc"
-  end
-end

data/spec/toggler_spec.rb

@@ -1,39 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'action_controller'
-require 'sorted'
-
-describe Sorted::Toggler, "toggle sorts" do
-  it "should should fail becasue the sort order is incorect" do
-    sorter = Sorted::Sorter.new(:jsci_complete, {:sort => "parent_id_desc!non_vocational_complete_desc!jsci_complete_desc"})
-    sorter.toggle
-    sorter.to_s.should_not == "parent_id_desc!non_vocational_complete_desc!jsci_complete_desc"
-  end
-
-  it "should toggle two order params at once" do
-    first = Sorted::Sorter.new("email ASC, phone ASC")
-    first.toggle.to_a.should == [["email", "asc"],["phone", "asc"]]
-    second = Sorted::Sorter.new(:name, {:sort => first.to_s})
-    second.toggle.to_a.should == [["name", "asc"], ["email", "asc"],["phone", "asc"]]
-    third = Sorted::Sorter.new("email ASC, phone ASC", {:sort => second.to_s})
-    third.toggle.to_a.should == [["email", "asc"],["phone", "asc"], ["name", "asc"]]
-  end
-end
-
-describe Sorted::Toggler, "add remaining orders" do
-  it "should toggle the sort order and include any sql orders not in sort params" do
-    sorter = Sorted::Sorter.new("email DESC, phone ASC, name DESC", {:sort => "email_desc!name_desc"})
-    sorter.toggle.to_a.should == [["email", "desc"], ["name", "desc"], ["phone", "asc"]]
-  end
-
-  it "should toggle the sort order and include any sql orders not in sort params" do
-    sorter = Sorted::Sorter.new("email DESC, phone ASC, name DESC", {:sort => "mobile_asc!email_desc!phone_asc!name_desc"})
-    sorter.toggle.to_a.should == [["email", "desc"], ["phone", "asc"], ["name", "desc"], ["mobile", "asc"]]
-  end
-end
-
-describe Sorted::Toggler, "add remaining sorts" do
-  it "should toggle the sort order and include any sort orders not in order params" do
-    sorter = Sorted::Sorter.new("email DESC", {:sort => "email_desc!name_desc"})
-    sorter.toggle.to_a.should == [["email", "asc"], ["name", "desc"]]
-  end
-end