sort_order 0.1.1

data/features/sort_order.feature

@@ -0,0 +1,37 @@
+Scenario: Sort Order
+  Given the following tokens: users.first_name, users.last_name asc, users.email 0
+
+  When I output each as sql
+  Then I should get the following list: users.first_name ASC, users.last_name ASC, users.email DESC 
+
+  When I output the columns as sql
+  Then I should get the following string: users.first_name ASC, users.last_name ASC, users.email DESC
+
+  When I output the columns as sql (current only)
+  Then I should get the following string: users.first_name ASC
+
+  When I output each as a parameter
+  Then I should get the following list: first_name 1, last_name 1, email 0
+
+  When I output the columns as parameters
+  Then I should get the following hash: {:order=>["first_name 1", "last_name 1", "email 0"]}
+
+  When I output the columns as parameters (current only)
+  Then I should get the following hash: {:order=>"first_name 1"}
+  
+Scenario: Flipping Sort Orders!!!!
+  Given the following tokens: users.first_name, users.last_name asc, users.email 0
+
+  When I flip the current column
+  And I output the columns as sql (current only)
+  Then I should get the following string: users.first_name DESC
+
+  When I set the current column to: last_name 0
+  And I output the columns as sql (current only)
+  Then I should get the following string: users.last_name DESC
+
+
+
+
+
+  

data/features/step_definitions/sort_order_steps.rb

@@ -0,0 +1,50 @@
+Given /^the following tokens: (.+)$/ do |tokens|
+  @sort_order = SortOrder.new(*tokens.split(', '))
+end
+
+
+When /^I output (.+) as (.+)$/ do |item, format|
+  @result = case [item, format]
+  when ['each', 'a parameter']
+    @sort_order.map(&:to_param)
+  when ['each', 'sql']
+    @sort_order.map(&:to_sql)
+  when ['the columns', 'sql']
+    @sort_order.to_sql
+  when ['the columns', 'sql (current only)']
+    @sort_order.to_sql(:current => true)    
+  when ['the columns', 'parameters']
+    @sort_order.to_params
+  when ['the columns', 'parameters (current only)']
+    @sort_order.to_params(:current => true)
+  end
+  raise "No list set!" if @result.blank?
+end
+
+When /^I flip the current column$/ do
+  @sort_order.current.flip!
+end
+
+
+When /^I set the current column to: (.+)$/ do |token|
+  @sort_order.current = token
+end
+
+
+
+Then /^I should get the following list: (.+)$/ do |tokens|
+  @result.should == tokens.split(', ')
+end
+
+Then /^I should get the following string: (.+)$/ do |tokens|
+  @result.should == tokens
+end
+
+Then /^I should get the following hash$/ do |tokens|
+  @result.should == tokens.split(', ')
+end
+
+Then /^I should get the following hash: (.+)$/ do |hash|
+  @result.inspect.should == hash
+end
+

data/features/support/env.rb

@@ -0,0 +1 @@
+require File.expand_path( File.join( File.dirname(__FILE__), '..', '..', 'init' ) )

data/init.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.expand_path('lib', File.dirname(__FILE__)))
+$:.unshift(File.dirname(__FILE__))
+require 'active_support'
+require 'sort_order'

data/lib/sort_order/column/direction.rb

@@ -0,0 +1,31 @@
+module SortOrder
+  class Column
+    class Direction < String
+  
+      def self.parse(value)
+        new((value.to_s.upcase == 'DESC' || value.to_s == '0') ? 'DESC' : 'ASC')
+      end
+  
+      def label
+        "#{titleize}ending"
+      end
+  
+      def asc?
+        self == 'ASC'
+      end
+  
+      def desc?
+        !asc?
+      end
+  
+      def to_param(flip=false)
+        (flip ? desc? : asc?) ? '1' : '0'
+      end
+  
+      def to_sql(flip=false)
+        (flip ? desc? : asc?) ? 'ASC' : 'DESC'
+      end
+  
+    end
+  end
+end

data/lib/sort_order/column/field.rb

@@ -0,0 +1,19 @@
+module SortOrder
+  class Column
+    class Field < String
+  
+      def table
+        split('.').first || ''
+      end
+  
+      def name
+        split('.').last
+      end
+  
+      def label
+        name.titleize
+      end
+  
+    end
+  end
+end

data/lib/sort_order/column.rb

@@ -0,0 +1,40 @@
+module SortOrder
+  class Column
+    
+    attr_accessor :field, :direction
+  
+    def self.parse(token)
+      token.is_a?(SortOrder::Column) ? token : new(*token.to_s.split(' '))
+    end
+  
+    def initialize(field, direction=nil)
+      @field, @direction = Field.new(field), Direction.parse(direction)
+    end
+  
+    def label
+      field.label
+    end
+    
+    def name
+      field.name
+    end
+  
+    def to_sql(options = {})
+      "#{field} #{direction.to_sql(options[:flip])}"
+    end
+
+    def to_param(options = {})
+      "#{field.name} #{direction.to_param(options[:flip])}"
+    end
+  
+    def direction=(value)
+      @direction = Direction.parse(value)
+    end
+    
+    def flip!
+      self.direction = direction.to_param(true)
+    end
+    
+  end
+end
+

data/lib/sort_order/columns.rb

@@ -0,0 +1,62 @@
+module SortOrder
+  class Columns < Array
+
+    def initialize(*defaults)
+      super defaults.map { |d| Column.parse(d) }
+      raise SortOrder::NoDefaultColumnsError, "Please supply some default columns e.g. 'name', 'email desc', etc." if empty?
+    end
+
+    def to_sql(options={})
+      options.delete(:current) ? current.to_sql(options) : map {|c| c.to_sql(options) }.join(', ')
+    end
+    
+    def to_params(options={})
+      { :order => options.delete(:current) ? current.to_param(options) : map {|c| c.to_param(options) } }
+    end
+
+    def current
+      @current ||= first
+    end
+
+    def current=(token)
+      @current = merge(token)
+    end
+  
+    def current?(other)
+      current == other
+    end
+  
+    def column(token)
+      SortOrder::Column.parse(token)
+    end
+  
+    def fields
+      map(&:field)
+    end
+    
+    def <<(token)
+      merge token
+      return self
+    end
+    
+    def merge(token) 
+      new_col = column(token)
+      if old_col = find(new_col.name)
+        old_col.direction = new_col.direction
+        return old_col
+      else
+        self << new_col
+        return new_col
+      end
+    end
+
+    def find(name)
+      super() {|c| c.name == name }
+    end
+
+    def include?(name)
+      find(name).present?
+    end
+
+  end
+end

data/lib/sort_order/controller_helper.rb

@@ -0,0 +1,32 @@
+module SortOrder
+  
+  module ControllerHelper
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def default_sort_order(*args)
+        if args.any?
+          @@default_sort_order ||= {}
+          @@default_sort_order[name] = args
+          include InstanceMethods unless included_modules.include?(SortOrder::ControllerHelper::InstanceMethods)
+          helper_method :sort_order
+        end
+        @@default_sort_order[name]
+      end
+    end
+    
+    module InstanceMethods
+      
+      def sort_order
+        @sort_order ||= SortOrder.new *self.class.default_sort_order
+      end
+
+      private :sort_order
+    end
+    
+  end
+end
+
+ActionController::Base.send :include, SortOrder::ControllerHelper

data/lib/sort_order/view_helper.rb

@@ -0,0 +1,15 @@
+module SortOrder
+  module ViewHelper
+
+    def link_to_order_by(name, label=nil)
+      return "No call to default_sort_order in #{controller.controller_name} " unless respond_to?(:sort_order)
+      column = sort_order.find(name.to_s)
+      column = sort_order.current if sort_order.current?(column)
+      label ||= column.label
+      link_to label, {:order => column.to_param(:flip => true)}
+    end
+
+  end
+end
+
+ActionView::Base.send :include, SortOrder::ViewHelper

data/lib/sort_order.rb

@@ -0,0 +1,17 @@
+module SortOrder
+  VERSION = '0.1.1'
+  
+  def self.new *cols
+    Columns.new *cols
+  end
+  
+  class NoDefaultColumnsError < StandardError; end
+
+end
+
+require 'sort_order/column'
+require 'sort_order/columns'
+require 'sort_order/column/field'
+require 'sort_order/column/direction'
+require 'sort_order/view_helper' if defined?(ActionView::Base)
+require 'sort_order/controller_helper' if defined?(ActionController::Base)

data/rails/init.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/../init')

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: sort_order
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Alex Neill
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-21 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Manipulate column sort orders...
+email: alex@rawnet.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- features/sort_order.feature
+- features/step_definitions/sort_order_steps.rb
+- features/support/env.rb
+- init.rb
+- lib/sort_order.rb
+- lib/sort_order/column.rb
+- lib/sort_order/column/direction.rb
+- lib/sort_order/column/field.rb
+- lib/sort_order/columns.rb
+- lib/sort_order/controller_helper.rb
+- lib/sort_order/view_helper.rb
+- rails/init.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: sort_order
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: Manipulate column sort orders.
+test_files: []
+