sorting_table_for 0.2.0 → 0.2.1

data/CHANGELOG.mdown

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+### Version 0.2.1 _(July 20, 2011)_
+
+* Fix bug with sorting_table was not loading in ActiveRecord
+
 ### Version 0.2.0 _(November 14, 2010)_
 
 * Add footers and footer

data/init.rb

@@ -1,7 +1,3 @@
 # encoding: utf-8
 
-# Require Helper
 require 'sorting_table_for'
-
-# Require Scoping helper
-require 'model/sorting_table_model_scope'

data/lib/sorting_table_for.rb

@@ -1,6 +1,9 @@
 # encoding: utf-8
 
+require 'sorting_table_for/model_scope'
 require 'sorting_table_for/table_builder'
+require 'sorting_table_for/format_line'
+require 'sorting_table_for/format_cell'
 require 'sorting_table_for/i18n'
 require 'sorting_table_for/tools'
 

data/lib/sorting_table_for/format_cell.rb

@@ -0,0 +1,189 @@
+module SortingTableFor
+  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_column?
+    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
+        sort_on = @options[:sort_as] || @ask
+        @html_options.merge!(:class => "#{@html_options[:class]} #{sorting_html_class(sort_on)}".strip)
+        content_tag(:th, sort_link_to(cell_value, sort_on), @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 to true if column is sortable
+    def can_sort_column?
+      @can_sort = true if @options[:sort] and model_have_column?(@options[:sort_as] || @ask)
+    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, sort_on)
+      create_link_to(name, sort_url(sort_on), @@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 link_to(block, url, :method => method, :confirm => confirm, :remote => true)
+      elsif remote
+        method = :get if method.nil?
+        return link_to_remote(block, { :url => url, :method => method, :confirm => confirm })
+      end
+      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(sort_on)
+      return TableBuilder.html_sorting_class.first if current_sorting(sort_on).nil?
+      return TableBuilder.html_sorting_class.second if current_sorting(sort_on) == :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(sort_on)
+      url_params = @@params.clone
+      if url_params.has_key? TableBuilder.params_sort_table
+        if url_params[TableBuilder.params_sort_table].has_key? sort_on
+          url_params[TableBuilder.params_sort_table][sort_on] = inverse_sorting(sort_on)
+          return url_for(url_params)
+        end
+        url_params[TableBuilder.params_sort_table].delete sort_on
+      end
+      url_params[TableBuilder.params_sort_table] = { sort_on => :asc }
+      url_for(url_params)
+    end
+  
+    # Return a symbol of the current sorting (:asc, :desc, nil)
+    def current_sorting(sort_on)
+      if @@params.has_key? TableBuilder.params_sort_table and @@params[TableBuilder.params_sort_table].has_key? sort_on
+        return @@params[TableBuilder.params_sort_table][sort_on].to_sym
+      end
+      nil
+    end
+  
+    # Return a symbol, the inverse of the current sorting
+    def inverse_sorting(sort_on)
+      return :asc if current_sorting(sort_on).nil?
+      return :desc if current_sorting(sort_on) == :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/lib/sorting_table_for/format_line.rb

@@ -0,0 +1,110 @@
+module SortingTableFor
+  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
+
+    # 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 
+end

data/lib/sorting_table_for/i18n.rb

@@ -5,21 +5,28 @@ module SortingTableFor
     class << self
       
       # Set options to create a default scope
-      def set_options(params, model_name, namespace, i18n_active = true)
-        @params, @model_name, @namespace, @i18n_active = params, model_name, namespace, i18n_active
+      def set_options(params, model_name, i18n_active = true)
+        @model_name, @i18n_active = model_name, i18n_active
+        @action = (params.has_key? :action) ? params[:action].downcase : ''
+        @controller = (params.has_key? :controller) ? params[:controller].downcase : ''
+        if @controller.include? '/'
+          @namespace = @controller.split '/'
+          @controller = @namespace.pop
+        end
       end
       
-      # Translate
       # Add a default scope if option scope isn't defined
       def translate(attribute, options = {}, type = nil)
-        if !@i18n_active
+        unless @i18n_active
           return options[:value] if options.has_key? :value
           return attribute
         end
-        if !options.has_key? :scope
-          options[:scope] = create_scope 
+        unless options.has_key? :scope
+          options[:scope] = create_scope
           options[:scope] << TableBuilder.i18n_add_header_action_scope if type and type == :header
           options[:scope] << TableBuilder.i18n_add_footer_action_scope if type and type == :footer
+          options[:scope] << options.delete(:add_scope)
+          options[:scope].flatten!
         end
         ::I18n.t(attribute, options)
       end
@@ -31,10 +38,10 @@ module SortingTableFor
       def create_scope
         return TableBuilder.i18n_default_scope.collect do |scope_value|
           case scope_value.to_sym
-            when :controller then @params[:controller] ? @params[:controller].downcase : ''
-            when :action then @params[:action] ? @params[:action].downcase : ''
+            when :controller then @controller
+            when :action then @action
             when :model then @model_name ? @model_name.downcase.to_s : ''
-            when :namespace then @namespace ? @namespace.downcase.to_s : ''
+            when :namespace then @namespace ? @namespace : ''
             else scope_value.to_s
           end
         end

data/lib/sorting_table_for/model_scope.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module SortingTableFor
+  module ModelScope
+  
+    # Include the methods in models
+    def self.included(base)
+      base.class_eval do
+        extend SingletonMethods
+      end
+    end
+  
+    module SingletonMethods
+    
+      # Return a scope of the object with an order
+      #
+      # === Usage
+      # 
+      #  sorting_table(the params) - Sorting by the given parameters
+      #  sorting_table(the params, column name) - Sort by the column name with direction ascending, if no parameters
+      #  sorting_table(the params, column name, direction) - Sort by the column name with the given direction, if no parameters
+      #
+      # === Exemples
+      #
+      #  User.sorting_table(params)
+      #  User.sorting_table(params, :username)
+      #  User.sorting_table(params, :username, :desc)
+      #
+      def sorting_table(*args)
+        raise ArgumentError, 'sorting_table: Too many arguments (max : 3)' if args.size > 3 
+        sort_table_param = get_sorting_table_params(args)
+        return scoped({})  if !sort_table_param and args.size == 1
+        sort, direction = get_sort_and_direction(sort_table_param, args)
+        return scoped({}) if !sort or !valid_column?(sort) or !valid_direction?(direction)
+        scoped({ :order => "#{sort} #{direction}" })
+      end
+
+      private
+    
+      # Return the params for sorting table
+      def get_sorting_table_params(args)
+        return nil unless args.first.is_a? Hash
+        return nil unless args.first.has_key? SortingTableFor::TableBuilder.params_sort_table.to_s
+        args.first[SortingTableFor::TableBuilder.params_sort_table.to_s]
+      end
+    
+      # Parse the params and return the column name and the direction
+      def get_sort_and_direction(sort_table_param, args)
+        if sort_table_param
+          key = sort_table_param.keys.first rescue nil
+          value = sort_table_param.values.first rescue nil
+          return nil if !key.is_a?(String) or !value.is_a?(String)
+          return key, value
+        end
+        return nil if args.size < 2
+        return args[1], 'asc' if args.size == 2
+        return args[1], args[2]
+      end
+    
+      # Return true if the column name exist
+      def valid_column?(column)
+        column_names.include? column.to_s.downcase
+      end
+    
+      # Return true if the direction exist
+      def valid_direction?(direction)
+        %[asc desc].include? direction.to_s.downcase
+      end
+    
+   end  
+  end
+end
+
+if defined? ActiveRecord
+  ActiveRecord::Base.send :include, SortingTableFor::ModelScope
+end