sorting_table_for 0.2.0 → 0.2.1

data/lib/sorting_table_for/table_builder.rb

@@ -6,8 +6,7 @@ module SortingTableFor
   
   class TableBuilder
     
-    include ::ActionView::Helpers::TagHelper
-    include ::ActionView::Helpers::NumberHelper
+    include ::ActionView::Helpers
     
     class_inheritable_accessor :reserved_columns, :currency_columns,
                                :default_boolean, :show_total_entries,
@@ -31,7 +30,7 @@ module SortingTableFor
     def initialize(collection, object_or_array, template, options, params)
       @collection, @@object_or_array, @@template, @@options, @@params = collection, object_or_array, template, options, params
       set_default_global_options
-      I18n.set_options(params, model_name(@collection.first), object_or_array.first, @@options[:i18n])
+      I18n.set_options(params, model_name(@collection.first), @@options[:i18n])
       @lines = []
     end
     
@@ -135,7 +134,7 @@ module SortingTableFor
       column_options, html_options = get_column_and_html_options( args.extract_options! )
       if block_given?
         @header_line = FormatLine.new(args, column_options, html_options, nil, :thead)
-        @@template.capture(&block)
+        capture(&block)
       else
         @header_line = FormatLine.new(args, column_options, html_options, @collection.first, :thead)
       end
@@ -184,7 +183,7 @@ module SortingTableFor
     #
     def header(*args, &block)
       if block_given?
-        block = @@template.capture(&block)
+        block = capture(&block)
         @header_line.add_cell(@collection.first, args, nil, block)
       else
         @header_line.add_cell(@collection.first, args)
@@ -392,7 +391,7 @@ module SortingTableFor
     #    
     def column(*args, &block)
       if block_given?
-        block = @@template.capture(&block)
+        block = capture(&block)
         @lines.last.add_cell(@current_object, args, nil, block)
       else
         @lines.last.add_cell(@current_object, args)
@@ -451,7 +450,7 @@ module SortingTableFor
       column_options, html_options = get_column_and_html_options( args.extract_options! )
       if block_given?
         @footer_line = FormatLine.new(args, column_options, html_options, nil, :tfoot)
-        @@template.capture(&block)
+        capture(&block)
       else
         @footer_line = FormatLine.new(args, column_options, html_options, @collection.first, :tfoot) if !args.empty?
       end
@@ -506,7 +505,7 @@ module SortingTableFor
     #
     def footer(*args, &block)
       if block_given?
-        block = @@template.capture(&block)
+        block = capture(&block)
         @footer_line.add_cell(@collection.first, args, nil, block)
       else
         @footer_line.add_cell(@collection.first, args)
@@ -557,7 +556,7 @@ module SortingTableFor
     def caption(*args, &block)
       @caption[:option], @caption[:html] = get_column_and_html_options( args.extract_options! )
       if block_given?
-        @caption[:value] = @@template.capture(&block)
+        @caption[:value] = capture(&block)
       else
         @caption[:value] = (args.empty?) ? I18n.t(:table_caption) : args.first;
       end
@@ -571,6 +570,11 @@ module SortingTableFor
       object.present? ? object.class.name : object.to_s.classify
     end
     
+    # Send method to ActionView
+    def method_missing(name, *args, &block)
+      @@template.send(name, *args, &block)
+    end
+    
     private
     
     def render_caption
@@ -595,6 +599,7 @@ module SortingTableFor
     def render_tbody
       if @lines and @lines.size > 0
         return Tools::html_safe(content_tag(:tbody, render_total_entries + Tools::html_safe(@lines.collect { |line| line.render_line }.join)))
+        return Tools::html_safe(content_tag(:tr, content_tag(:td, I18n.t(:total_entries, :scope => :sorting_table_for, :value => total_entries), {:colspan => max_cells}), { :class => 'total-entries' }))
       end
       ''
     end
@@ -624,7 +629,7 @@ module SortingTableFor
         total_entries = @collection.total_entries rescue @collection.size
         header_total_cells = @header_line ? @header_line.total_cells : 0
         max_cells = (@lines.first.total_cells > header_total_cells) ? @lines.first.total_cells : header_total_cells
-        return Tools::html_safe(content_tag(:tr, content_tag(:td, I18n.t(:total_entries, :scope => :sorting_table_for, :value => total_entries), {:colspan => max_cells}), { :class => 'total-entries' }))
+        return Tools::html_safe(content_tag(:tr, content_tag(:td, I18n.t(:total_entries, :value => total_entries), {:colspan => max_cells}), { :class => 'total-entries' }))
       end
       ''
     end
@@ -635,300 +640,4 @@ module SortingTableFor
     end
     
   end
-  
-  class FormatLine < TableBuilder
-    
-    def initialize(args, column_options = {}, html_options = {}, object = nil, type = nil)
-      @args, @column_options, @html_options, @object, @type = args, column_options, html_options, object, type
-      @cells = []
-      if object
-        @attributes = (args.empty?) ? (get_columns - TableBuilder.reserved_columns) : @args
-        create_cells
-      end
-    end
-    
-    # Create a new cell with the class FormatCell
-    # Add the object in @cells
-    def add_cell(object, args, type = nil, block = nil)
-      @cells << FormatCell.new(object, args, type, block)
-    end
-    
-    # Return a tr line based on the type (:thead, :tbody or :tfoot) 
-    def render_line
-      if @type == :thead
-        return content_tag(:tr, Tools::html_safe(@cells.collect { |cell| cell.render_cell_thead }.join), @html_options)
-      elsif @type == :tfoot
-        return content_tag(:tr, Tools::html_safe(@cells.collect { |cell| cell.render_cell_tfoot }.join), @html_options)
-      else
-        content_tag(:tr, Tools::html_safe(@cells.collect { |cell| cell.render_cell_tbody }.join), @html_options.merge(:class => "#{@html_options[:class]} #{@@template.cycle(:odd, :even)}".strip))
-      end
-    end
-    
-    # Return the number of cells in line
-    def total_cells
-      @cells.size
-    end
-    
-    protected
-    
-    # Return each column in the model's database table
-    def content_columns
-      model_name(@object).constantize.content_columns.collect { |c| c.name.to_sym }.compact rescue []
-    end
-    
-    # Return true if the column is in the model's database table
-    def model_have_column?(column)
-      model_name(@object).constantize.content_columns.each do |model_column|
-        return true if model_column.name == column.to_s
-      end
-      false
-    end
-    
-    # Return true if the column is in the model's database table
-    def can_sort_column?(column)
-      model_have_column?(column)
-    end
-
-    # Options only for cells
-    def only_cell_option?(key)
-      [:colspan].include? key
-    end
-
-    # Format ask to send options to cell
-    def format_options_to_cell(ask, options = @column_options)
-      options.each do |key, value|
-        if only_cell_option?(key)
-          if ask.is_a? Hash
-            ask.merge!(key => value)
-          else            
-            ask = [ask] unless ask.is_a? Array
-            (ask.last.is_a? Hash and ask.last.has_key? :html) ? ask.last[:html].merge!(key => value) : ask << { :html =>  { key => value }} 
-          end
-        end
-      end
-      ask
-    end
-
-    private
-    
-    # Call after headers or columns with no attributes (table.headers)
-    # Create all the cells based on each column in the model's database table
-    # Create cell's actions based on option default_actions or on actions given (:actions => [:edit])
-    def create_cells
-      @attributes.each { |ask| add_cell(@object, format_options_to_cell(ask)) }
-      if @args.empty?
-        TableBuilder.default_actions.each { |action| add_cell(@object, action, :action) }
-      else
-        get_column_actions.each { |action| add_cell(@object, action, :action) }
-      end
-    end
-    
-    # Return an Array of all actions given to headers or columns (:actions => [:edit, :delete])
-    def get_column_actions
-      if @column_options.has_key? :actions
-        if @column_options[:actions].is_a?(Array)
-          return @column_options[:actions]
-        else
-          return [ @column_options[:actions] ]
-        end
-      end
-      []
-    end
-    
-    # Return an Array of the columns based on options :only or :except
-    def get_columns
-      if @column_options.has_key? :only
-        return @column_options[:only] if @column_options[:only].is_a?(Array)
-        [ @column_options[:only] ]
-      elsif @column_options.has_key? :except
-        return content_columns - @column_options[:except] if @column_options[:except].is_a?(Array)
-        content_columns - [ @column_options[:except] ] 
-      else
-        content_columns
-      end
-    end
-
-  end
-
-  class FormatCell < FormatLine
-    
-    def initialize(object, args, type = nil, block = nil)
-      @object, @type, @block = object, type, block
-      if args.is_a? Array
-        @options, @html_options = get_cell_and_html_options( args.extract_options! )
-        @ask = args.first
-        if @ask.nil? and @options.has_key?(:action)
-          @type = :action 
-          @ask = @options[:action]
-        end
-      else
-        @ask = args
-      end
-      set_default_options
-      @can_sort = true if @options and @options[:sort] and can_sort_column?(@ask)
-    end
-    
-    # Return a td with the formated value or action for columns
-    def render_cell_tbody
-      if @type == :action
-        cell_value = action_link_to(@ask)
-      elsif @ask
-        cell_value = (@ask.is_a?(Symbol)) ? format_cell_value(@object[@ask], @ask) : format_cell_value(@ask)
-      else
-        cell_value = @block
-      end
-      cell_value = action_link_to(@options[:action], cell_value) if @type != :action and @options.has_key?(:action)
-      content_tag(:td, cell_value, @html_options)
-    end
-    
-    # Return a td with the formated value or action for headers
-    def render_cell_thead
-      if @ask
-        cell_value = (@ask.is_a?(Symbol)) ? I18n.t(@ask, {}, :header) : @ask
-      else
-        cell_value = @block
-      end
-      if @can_sort and @options[:sort]
-        @html_options.merge!(:class => "#{@html_options[:class]} #{sorting_html_class}".strip)
-        content_tag(:th, sort_link_to(cell_value), @html_options)
-      else
-        content_tag(:th, cell_value, @html_options)
-      end
-    end
-    
-    def render_cell_tfoot
-      if @ask
-        cell_value = (@ask.is_a?(Symbol)) ? I18n.t(@ask, {}, :footer) : @ask
-      else
-        cell_value = @block
-      end
-      cell_value = action_link_to(@options[:action], cell_value) if @type != :action and @options.has_key?(:action)
-      content_tag(:td, cell_value, @html_options)
-    end
-    
-    private
-    
-    # Return options and html options for a cell
-    def get_cell_and_html_options(options)
-      return options, options.delete(:html) || {}
-    end
-    
-    # Set default options for cell
-    # Set an empty hash if no html options
-    # Set an empty hash if no options
-    # Set sort to true if no options sort
-    def set_default_options
-      @html_options = {} unless defined? @html_options
-      @options = {} unless defined? @options
-      @html_options = format_options_to_cell(@html_options, @options)
-      @options[:sort] = @@options[:sort] if !@options.has_key? :sort
-    end
-    
-    # Create the link for actions
-    # Set the I18n translation or the given block for the link's name
-    def action_link_to(action, block = nil)
-      object_or_array = @@object_or_array.clone
-      object_or_array.push @object
-      return case action.to_sym
-        when :delete
-          create_link_to(block || I18n.t(:delete), object_or_array, @@options[:link_remote], :delete, I18n.t(:confirm_delete))
-        when :show
-          create_link_to(block || I18n.t(:show), object_or_array, @@options[:link_remote])
-        else
-          object_or_array.insert(0, action)
-          create_link_to(block || I18n.t(@ask), object_or_array, @@options[:link_remote])
-      end
-    end
-    
-    # Create sorting link
-    def sort_link_to(name)
-      create_link_to(name, sort_url, @@options[:sort_remote])
-    end
-    
-    # Create the link based on object
-    # Set an ajax link if option link_remote is set to true
-    # Compatible with rails 2 and 3.
-    def create_link_to(block, url, remote, method = nil, confirm = nil)
-      if remote and Tools::rails3?
-        return @@template.link_to(block, url, :method => method, :confirm => confirm, :remote => true)
-      elsif remote
-        method = :get if method.nil?
-        return @@template.link_to_remote(block, { :url => url, :method => method, :confirm => confirm })
-      end
-      @@template.link_to(block, url, :method => method, :confirm => confirm)
-    end
-    
-    # Return a string with html class of sorting for headers
-    # The html class is based on option: SortingTableFor::TableBuilder.html_sorting_class
-    def sorting_html_class
-      return TableBuilder.html_sorting_class.first if current_sorting.nil?
-      return TableBuilder.html_sorting_class.second if current_sorting == :asc
-      TableBuilder.html_sorting_class.third
-    end
-    
-    # Return an url for sorting
-    # Add the param sorting_table[name]=direction to the url
-    # Add the default direction: :asc
-    def sort_url
-      url_params = @@params.clone
-      if url_params.has_key? TableBuilder.params_sort_table
-        if url_params[TableBuilder.params_sort_table].has_key? @ask
-          url_params[TableBuilder.params_sort_table][@ask] = inverse_sorting
-          return @@template.url_for(url_params)
-        end
-        url_params[TableBuilder.params_sort_table].delete @ask
-      end
-      url_params[TableBuilder.params_sort_table] = { @ask => :asc }
-      @@template.url_for(url_params)
-    end
-    
-    # Return a symbol of the current sorting (:asc, :desc, nil)
-    def current_sorting
-      if @@params.has_key? TableBuilder.params_sort_table and @@params[TableBuilder.params_sort_table].has_key? @ask
-        return @@params[TableBuilder.params_sort_table][@ask].to_sym
-      end
-      nil
-    end
-    
-    # Return a symbol, the inverse of the current sorting
-    def inverse_sorting
-      return :asc if current_sorting.nil?
-      return :desc if current_sorting == :asc
-      :asc
-    end
-    
-    # Return the formated cell's value
-    def format_cell_value(value, attribute = nil)
-      unless (ret_value = format_cell_value_as_ask(value)).nil?
-        return ret_value
-      end
-      format_cell_value_as_type(value, attribute)
-    end
-    
-    # Format the value if option :as is set
-    def format_cell_value_as_ask(value)
-      return nil if !@options or @options.empty? or !@options.has_key?(:as)
-      return case @options[:as]
-        when :date then ::I18n.l(value.to_date, :format => @options[:format] || TableBuilder.i18n_default_format_date)
-        when :time then ::I18n.l(value.to_datetime, :format => @options[:format] || TableBuilder.i18n_default_format_date)
-        when :currency then number_to_currency(value)
-        else nil
-      end
-    end
-    
-    # Format the value based on value's type
-    def format_cell_value_as_type(value, attribute)
-      if value.is_a?(Time) or value.is_a?(Date)
-        return ::I18n.l(value, :format => @options[:format] || TableBuilder.i18n_default_format_date)
-      elsif TableBuilder.currency_columns.include?(attribute)
-        return number_to_currency(value)
-      elsif value.is_a?(TrueClass)
-        return TableBuilder.default_boolean.first
-      elsif value.is_a?(FalseClass)
-        return TableBuilder.default_boolean.second
-      end
-      value
-    end
-    
-  end
 end

data/spec/db/schema.rb

@@ -1,6 +1,6 @@
 ActiveRecord::Schema.define(:version => 0) do
 
-  create_table :users, :force => true do |t|
+  create_table :sorting_table_for_users, :force => true do |t|
     
     t.string    :username
     t.string    :firstname

data/spec/fixtures/{user.rb → sorting_table_for_user.rb}

@@ -1,4 +1,4 @@
-class User < ActiveRecord::Base
+class SortingTableForUser < ActiveRecord::Base
   if ::SortingTableFor::Tools::rails3?
     scope :good_position, :conditions => 'position > 3'
     scope :set_limit, lambda { |limit| { :limit => limit } }
@@ -10,7 +10,7 @@ class User < ActiveRecord::Base
 end
 
 20.times do |n|
-  User.create( 
+  SortingTableForUser.create( 
       :username => "my_usename_#{n}",
       :firstname => "my_firstname_#{n}",
       :lastname => "my_lastname_#{n}",

data/spec/helpers/builder_spec.rb

@@ -1,16 +1,19 @@
 # encoding: utf-8
 
 require 'spec_helper'
-require File.expand_path(File.dirname(__FILE__) + '/../fixtures/user')
+require File.expand_path(File.dirname(__FILE__) + '/../fixtures/sorting_table_for_user')
 
 include SortingTableForSpecHelper
 
 describe SortingTableFor, :type => :helper do
   
+  before :all do
+    (SortingTableFor::Tools::rails3?) ? routes_rails3 : routes_rails2
+  end
+  
   before :each do
-    @users = User.all
-    helper.stub!(:url_for).and_return('fake_link')
-    helper.stub!(:params).and_return({ :controller => 'fakes', :action => 'index' })
+    @users = SortingTableForUser.all
+    helper.stub!(:params).and_return({ :controller => 'sorting_table_for_users', :action => 'index' })
     helper.output_buffer = ''
   end
   
@@ -42,7 +45,7 @@ describe SortingTableFor, :type => :helper do
       end
     end
     
-    it "should no use i18n by default" do
+    it "should use i18n by default" do
       helper.sorting_table_for(@users) do |table|
         html = table.headers(:username)
         html.should have_comp_tag("th:nth-child(1)", :text => 'Usernames')