sortable_table 0.1.0

data/README

@@ -0,0 +1,7 @@
+Sortable
+========
+
+See my blog posting on sortable here: http://javathehutt.blogspot.com/2009/06/mo-simple-sortable-tables-in-rails.html
+
+For more usage information see sortable.rb and sortable_helper.rb. Also see the example app in the example dir as
+well as the tests that go along with it.

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the sortable plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the sortable plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Sortable'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "sortable_table"
+    gemspec.summary = "Rails plugin to produce a sortable, paginated, searchable table for any model"
+    gemspec.description = "Rails plugin to produce a sortable, paginated, searchable table for any model"
+    gemspec.email = ""
+    gemspec.homepage = "http://github.com/kovacs/sortable"
+    gemspec.authors = ["Michael Kovacs"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/example/controllers/cablecar/users_controller.rb

@@ -0,0 +1,49 @@
+module Cablecar
+  class UsersController < ActionController::Base
+
+    # By default this will create an index action that uses the default sortable table partial to render the list of objects
+    sortable_table Cablecar::User
+
+    # The following index action demonstrates various ways that you can fetch and display your objects in a paginated, sortable,
+    # searchable table. Each clause in the elsif chain below could be its own index action on its own but all are included here
+    # for demo and testing purposes. Each example is triggered by passing the appropriate param value to trigger the desired
+    # clause to demo.
+    def index
+      if params[:filter_example]
+        # This demonstrates the ability to add additional conditions to fetching the list of objects. This will filter
+        # the results to the list of active users
+        if params[:active]
+          conditions = 'cablecar_users.status = "active"'
+        end
+        get_sorted_objects(params, :conditions => conditions)      
+      elsif params[:complex_example]
+        # This example demonstrates a more complicated example that displays the flexibility of creating the sortable table.
+        # Here we are showing an attribute on a related object as a sortable column in the table, namely the contact_info name
+        # column. We're also restricting the visible columns to 3 columns as well as defining the sort order for each column
+        # as well as the default sort column. We're also specifying what columns should be used when a search is performed.
+        # Finally we're also setting the number of results to show per page.
+        get_sorted_objects(params, :include_relations => [:contact_info],
+                                   :table_headings => [['Username', 'username'], ['Status', 'status'], ['Name', 'name']],
+                                   :sort_map => {:username => [['cablecar_users.username', 'DESC'], 
+                                                               ['cablecar_users.status', 'DESC']], 
+                                                 :status => ['cablecar_users.status', 'ASC'],
+                                                 :name => ['cablecar_contact_infos.name', 'DESC']},
+                                   :default_sort => ['name', 'ASC'],
+                                   :search_array => ['cablecar_users.username', 'cablecar_contact_infos.name'],
+                                   :per_page => 15)      
+      elsif params[:no_pagination]
+        @hide_pagination = true
+        get_sorted_objects(params)      
+      else
+        if params[:use_default]
+          super
+        else
+          # If you wish to override how the objects are fetched this is the simplest way to do so
+          # The key is that you simply need to call get_sorted_objects with your params and any optional overrides for 
+          # sortable defaults. See sortable.rb for more details on overrides.
+          get_sorted_objects(params)      
+        end
+      end
+    end
+  end
+end

data/example/models/cablecar/contact_info.rb

@@ -0,0 +1,9 @@
+class Cablecar::ContactInfo < ActiveRecord::Base
+  set_table_name 'cablecar_contact_infos'
+  has_one :user, :class_name => Cablecar::User.to_s
+end
+
+# to solve circular dependency
+Cablecar::User.class_eval do
+  belongs_to :contact_info, :class_name => Cablecar::ContactInfo.to_s  
+end

data/example/models/cablecar/user.rb

@@ -0,0 +1,7 @@
+class Cablecar::User < ActiveRecord::Base
+  set_table_name 'cablecar_users'
+
+  def name
+    self.contact_info.name
+  end
+end

data/example/views/cablecar/users/index.html.erb

@@ -0,0 +1 @@
+<%= sortable_table :paginate => !@hide_pagination%>

data/init.rb

@@ -0,0 +1,33 @@
+require 'sortable'
+ActionController::Base.send(:include, Sortable)
+
+VIEW_PATH = File.join(RAILS_ROOT, 'vendor', 'plugins', 'sortable', 'views')
+ActionController::Base.append_view_path(VIEW_PATH) unless ActionController::Base.view_paths.include?(VIEW_PATH)
+
+require 'sortable_helper'
+ActionView::Base.send(:include, SortableHelper)
+
+if RAILS_ENV == 'test'
+  # only load the example files/routes in development mode
+  # TODO easy way to load all controller/model paths instead? Don't know off the top of my head but am sure it's easy
+  require File.join(File.dirname(__FILE__), 'example', 'controllers', 'cablecar', 'users_controller')
+  require File.join(File.dirname(__FILE__), 'example', 'models', 'cablecar', 'user')
+  require File.join(File.dirname(__FILE__), 'example', 'models', 'cablecar', 'contact_info')
+
+  # install the routes
+  require File.join(File.dirname(__FILE__), 'test', 'example_test_routing')
+  
+  # install the example app view path
+  VIEW_PATH = File.join(RAILS_ROOT, 'vendor', 'plugins', 'sortable', 'example', 'views')
+  ActionController::Base.append_view_path(VIEW_PATH) unless ActionController::Base.view_paths.include?(VIEW_PATH)
+end
+
+COPY_IMAGES = true
+
+if COPY_IMAGES
+  require "ftools"
+
+  File.copy(File.join(File.dirname(__FILE__), 'images', 'logo_opaque.png'), File.join(RAILS_ROOT, 'public', 'images'))
+  File.copy(File.join(File.dirname(__FILE__), 'images', 'arrow_up.gif'), File.join(RAILS_ROOT, 'public', 'images'))
+  File.copy(File.join(File.dirname(__FILE__), 'images', 'arrow_down.gif'), File.join(RAILS_ROOT, 'public', 'images'))
+end

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/sortable.rb

@@ -0,0 +1,299 @@
+require 'generator'
+
+module Sortable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Class method to setup a controller to create a sortable table. 
+      #
+      # usage: sortable_table class_to_tabularize, optional_params
+      # 
+      # simplest example possible: 
+      # 
+      # In your controller...
+      # 
+      # sortable_table User
+      # 
+      # This will create a sortable table over all your objects and display all columns.
+      # The simplest way to trim down the columns to display is to pass in a parameter specifying which columns
+      # on your object you'd like to display:
+      #
+      # sortable_table User, :display_columns => ['id', 'email', 'name', 'state', 'created_at']
+      #
+      # This will show the same sortable, searchable, paginated table with only these columns
+      # 
+      # If you need a bit more control over how the objects are fetchd and displayed this is
+      # the next simplest example:
+      #
+      # Override the index action in your controller:
+      #
+      # def index
+      #  get_sorted_objects(params)        
+      # end
+      # 
+      # In your index action template (within the same controller) put in a helper call to show a sortable table. You can
+      # create your own table partial to be used to display the objects. See the sortable/views/sortable/_table.html.erb 
+      # (which is the default template used by the plugin) for an example. 
+      # 
+      # <%= sortable_table %>
+      # 
+      # The view method will automatically generate a paginated, sortable table for the class type declared in the controller
+      # 
+      # optional_params:
+      # 
+      # :per_page - Number of records to show per page. Default is 10
+      #
+      # The next section deals with how to change what's displayed in the table. The first and simplest option is :display_columns.
+      # The more flexible option is to use :table_headings and :sort_map. First we'll go over the simpler option.
+      #
+      # :display_columns - Specifies which columns that you'd like to display in the table. 
+      #
+      # For more flexibility you can use :table_headings and :sort_map. You would most likely use this when you want to display 
+      # attributes from more than one object in the same table or if you need more flexibility with regards to sort rules. 
+      # :table_headings - The table heading label and sort key. Default is all the column names for the given class
+      # :sort_map - The mapping between the sort key and the table.column to sort on. Default is all the columns for the given class
+      # :include_relations - Relations to include if you choose to display a column in a related object's table
+      #
+      # :default_sort - The default sorting column and direction when displaying the table without any sort params. Default is 'id DESC'
+      # 
+      # Note: You *must* override both :table_headings and :sort_map if you do choose to override so that 
+      # the contents of the column headings match up with the contents of the sort_map they associate with.
+      # Also if you override :default_sort you'll need to change the :table_headings and :sort_map if the new :default_sort
+      # column doesn't currently reside within the :table_heading and :sort_map collections
+      # 
+      # Example of modifying :table_headings or :sort_map :
+      #   :table_headings => [['Name', 'name'], ['Status', 'status']]
+      #   :sort_map =>  {'name' => ['users.name'], 
+      #                  'status' => ['users.status']}
+      # 
+      #   Note that both 'name' and 'status' are sort keys that map to both the table heading label and the 
+      #   database table.column combination that the heading refers to. 
+      #   
+      #   Also note that :default_sort now needs to change as well since the table no longer contains the :default_sort
+      #   column of 'id':
+      #   
+      #   :default_sort => ['name', 'DESC'] 
+      #   
+      # Example of modifying :table_headings to include a column from a related object:
+      #   :table_headings => [['Name', 'name'], ['Status', 'status'], ['Role', 'role']]
+      #   :sort_map =>  {'name' => ['users.name'], 
+      #                  'status' => ['users.status'],
+      #                  'role' => ['roles.role']}
+      #   
+      #   Note that we've now added 'roles.role' to the list of columns to display and sort on. In order to
+      #   make the find work properly we also need to include the related object, so we pass in the following param:
+      #   :include_relations => [:role]
+      #   
+      #   Perhaps we want to sort by role ascending by default as well. We'd pass the param value:
+      #   :default_sort => ['role', 'ASC']               
+      #   
+      #   and the table is now sortable by a related object's column and is the default sort value for the table.
+      #
+      # Search. You can specify what columns are searchable on your objects as follows:
+      #   :search_array => ['cablecar_users.username', 'cablecar_users.name']
+      # 
+      # Now search queries will only search username and name for users. By default search is enabled for all columns
+      # that are being displayed in the table. This allows you to expand or constrain those values.
+      #
+      def sortable_table(klass, options={})
+        @@sortable_table_options ||={}
+
+        sort_map = HashWithIndifferentAccess.new
+
+        if options[:table_headings] &&
+           options[:sort_map]
+           table_headings = options[:table_headings]
+           sort_map.merge!(options[:sort_map])           
+        else
+          display_columns = options[:display_columns].blank? ? klass.column_names : options[:display_columns]
+          table_headings = []
+          klass.column_names.each do |att|
+            if display_columns.include?(att)
+              table_headings << [att.humanize, att]
+              sort_map[att] = ["#{klass.table_name}.#{att}", 'DESC']
+            end
+          end           
+        end
+
+        default_sort = options[:default_sort].nil? ? ['id', 'DESC'] : options[:default_sort]
+        per_page = options[:per_page].nil? ? 10 : options[:per_page]
+        include_relations = options[:include_relations].nil? ? [] : options[:include_relations]        
+
+        search_array = options[:search_array].nil? ? sort_map.values.collect {|v| v[0]} : options[:search_array]
+
+        @@sortable_table_options[controller_name] = {:class => klass,
+                                                     :table_headings => table_headings,
+                                                     :default_sort => default_sort,
+                                                     :sort_map => sort_map,
+                                                     :search_array => search_array,
+                                                     :per_page => per_page,
+                                                     :include_relations => include_relations}
+        
+        module_eval do
+          include Sortable::InstanceMethods
+          def sortable_class
+            @@sortable_table_options[controller_name][:class]
+          end
+
+          def sortable_table_headings
+            @@sortable_table_options[controller_name][:table_headings]
+          end
+          
+          def sortable_default_sort
+            @@sortable_table_options[controller_name][:default_sort]
+          end
+          
+          def sortable_sort_map
+            @@sortable_table_options[controller_name][:sort_map]
+          end
+          
+          def sortable_search_array
+            @@sortable_table_options[controller_name][:search_array]
+          end
+          
+          def sortable_per_page
+            @@sortable_table_options[controller_name][:per_page]
+          end
+          
+          def sortable_include_relations
+            @@sortable_table_options[controller_name][:include_relations]
+          end
+        end
+    end
+      
+    end
+    
+    module InstanceMethods      
+      # default impl for listing a collection of objects. Override this action in your controller to fetch objects
+      # differently and/or to render a different template.
+      def index
+        get_sorted_objects(params)  
+        render :template => 'sortable/index'
+      end
+      
+      # Users can also pass in optional conditions that are used by the finder method call. For example if only wanted to
+      # show the items that had a certain status value you could pass in a condition 'mytable.status == 300' for example
+      # as the conditions parameter and when the finder is called the sortable table will only display objects that meet those
+      # conditions. Additionally you can paginate and sort the objects that are returned and apply the conditions to them.
+      def get_sorted_objects(params, options={})                           
+        objects = options[:objects].nil? ? sortable_class : options[:objects]
+        include_rel = options[:include_relations].nil? ? sortable_include_relations : options[:include_relations]
+        @headings = options[:table_headings].nil? ? sortable_table_headings : options[:table_headings]
+        sort_map = options[:sort_map].nil? ? sortable_sort_map : HashWithIndifferentAccess.new(options[:sort_map])
+        default_sort = options[:default_sort].nil? ? sortable_default_sort : options[:default_sort]
+        conditions = options[:conditions].nil? ? '' : options[:conditions]
+        search_array = options[:search_array].nil? ? sortable_search_array : options[:search_array]
+        
+        conditions = process_search(params, conditions, search_array)
+        items_per_page = options[:per_page].nil? ? sortable_per_page : options[:per_page]
+       
+        @sort_map = sort_map
+        sort = process_sort(params, sort_map, default_sort)
+        page = params[:page]
+        page ||= 1
+        # fetch the objects, paginated and sorted as desired along with any extra filtering conditions
+        get_paginated_objects(objects, sort, include_rel, conditions, page, items_per_page)
+      end
+      
+      private
+      def get_paginated_objects(objects, sort, include_rel, conditions, page, items_per_page)
+        @objects = objects.paginate(:include => include_rel, 
+                                 :order => sort, 
+                                 :conditions => conditions,
+                                 :page => page,
+                                 :per_page => items_per_page)
+      end
+
+      def process_search(params, conditions, search_array)
+        if !params[:q].blank?
+          columns_to_search = ''
+          values = Array.new        
+          g = Generator.new(search_array)
+          g.each do |col|
+           columns_to_search += col + ' LIKE ? '
+           columns_to_search += 'OR ' unless g.end?
+           values<< "%#{params[:q]}%"
+          end
+          conditions += ' and' if !conditions.blank?
+          conditions = [conditions + ' (' + columns_to_search + ')'] + values
+        end
+        return conditions
+      end
+
+      def value_provided?(params, name)
+        !params[name].nil? && !params[name].empty?
+      end
+
+      def process_sort(params, sort_map, default_sort)
+        if params['sort']
+          sort = process_sort_param(params['sort'], sort_map)  
+        else
+          # fetch the table.column from the sortmap for the given sort key and append the sort direction
+          sort = sort_map[default_sort[0]][0] + ' ' + default_sort[1]            
+          
+          # These variables are used in the sort_link_helper and sort_td_class_helper to build the column link headings
+          # and create the proper CSS class for the column heading for the case where there is no sort param.
+          @default_sort = default_sort[0]
+          if default_sort[1] && default_sort[1] == 'DESC'
+            @default_sort_key = default_sort[0] + '_reverse'
+            @sortclass = 'sortup'       
+          else
+            @default_sort_key = default_sort[0]             
+            @sortclass = 'sortdown'
+          end
+        end      
+        return sort    
+      end
+
+      def process_sort_param(sort, sort_map)
+        mapKey = get_sort_key(sort)
+        
+        if sort_map[mapKey].nil? 
+          raise Exception.new("Invalid sort parameter passed #{sort}")
+        end
+        
+        result = ''
+        sort_array = sort_map[mapKey]
+        # this adds support for more than one sort criteria for a given column
+        # for example, status DESC, created_at ASC
+        if sort_array[0].class == Array
+          g = Generator.new(sort_array)
+          g.each do |sort_value|
+            result = get_sort_direction(sort, sort_value)
+            result += ', ' unless g.end?
+          end
+        else
+          result = get_sort_direction(sort, sort_array)
+        end
+        
+        return result
+      end
+      
+      def get_sort_direction(sort, sort_value)
+        result = ''
+        column = sort_value[0]
+        direction = sort_value[1]
+        if /_reverse$/.match(sort)
+          if direction == 'DESC'
+            direction = 'ASC'
+          else
+            direction = 'DESC'
+          end
+        end
+        result += column + ' ' + direction        
+      end
+      
+      def get_sort_key(sort)
+        i = sort.index('_reverse')
+        if i
+          mapKey = sort[0, i]
+        else
+          mapKey = sort
+        end
+        return mapKey
+      end
+    end
+    
+end

data/lib/sortable_helper.rb

@@ -0,0 +1,81 @@
+module SortableHelper
+  # Helper method to generate a sortable table in the view
+  # 
+  # usage: <%= sortable_table(optional_params) %>
+  # 
+  # optional_params:
+  # 
+  # :paginate - Whether or not to display pagination links for the table. Default is true.
+  # :partial - Name of the partial containing the table to display. Default is the table partial in the sortable
+  #            plugin: 'sortable/table'
+  #            
+  #            If you choose to create your own partial in place of the one distributed with the sortable plugin 
+  #            your partial has the following available to it for generating the table:
+  #              @headings contains the table heading values
+  #              @objects contains the collection of objects to be displayed in the table
+  #              
+  # :search - Whether or not to include a search field for the table. Default is true.
+  #
+  def sortable_table(options={})
+    paginate = options[:paginate].nil? ? true : options[:paginate]
+    partial = options[:partial].nil? ? 'sortable/table' : options[:partial]  
+    search = options[:search].nil? ? true : options[:search]
+
+    result = render(:partial => partial, :locals => {:search => search})
+    result += will_paginate(@objects).to_s if paginate
+    result
+  end
+ 
+    
+  def sort_td_class_helper(param)
+    result = 'sortup' if params[:sort] == param
+    result = 'sortdown' if params[:sort] == param + "_reverse"
+    result = @sortclass if @default_sort && @default_sort == param    
+    return result
+  end
+
+
+  def sort_link_helper(action, text, param, params, extra_params={})
+    options = build_url_params(action, param, params, extra_params)
+    html_options = {:title => "Sort by this field"}        
+    
+    link_to(text, options, html_options)
+  end
+
+  def build_url_params(action, param, params, extra_params={})
+    key = param
+    if @default_sort_key && @default_sort == param
+      key = @default_sort_key
+    else
+      key += "_reverse" if params[:sort] == param
+    end
+    params = {:sort => key, 
+      :page => nil, # when sorting we start over on page 1
+      :q => params[:q]}
+    params.merge!(extra_params)
+
+    return {:action => action, :params => params}
+  end
+
+   def row_cell_link(new_location)
+     mouseover_pointer + "onclick='window.location=\"#{new_location}\"'"
+   end
+
+   def mouseover_pointer
+     "onmouseover='this.style.cursor = \"pointer\"' onmouseout='this.style.cursor=\"auto\"'"
+   end
+
+   def table_header
+     result = "<tr class='tableHeaderRow'>"
+     	 @headings.each do |heading|
+         sort_class = sort_td_class_helper heading[1]
+      	 result += "<td"
+   		   result += " class='#{sort_class}'" if !sort_class.blank? 
+   		   result += ">"
+   		   result += sort_link_helper @action, heading[0], heading[1], params
+   		   result += "</td>"
+   		end   
+   		result += "</tr>"
+   		return result
+   end
+end

data/sortable_table.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sortable_table}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Kovacs"]
+  s.date = %q{2010-01-12}
+  s.description = %q{Rails plugin to produce a sortable, paginated, searchable table for any model}
+  s.email = %q{}
+  s.extra_rdoc_files = [
+    "README",
+     "TODO"
+  ]
+  s.files = [
+    "README",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "example/controllers/cablecar/users_controller.rb",
+     "example/models/cablecar/contact_info.rb",
+     "example/models/cablecar/user.rb",
+     "example/views/cablecar/users/index.html.erb",
+     "images/arrow_down.gif",
+     "images/arrow_up.gif",
+     "images/logo_opaque.png",
+     "init.rb",
+     "install.rb",
+     "lib/sortable.rb",
+     "lib/sortable_helper.rb",
+     "sortable_table.gemspec",
+     "test/example_test_routing.rb",
+     "test/test_helper.rb",
+     "test/users_controller_test.rb",
+     "views/sortable/_table.html.erb",
+     "views/sortable/index.erb"
+  ]
+  s.homepage = %q{http://github.com/kovacs/sortable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Rails plugin to produce a sortable, paginated, searchable table for any model}
+  s.test_files = [
+    "test/example_test_routing.rb",
+     "test/test_helper.rb",
+     "test/users_controller_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/example_test_routing.rb

@@ -0,0 +1,16 @@
+module ActionController
+  module Routing
+    class RouteSet
+      def draw
+        clear!
+        map = Mapper.new(self)
+        map.namespace :cablecar do |strong|
+          strong.resources 'users'
+        end
+        
+        yield map
+        install_helpers                         
+      end      
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+ENV["RAILS_ENV"] = 'test'
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+
+require 'test/unit'
+require 'test_help'
+
+class Test::Unit::TestCase
+
+  self.fixture_path = File.expand_path( File.join(File.dirname(__FILE__), 'fixtures') )
+
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+
+end

data/test/users_controller_test.rb

@@ -0,0 +1,346 @@
+require File.dirname(__FILE__) + '/test_helper'
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+def setup_sortable_db
+  old_stdout = $stdout
+  
+  # AR keeps printing annoying schema statements
+  $stdout = StringIO.new
+
+  ActiveRecord::Base.logger
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :cablecar_users do |t|
+      t.column :username, :string
+      t.column :status, :string
+      t.column :contact_info_id, :integer
+    end
+
+    create_table :cablecar_contact_infos do |t|
+      t.column :name, :string
+      t.column :phone, :string
+    end
+  end
+  
+  $stdout = old_stdout
+end
+
+setup_sortable_db
+
+require File.dirname(__FILE__) + '/../example/controllers/cablecar/users_controller'
+
+# Re-raise errors caught by the controller.
+class Cablecar::UsersController
+  def rescue_action(e) raise e end
+end
+
+
+class UsersControllerTest < Test::Unit::TestCase
+
+  def teardown_db
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+  end
+
+  #fixtures :widgets
+
+  def setup
+    @controller = Cablecar::UsersController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    
+    30.times do |n|
+      c = Cablecar::ContactInfo.new(:name => "name#{n}")
+      c.user = Cablecar::User.new(:username => "user#{n}")
+      c.save!
+    end
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_should_show_paginated_table_using_default_action
+    get :index, :use_default => true
+    assert_equal 10, assigns(:objects).size    
+
+    verify_sortable_table_html
+    verify_pagination_html
+  end
+
+  def test_should_show_paginated_table
+    get :index
+    assert_equal 10, assigns(:objects).size    
+
+    verify_sortable_table_html
+    verify_pagination_html
+  end
+  
+  def test_should_show_sorable_table_without_pagination
+    get :index, :no_pagination => true
+    assert_equal 10, assigns(:objects).size    
+
+    verify_sortable_table_html
+    assert_select 'div.pagination', false
+  end
+
+  def test_should_show_paginated_table_with_overrides_and_related_columns
+    get :index, :complex_example => true
+    assert_equal 15, assigns(:objects).size    
+    assert_select 'thead' do
+      assert_select 'tr' do
+        assert_select 'td', :count => 3
+        assert_select 'td.sortdown', 'Name'
+        assert_select 'td.sortdown' do 
+          assert_select 'a[href=/cablecar/users?sort=name]', 'Name'
+          assert_select 'a[title=Sort by this field]', 'Name'
+        end
+      end
+    end
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 15
+      verify_name_user_row_data(11, 22)
+    end    
+    verify_pagination_html(2)
+  end
+
+  def test_should_sortdown_up_by_related_field
+    get :index, :sort => 'name', :complex_example => true
+    assert_equal 15, assigns(:objects).size    
+    assert_select 'thead' do
+      assert_select 'tr' do
+        assert_select 'td', :count => 3
+        assert_select 'td.sortup', 'Name'
+        assert_select 'td.sortup' do 
+          assert_select 'a[href=/cablecar/users?sort=name_reverse]', 'Name'
+          assert_select 'a[title=Sort by this field]', 'Name'
+        end
+      end
+    end
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 15
+      verify_name_user_row_data(4, 10)
+      verify_name_user_row_data(23, 30)
+    end    
+    verify_pagination_html(2)
+  end
+
+  def test_should_sortup_up_by_field_with_desc_default_sort
+    get :index, :sort => 'name_reverse', :complex_example => true
+    assert_equal 15, assigns(:objects).size    
+    assert_select 'thead' do
+      assert_select 'tr' do
+        assert_select 'td', :count => 3
+        assert_select 'td.sortdown', 'Name'
+        assert_select 'td.sortdown' do 
+          assert_select 'a[href=/cablecar/users?sort=name]', 'Name'
+          assert_select 'a[title=Sort by this field]', 'Name'
+        end
+      end
+    end
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 15
+      verify_name_user_row_data(11, 22)
+    end    
+    verify_pagination_html(2)
+  end
+
+  def test_should_sortup_up_by_field_with_asc_default_sort
+    get :index, :sort => 'status_reverse', :complex_example => true
+    assert_equal 15, assigns(:objects).size    
+    assert_select 'thead' do
+      assert_select 'tr' do
+        assert_select 'td', :count => 3
+        assert_select 'td.sortdown', 'Status'
+        assert_select 'td.sortdown' do 
+          assert_select 'a[href=/cablecar/users?sort=status]', 'Status'
+          assert_select 'a[title=Sort by this field]', 'Status'
+        end
+      end
+    end
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 15
+      verify_name_user_row_data(1, 15)
+    end    
+    verify_pagination_html(2)
+  end
+
+  def test_should_sortup_up_by_field_with_more_than_one_sort_param
+    get :index, :sort => 'username_reverse', :complex_example => true
+    assert_equal 15, assigns(:objects).size    
+    assert_select 'thead' do
+      assert_select 'tr' do
+        assert_select 'td', :count => 3
+        assert_select 'td.sortdown', 'Username'
+        assert_select 'td.sortdown' do 
+          assert_select 'a[href=/cablecar/users?sort=username]', 'Username'
+          assert_select 'a[title=Sort by this field]', 'Username'
+        end
+      end
+    end
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 15
+      verify_name_user_row_data(1, 15)
+    end    
+    verify_pagination_html(2)
+  end
+
+  def test_should_fail_to_sort_with_invalid_sort_param
+    assert_raise Exception do |ex|
+      get :index, :sort => 'username_invalid', :complex_example => true
+    end
+  end
+  
+  def test_should_override_class_defaults
+    Cablecar::UsersController.class_eval do
+      sortable_table Cablecar::User, {:include_relations => [:contact_info],
+                               :table_headings => [['Username', 'username'], ['Status', 'status'], ['Name', 'name']],
+                               :sort_map => {:username => [['cablecar_users.username', 'DESC'], ['cablecar_users.status', 'DESC']], 
+                                             :status => ['cablecar_users.status', 'ASC'],
+                                             :name => ['cablecar_contact_infos.name', 'DESC']},
+                               :default_sort => ['name', 'ASC'],
+                               :per_page => 15}
+    end  
+    get :index, :sort => 'name_reverse'
+    assert_equal 15, assigns(:objects).size    
+    assert_select 'thead' do
+      assert_select 'tr' do
+        assert_select 'td', :count => 3
+        assert_select 'td.sortdown', 'Name'
+        assert_select 'td.sortdown' do 
+          assert_select 'a[href=/cablecar/users?sort=name]', 'Name'
+          assert_select 'a[title=Sort by this field]', 'Name'
+        end
+      end
+    end
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 15
+      verify_name_user_row_data(11, 22)
+    end    
+    verify_pagination_html(2)
+
+    Cablecar::UsersController.class_eval do
+      sortable_table Cablecar::User # put things back where you found them
+    end
+  end
+  
+  def verify_name_user_row_data(start, finish)
+    start.upto(finish) do |n|
+      assert_select "tr#cablecar_user_#{n}" do
+        assert_select 'td', :count => 3
+        assert_select 'td', {:minimum => 1}, "name#{n}" # test that the name value is there
+        assert_select 'td', {:minimum => 1}, "user#{n}"
+      end      
+    end
+  end
+  
+  def verify_sortable_table_html(count=10)
+    verify_sortable_table_header
+    assert_select 'tbody' do
+      assert_select 'tr', :count => count
+      30.downto(21) do |n|
+        assert_select "tr#cablecar_user_#{n}" do
+          assert_select 'td', :count => 4
+          assert_select 'td', {:minimum => 1}, n # test that the id value is there
+        end
+      end
+    end    
+  end
+  
+  def verify_sortable_table_header(href='/cablecar/users?sort=id_reverse')
+    assert_select 'thead' do
+      assert_select 'tr' do
+        assert_select 'td', :count => 4
+        assert_select 'td.sortup', 'Id'
+        assert_select 'td.sortup' do 
+          assert_select "a[href=#{href}]", 'Id'
+          assert_select 'a[title=Sort by this field]', 'Id'
+        end
+      end
+    end    
+  end
+  
+  def verify_pagination_html(pages=3)
+    assert_select 'div.pagination' do 
+      assert_select 'span', :count => 2
+      assert_select 'a', :count => pages
+    end    
+  end
+
+  def test_truth
+    true
+  end
+  
+  def test_should_search
+    get :index, :q => 'user3'
+    assert_equal 1, assigns(:objects).size    
+
+    verify_sortable_table_header('/cablecar/users?q=user3&amp;sort=id_reverse')
+    
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 1
+        assert_select "tr#cablecar_user_4" do
+          assert_select 'td', :count => 4
+          assert_select 'td', {:minimum => 1}, 4 # test that the id value is there
+        end
+    end    
+  end
+
+  def test_should_search_and_return_multiple_results
+    get :index, :q => 'user4'
+    assert_equal 2, assigns(:objects).size    
+
+    verify_sortable_table_header('/cablecar/users?q=user4&amp;sort=id_reverse')
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 2
+        assert_select "tr#cablecar_user_5" do
+          assert_select 'td', :count => 4
+          assert_select 'td', {:minimum => 1}, 4 # test that the id value is there
+        end
+    end    
+
+  end
+      
+  def create_a_dupe_user
+    c = Cablecar::ContactInfo.new(:name => "dupe_name4")
+    c.user = Cablecar::User.new(:username => "dupe_user4")
+    c.user.status = 'active'
+    c.save!    
+  end
+  
+  def test_should_search_and_filter_results
+    create_a_dupe_user
+    # This tests the ability to search as well as apply an additional filter that is used in conjunction with the
+    # search conditions
+    get :index, :q => 'user4', :active => 'true', :filter_example => true
+    assert_equal 1, assigns(:objects).size    
+
+    verify_sortable_table_header('/cablecar/users?q=user4&amp;sort=id_reverse')
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 1
+        assert_select "tr#cablecar_user_31" do
+          assert_select 'td', :count => 4
+          assert_select 'td', {:minimum => 1}, 4 # test that the id value is there
+        end
+    end    
+    
+  end
+  
+  def test_should_search_and_return_multiple_results
+    create_a_dupe_user
+
+    get :index, :q => 'user4'
+    assert_equal 2, assigns(:objects).size    
+
+    verify_sortable_table_header('/cablecar/users?q=user4&amp;sort=id_reverse')
+    assert_select 'tbody' do
+      assert_select 'tr', :count => 2
+        assert_select "tr#cablecar_user_5" do
+          assert_select 'td', :count => 4
+          assert_select 'td', {:minimum => 1}, 4 # test that the id value is there
+        end
+    end    
+
+  end
+  
+end

data/views/sortable/_table.html.erb

@@ -0,0 +1,74 @@
+<style>
+.sortableTable {
+  border: 1px solid #999;
+  background-image:url(../images/logo_opaque.png);	
+	background-position: center;
+	background-repeat:no-repeat;	
+}
+
+.sortableTable td {
+	font-size: .95em;
+	padding: 3px 6px;
+	color: #101010;
+	border-bottom: 1px solid #999;
+}
+
+.sortableTable tr.tableHeaderRow td {
+	color: #830519;	
+  background: #c7e1f0;
+	border-top: 1px solid #830519;
+	border-bottom: 1px solid #830519;
+	font-weight: bold;
+}
+
+.sortableTable tr.tableHeaderRow td.sortup {
+	background-color: #faf1ed;
+  background-image:url(../images/arrow_down.gif); 
+	background-position: top right;
+	background-repeat:no-repeat;
+	
+}
+
+.sortableTable tr.tableHeaderRow td.sortdown {
+	background-color: #faf1ed;
+  background-image:url(../images/arrow_up.gif); 
+	background-position: top right;
+	background-repeat:no-repeat;
+}
+
+#search {
+  padding: 10px;
+}
+</style>
+
+<% if search %>
+  <div id='search'>
+  <% form_tag({:action => @action}, {:method => 'get', :id => 'search_form'}) do %>
+    <%=text_field_tag("q", params['q'], :size => 10 ) %> 
+    <%=submit_tag 'Search'%>
+  <% end %>
+  </div>
+<% end %>
+
+<table width="100%" class='sortableTable' cellpadding="0" cellspacing="0">
+  <thead>
+    <%= table_header %>
+  </thead>
+  <tbody>
+	<%if @objects.size == 0%>
+  	  <tr><td colspan='<%= @headings.size %>'>No items in the list</td></tr>
+	<%else  
+	    @objects.each do |object|
+	        klass = cycle('odd', 'even')        
+        %>
+	    <tr id='<%=dom_id(object)%>' class='<%= klass %>'>
+         <% @headings.each do |heading| %>
+             <td>
+               <%= object.instance_eval(heading[1]) %>
+             </td>
+         <% end %>
+  		</tr>
+	<%  end
+	 end%>
+	</tbody>
+</table>

data/views/sortable/index.erb

@@ -0,0 +1 @@
+<%= sortable_table %>

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: sortable_table
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Michael Kovacs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-12 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Rails plugin to produce a sortable, paginated, searchable table for any model
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- TODO
+files: 
+- README
+- Rakefile
+- TODO
+- VERSION
+- example/controllers/cablecar/users_controller.rb
+- example/models/cablecar/contact_info.rb
+- example/models/cablecar/user.rb
+- example/views/cablecar/users/index.html.erb
+- images/arrow_down.gif
+- images/arrow_up.gif
+- images/logo_opaque.png
+- init.rb
+- install.rb
+- lib/sortable.rb
+- lib/sortable_helper.rb
+- sortable_table.gemspec
+- test/example_test_routing.rb
+- test/test_helper.rb
+- test/users_controller_test.rb
+- views/sortable/_table.html.erb
+- views/sortable/index.erb
+has_rdoc: true
+homepage: http://github.com/kovacs/sortable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Rails plugin to produce a sortable, paginated, searchable table for any model
+test_files: 
+- test/example_test_routing.rb
+- test/test_helper.rb
+- test/users_controller_test.rb