sorted 0.2.2 → 0.3.0

data/README.rdoc

@@ -1,27 +1,46 @@
 = sorted
 
-This wee gem lets you sort tables (or somthing else) using a view helper and a scope.
+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.
 
-It will toggle your sort order for you and will even work across pages with {will_paginate}[http://github.com/mislav/will_paginate]
-
-== Requirements
-
-activerecord >= 3.0.0
+Using Rails master it will create a `sorted` scope and a two view helpers
 
 == Example
 
-The view:
+=== The view:
 
   link_to_sorted "Email", :email
 
-The model:
+This will make a url like this:
+
+  http://myapp/users?sort=email_asc
 
-  @users = User.sorted(params[:order]).paginate(:page => params[:page])
+Or on the next page load when you then sort by something else....
 
-This will make a url like this:
+  http://myapp/users?sort=name_asc!email_asc
+
+=== The model:
+
+This will initially sort by email ascending:
+
+  @users = User.sorted(:order => "email ASC", :sort => params[:sort]).paginate(:page => params[:page])
+
+== Rails 2.3.x
+
+This gem works with rails 2.3.x but you will have to roll your own scope and view helper
+
+Here is the named scope:
+
+  named_scope :sorted, lambda { |params|
+    { :order =>  Sorted::Sorter.new(params[:order], {:sort => params[:sort]}).to_sql }
+  }
 
-  http://myapp/users?order=email_asc
+And this in your application helper:
 
-Or this when you then sort by somthing else....
+  def sorted(order)
+    Sorted::Sorter.new(order, (request.get? && !params.nil?) ? params.dup : nil).toggle
+  end
 
-  http://myapp/users?order=name_asc!email_desc
+  def link_to_sorted(name, order)
+    sorter = sorted(order)
+    link_to(name, sorter.params, {:class => sorter.css_class})
+  end

data/Rakefile

@@ -6,12 +6,10 @@ begin
   Jeweler::Tasks.new do |gem|
     gem.name = "sorted"
     gem.summary = %Q{sort a table}
-    gem.description = %Q{lets you sort tables (or somthing else) using a view helper and a custom scope}
+    gem.description = %Q{lets you sort large data sets using view helpers and a scope}
     gem.email = "rufuspost@gmail.com"
     gem.homepage = "http://github.com/mynameisrufus/sorted"
     gem.authors = ["Rufus Post"]
-    gem.add_dependency "activerecord", ">= 3.0.0"
-    gem.add_development_dependency "rspec", ">= 1.2.9"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/lib/sorted.rb

@@ -1,4 +1,114 @@
 module Sorted
+  class Sorter
+    def initialize(*args)
+      parse_order(args[0])
+      unless args[1].nil?
+        @params = args[1]
+        unless @params[:sort].nil?
+          parse_sort(@params[:sort])
+        end
+      end
+      self
+    end
+    
+    def parse_sort(sort)
+      sort.split(/!/).each do |s|
+        if ps = parse_query(s)
+          sort_queue << ps
+        end 
+      end
+    end
+
+    def parse_order(order)
+      order.to_s.split(/,/).each do |o|
+        if po = parse_sql(o)
+          order_queue << po
+        end
+      end
+    end
+    
+    def parse_query(sort)
+      if m = sort.match(/(\w+)_(asc|desc)/)
+        [m[1],m[2]]
+      end
+    end
+
+    def parse_sql(sql)
+      if m = sql.match(/(([a-zA-Z._]+)\s([asc|ASC|desc|DESC]+)|[a-zA-Z._]+)/)
+        [(m[2].nil? ? m[1] : m[2]),(m[3].nil? ? "asc" : m[3].downcase)]
+      end
+    end
+
+    def toggle
+      @_array = []
+      order_queue.select do |os|
+        sort_queue.flatten.include?(os[0])
+      end.each do |os|
+        @_array << [os[0], (case sort_queue.assoc(os[0])[1]; when "asc"; "desc"; when "desc"; "asc" end)]
+      end
+      order_queue.select do |o|
+        !@_array.flatten.include?(o[0])
+      end.each do |o|
+        @_array << [o[0], o[1]]
+      end
+      sort_queue.select do |s|
+        !@_array.flatten.include?(s[0])
+      end.each do |s|
+        @_array << [s[0], s[1]]
+      end
+      self
+    end
+
+    def un_toggle
+      @_array = default
+      self
+    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 css_class
+      "sorted-#{_array[0][1]}"
+    end
+
+    def params
+      @params ||= {}
+      @params[:sort] = to_s unless _array.empty?
+      @params
+    end
+
+    def order_queue
+      @order_queue ||= []
+    end
+
+    def sort_queue
+      @sort_queue ||= []
+    end
+    
+    private
+    def default
+      _default = sort_queue.dup
+      order_queue.each do |o|
+        unless _default.flatten.include?(o[0])
+          _default << [o[0], o[1]]
+        end
+      end
+      _default
+    end
+    
+    def _array
+      @_array ||= default
+    end
+  end
 end
 
 if defined?(::Rails::Railtie)

data/lib/sorted/action_view.rb

@@ -1,62 +1,16 @@
 require 'action_view'
+require 'sorted'
 
 module Sorted
   module ActionView
-    def sorted_params(attribute)
-      get_params = request.get? ? params.dup : {:order => nil}
-      get_params[:order] = sorted_order(get_params[:order], attribute)
-      get_params
+    def sorted(order)
+      ::Sorted::Sorter.new(order, (request.get? && !params.nil?) ? params.dup : nil).toggle
     end
 
-    def link_to_sorted(name, attribute, options = nil)
-      @sorted_params = sorted_params(attribute)
-      if options.nil?
-        options = {:class => sorted_css_class}
-      elsif options[:class].nil?
-        options.merge(:class => sorted_css_class)
-      else
-        options[:class] = "#{options[:class]} #{sorted_css_class}"
-      end
-      link_to(name, @sorted_params.merge(:order => sorted_to_string), options)
-    end
-
-    protected
-
-    def sorted_css_class
-      "sorted-#{@sorted_params[:order].first[1]}"
-    end
-
-    def sorted_order(sort_string, attribute, order_rest = {})
-      order_first = {attribute => 'asc'}
-      if sort_string.class == String
-        sort_string.split(/!/).each do |order|
-          order.match(/(\w+)_(asc|desc)/) do |match_data|
-            if match_data[1] == attribute.to_s
-              order_first = {attribute => sorted_sql_reverse(match_data[2])}
-            else
-              order_rest = order_rest.merge(match_data[1] => match_data[2])
-            end
-          end
-        end
-      end
-      order_first.merge(order_rest).symbolize_keys
-    end
-
-    def sorted_to_string
-      @sorted_params[:order].map do |order|
-        order.join('_')
-      end.join('!')
-    end
-
-    def sorted_sql_reverse(order)
-      case order
-      when 'asc'
-        'desc'
-      when 'desc'
-        'asc'
-      else
-        'asc'
-      end
+    def link_to_sorted(name, order, options = {})
+      sorter = sorted(order)
+      options[:class] = options[:class].nil? ? sorter.css_class : "#{options[:class]} #{sorter.css_class}"
+      link_to(name, sorter.params, options)
     end
   end
 end

data/lib/sorted/active_record.rb

@@ -1,17 +1,11 @@
 require 'active_record'
+require 'sorted'
 
 module Sorted
   module ActiveRecord
     def self.enable!
       ::ActiveRecord::Base.class_eval do
-        scope :sorted, lambda{|params|
-          return if params.nil?
-          order = []
-          params.split(/!/).each do |param|
-            order << param.gsub(/_asc/, ' ASC').gsub(/_desc/, ' DESC')
-          end
-          {:order => order.join(', ')}
-        }
+        scope :sorted, lambda { |params| Hash[:order, ::Sorted::Sorter.new(params[:order], {:sort => params[:sort]}).to_sql] }
       end
     end
   end

data/sorted.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sorted}
-  s.version = "0.2.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rufus Post"]
-  s.date = %q{2010-07-20}
-  s.description = %q{lets you sort tables (or somthing else) using a view helper and a custom scope}
+  s.date = %q{2010-07-23}
+  s.description = %q{lets you sort large data sets using view helpers and a scope}
   s.email = %q{rufuspost@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -46,15 +46,9 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.0"])
-      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
     else
-      s.add_dependency(%q<activerecord>, [">= 3.0.0"])
-      s.add_dependency(%q<rspec>, [">= 1.2.9"])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 3.0.0"])
-    s.add_dependency(%q<rspec>, [">= 1.2.9"])
   end
 end
 

data/spec/sorted_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'action_controller'
+require 'sorted'
 
 describe Sorted::ActiveRecord do
   before(:each) do
@@ -34,25 +35,93 @@ describe Sorted::ActionView do
   end
   
   it "should integrate with ActionView::Base" do
-    ActionView::Base.new.should respond_to(:sorted_params)
+    ActionView::Base.new.should respond_to(:sorted)
   end
 
-  it "should return a hash for url" do
-    @controller.params = {:order => "name_desc"}
-    ActionView::Base.new([], {}, @controller).sorted_params(:email).should == {:order => {:email => "asc", :name => "desc"}}
+  it "should return a nice hash from the order sql" do
+    sorter = Sorted::Sorter.new("email ASC, phone ASC, name DESC", {:sort => "email_desc!name_desc"})
+    sorter.order_queue.should == [["email", "asc"], ["phone", "asc"], ["name", "desc"]]
   end
 
-  it "should return a hash for url" do
-    @controller.params = {:order => "email_asc!name_desc"}
-    ActionView::Base.new([], {}, @controller).sorted_params(:email).should == {:order => {:email => "desc", :name => "desc"}}
+  it "should return a nice hash from the sort params" do
+    sorter = Sorted::Sorter.new("email ASC, phone ASC, name DESC", {:sort => "email_desc!name_desc"})
+    sorter.sort_queue.should == [["email", "desc"], ["name", "desc"]]
+  end
+  
+  it "should not 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.to_hash.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 => "email_desc!name_desc"})
+    sorter.toggle.to_hash.should == {"email" => "asc", "name" => "asc", "phone" => "asc"}
+  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_hash.should == {"email" => "desc", "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_hash.should == {"email" => "desc", "name" => "desc"}
+  end
+
+  it "should reverse email direction using view helper" do
+    @controller.params = {:sort => "phone_desc!name_desc!email_desc"}
+    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
+    sorter.toggle.params.should == {:sort => "email_asc!phone_desc!name_desc"}
+    @controller.params = sorter.params
+    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
+    sorter.toggle.params.should == {:sort => "email_desc!phone_desc!name_desc"}
+    @controller.params = sorter.params
+    sorter = ActionView::Base.new([], {}, @controller).sorted(:phone)
+    sorter.toggle.params.should == {:sort => "phone_asc!email_desc!name_desc"}
+    sorter = ActionView::Base.new([], {}, @controller).sorted(:name)
+    sorter.toggle.params.should == {:sort => "name_asc!email_desc!phone_desc"}
+  end
+
+  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 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 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 not die if params nil" do
+    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
+    sorter.params.should == {:sort => "email_asc"}
   end
 
-  it "should return a query string for link options" do
-    @controller.params = {:order => "email_asc!name_desc", :page => 2}
-    ActionView::Base.new([], {}, @controller).sorted_params(:email).should == {:order => {:email => "desc", :name => "desc"}, :page => 2}
+  it "should have some roll your own methods" do
+    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
+    sorter.to_s.should == "email_asc"
   end
 
-  it "should not care if params[:order] nil" do
-    ActionView::Base.new([], {}, @controller).sorted_params({:email => "desc", :name => "desc"}).should_not be_nil
+  it "should return css class" do
+    sorter = ActionView::Base.new([], {}, @controller).sorted(:email)
+    sorter.css_class.should == "sorted-asc"
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Rufus Post
@@ -14,40 +14,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-20 00:00:00 +10:00
+date: 2010-07-23 00:00:00 +10:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 0
-        version: 3.0.0
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 2
-        - 9
-        version: 1.2.9
-  type: :development
-  version_requirements: *id002
-description: lets you sort tables (or somthing else) using a view helper and a custom scope
+dependencies: []
+
+description: lets you sort large data sets using view helpers and a scope
 email: rufuspost@gmail.com
 executables: []