action_tabler 0.1.1 → 0.1.2

data/README.md

@@ -117,8 +117,8 @@ See the DataTables web site for more about DataTables [Options](http://www.datat
 
 DataTables options which start with m or fn are treated differently, since they can be used to pass context specific Javascript. These options accept three three kinds of value:
 
-- String: This can be simply a string which will be rendered as is, or the name of a a partial to be rendered. The options local variable will be the current column definition hash.
-- Symbol: the name of a helper method which will be executed with a single argument containing the current column definition hash.
+- String: a string which will be evaluated as is;
+- Symbol: the name of a helper method which will be executed with a single argument containing the current column definition hash; or,
 - Proc: a Proc which will passed the current column definition hash.
 
 ## Running Tests

data/app/views/action_tabler/_table.html.erb

@@ -1,7 +1,7 @@
-<table cellpadding="0" cellspacing="0" border="0"<% if @table_class %> class="@table_class"<% end %> id="<%= @table_id %>">
+<table cellpadding="0" cellspacing="0" border="0"<% if table_handler.table_class %> class="table_class"<% end %> id="<%= table_handler.table_id %>">
 	<thead>
 		<tr>
-			<% for column in @table_columns do %>
+			<% for column in table_handler.columns do %>
 				<th><%= column[:label] %></th>
 			<% end %>
 		</tr>
@@ -15,6 +15,6 @@
 
 <script type="text/javascript" charset="utf-8">
 	$(document).ready(function() {
-		$('#<%= @table_id %>').dataTable( <%= render_datatables_table_definitions.html_safe %> ); 
+		$('#<%= table_handler.table_id %>').dataTable( <%= table_handler.table_definition(params, url_for).html_safe %> ); 
 	} );
 </script>

data/lib/action_tabler/data_tables/data_handler.rb

@@ -0,0 +1,88 @@
+module ActionTabler
+  module DataTables
+    module DataHandler
+      
+      # Render table data
+      def data_package(params)
+        # Select the requested records
+        @records = @model.where(exitisting_conditions(params)).
+                          where(global_conditions(params)).
+                          where(column_conditions(params)).
+                          limit(params[:iDisplayLength]).
+                          offset(params[:iDisplayStart]).
+                          order(sort_conditions(params))
+  # Count the total records available
+        @display_count = @model.where(exitisting_conditions(params)).
+                                where(global_conditions(params)).
+                                where(column_conditions(params)).
+                                count
+        # Find out total records, including those not found by a search specification
+        @total_count = @model.where(exitisting_conditions(params)).count
+
+        @column_names = []
+
+        # Build a hash with json safe column names
+        @records = @records.inject([]) do |result, record|
+          result << @columns.inject([])  do |this, column|
+            this << eval("record.#{column[:name]}")
+            @column_names << column[:name].to_s
+            this
+          end
+          result
+        end
+
+        # Return the data package as a hash
+        { :iTotalDisplayRecords => @display_count,
+          :iTotalRecords => @total_count, 
+          :sNames => @column_names, 
+          :aaData => @records,
+          :sEcho => params[:sEcho].to_i }
+      end # datatable_json_index
+
+      private
+
+      # Calculate global finder were clause
+      def global_conditions(params)
+        # Check to see if there's a search parameter
+        unless params[:sSearch].to_s.empty?
+          # Build a LIKE condition string with searchable fields
+          # NOTE: This ignores client-side specified searchable fields
+          search_string = searchable_columns.collect {|c| "#{column_for_sql(column[:name])} LIKE :keyword"}.join(" OR ")
+          
+          # Assemble the condition string along with the search parameter
+          [search_string, {:keyword => "%#{params[:sSearch].to_s}%"}]
+        end
+      end
+
+      # Calculate where clause for individual column filtering
+      def column_conditions(params)
+        searchable_columns.inject({}) do |result, column|
+          search_string = params["sSearch_#{@columns.index(column)}"].to_s
+          unless search_string.empty?
+            result[column[:name]] = search_string
+          end
+          result
+        end
+      end
+
+      # Returns the finder order clause
+      def sort_conditions(params)
+        sort_conditions = params.inject([]) do |result, (k, v)|
+          # Find all of the parameters which start with iSortCol
+          if k.match(/iSortCol_(\d+)/) && i = k.match(/iSortCol_(\d+)/)[1]
+            # Add this sort condition to the temporary array
+            if @columns[v.to_i][:sortable] != false
+              sort_column = column_for_sql(@columns[v.to_i][:name])
+              result << "#{sort_column} #{params['sSortDir_' + i.to_s]}"
+            end
+          end
+          result
+        end
+
+        # Join the array into a sort string
+        sort_conditions.join(", ").strip
+      end
+
+    end
+  end
+end

data/lib/action_tabler/data_tables/display_handler.rb

@@ -0,0 +1,107 @@
+module ActionTabler
+  module DataTables
+    module DisplayHandler
+      def table_definition(params, source_url)
+        table_options = {:bProcessing => true, :bServerSide => true, :sAjaxSource => source_url}.update(@table_options)
+        table_options[:fnServerParams] ||= passed_parameters(exitisting_conditions(params))
+        table_options[:aoColumnDefs] ||= column_definitions
+
+        "{" + table_options.collect{|k,v| render_attribute(k, v)}.compact.join(", \n") + "}"
+      end # table_definition
+
+      def table_id
+        @model.name.underscore + "_table"
+      end
+
+      def table_class
+        @table_class
+      end
+
+      def columns
+        @columns
+      end
+
+      private
+
+      # Build the DataTables column definition list
+      def column_definitions
+        count = -1
+        @columns.collect {|column| count += 1; column_definition_for(column, count)}
+      end # column_definitions
+
+      # Build an individual DataTables column definition
+      def column_definition_for(column, count)
+        this_column = column.clone
+        this_column.delete(:label)
+        this_column[:sName] = this_column.delete(:name)
+        
+        this_column[:sType] ||= column_type_for(column[:name]) if @auto_type
+
+        this_column[:bSearchable] = this_column.delete(:searchable) if this_column.has_key?(:searchable)
+        this_column[:bSortable] = this_column.delete(:sortable) if this_column.has_key?(:sortable)
+        this_column[:aTargets] = [count]
+
+        "{" + this_column.collect{|k,v| render_attribute(k, v, column)}.compact.join(", ") + "}"
+      end # column_definition_for
+
+      # Render passed parameters for a Data Table table definition
+      def passed_parameters(options)
+        "function ( aoData ) { aoData.push( " + 
+        options.collect{|k,v| '{ "name": "' + @model.name.parameterize + 
+                              '[' + k + ']", "value": "' + v + '"}' }.join(", ") + 
+        " ); }" if options
+      end # passed_parameters
+
+      # Render an attribute for a DataTables column definition
+      def render_attribute(name, value, options = {})
+        this_name = name.to_s
+        if value.nil?
+          return
+        elsif this_name.starts_with?("b")
+          '"' + this_name + '": ' + (value ? 'true' : 'false')
+        elsif this_name.starts_with?("i")
+          '"' + this_name + '": "' + value.to_i.to_s + '"'
+        elsif this_name.starts_with?("ao")
+          '"' + this_name + '": ' + "[#{value.join(", \n")}]"
+        elsif this_name.starts_with?("a")
+          '"' + this_name + '": ' + value.to_json.html_safe
+        elsif this_name.starts_with?("fn", "m")
+          '"' + this_name + '": ' + render_fn_or_m_attribute(value, options)
+        elsif this_name.starts_with?("f")
+          '"' + this_name + '": "' + value.to_f.to_s + '"'
+        else
+          '"' + this_name + '": "' + value.to_s + '"'
+        end
+      end #render_attribute
+
+      # Render a function or method column attribute for a DataTables column definition.
+      def render_fn_or_m_attribute(value, options)
+        if value.kind_of?(Proc)
+          value.call(options)
+        elsif value.kind_of?(Symbol)
+          self.send(value, options)
+        elsif value.kind_of?(String)
+          value
+        else
+          ""
+        end
+      end # render_fn_or_m_attribute
+
+      def column_type_for(name)
+        visit_attribute(name) do |name, model|
+            case model.columns_hash[name].class
+            when :datetime, :date, :time, :timestamp
+            "date"
+          when :integer, :float, :decimal, :binary
+            "numeric"
+          when :text
+            "html"
+          else
+            "string"
+          end
+        end
+      end # column_type_for
+
+    end
+  end
+end

data/lib/action_tabler/data_tables.rb

@@ -0,0 +1,9 @@
+require 'action_tabler/data_tables/display_handler'
+require 'action_tabler/data_tables/data_handler'
+
+module ActionTabler
+  module DataTables
+    include ActionTabler::DataTables::DataHandler
+    include ActionTabler::DataTables::DisplayHandler
+  end
+end

data/lib/action_tabler/has_table_action.rb

@@ -3,333 +3,38 @@ module ActionTabler
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :action_tabler_columns, :action_tabler_action, :action_tabler_auto_type, 
-                      :action_tabler_pass_params, :action_tabler_model, :action_tabler_table_class, 
-                      :action_tabler_auto_width, :action_tabler_table_options 
+      class_attribute :table_handler
     end
 
     module ClassMethods
       # Adds table display to a controller. 
-      def has_table_action(columns = [], options = {})
-        self.action_tabler_columns = []
-        self.action_tabler_table_options = {}
-
-        # Load essential column-related options
-        self.action_tabler_model = (options[:class_name] || controller_name).classify.constantize
-        self.action_tabler_auto_type = options[:auto_type] || AbstractController::Base.action_tabler_auto_type
-
-        # Check to see what we've been passed
-        if columns.kind_of?(Hash)
-          # Set options to columns if columns not passed in parameters
-          options = columns
-        elsif columns == :auto
-          # Auto populate columns if specified
-          auto_table_columns
-        elsif columns.kind_of?(Array)
-          columns.collect{|c| column(c)}
-        end
-
-        # Populate columns from block
-        yield if block_given?
-
-        # Add configuration columns if specified
-        if AbstractController::Base.action_tabler_columns.kind_of?(Array)
-          AbstractController::Base.action_tabler_columns.collect{|c| column(c)}
-        end
-
-        # Auto specify columns if they're empty and the config is set to auto
-        if action_tabler_columns.empty? && AbstractController::Base.action_tabler_columns == :auto
-          auto_table_columns
-        end
-
-        if action_tabler_columns.empty?
-          raise ArgumentError, "No columns defined for has_table_action"
-        end
-
-        # Load options
-        self.action_tabler_action = options[:action] || AbstractController::Base.action_tabler_action
-        self.action_tabler_pass_params = options[:pass_params] || AbstractController::Base.action_tabler_pass_params
-        self.action_tabler_table_class = options[:table_class] || AbstractController::Base.action_tabler_table_class
-        
-        self.action_tabler_table_options.update(AbstractController::Base.action_tabler_table_options)
-        self.action_tabler_table_options.update(options[:table_options] || {})
+      def has_table_action(columns = [], options = {}, &block)
+        self.table_handler = ActionTabler::Handler.new(self, columns, options, &block)
 
         include DeclaredInstanceMethods
 
         # Define the table action method
-        define_method(action_tabler_action) do
+        define_method(options[:action] || ActionTabler::Handler.configuration[:action]) do
           action_tabler
         end
 
-        # Make the column name formaters available in views 
-        helper_method :column_name_for_json, :column_name_from_json, :render_datatables_table_definitions
+        helper_method :table_handler
       end # has_table_action
 
-      # Add a table column definition
-      def column(name, opts={})
-        # Check what we're getting
-        if name.kind_of?(Hash)
-          # If it's a hash, leave as is
-          column = name
-          raise ArgumentError, "column definition requires a name" if column[:name].to_s.empty?
-        elsif name.kind_of?(Symbol) || name.kind_of?(String)
-          # If it's a string or symbol, create a definition
-          column = {:name => name}
-          column.update(opts) if opts.kind_of?(Hash)
-        else
-          raise ArgumentError, "table_column name expects String, Symbol, or Hash (got #{name.class.name})"
-        end
-
-        # Ensure name is a string
-        column[:name] = column[:name].to_s
-
-        # Add label if not specified
-        column[:label] ||= column[:name].to_s.titleize
-
-        # Add the column to out list
-        self.action_tabler_columns << column
-      end
-
-      # Create column definitions using reflection
-      def auto_table_columns
-        action_tabler_model.columns_hash.keys.collect{|k| column(k)}
-      end
-
     end # ClassMethods
 
     module DeclaredInstanceMethods
 
-      # Translate . to _dot_
-      def column_name_for_json(name)
-        name.gsub(".", "_dot_")
-      end
-
-      # Translate _dot_ to .
-      def column_name_from_json(name)
-        name.gsub("_dot_", ".")
-      end
-
-      def render_datatables_table_definitions
-        table_options = {:bProcessing => true, :bServerSide => true, :sAjaxSource => url_for}.update(action_tabler_table_options)
-        table_options[:fnServerParams] ||= render_passed_parameters(@table_parameters) if @table_parameters
-        table_options[:aoColumnDefs] ||= datatables_column_definitions
-        
-        "{" + table_options.collect{|k,v| render_datatables_attribute(k, v)}.join(", \n") + "}"
-      end
-
       private
 
       # Main table view action
       def action_tabler
-        # Figure out what model with which we're working
-        @table_model = action_tabler_model
-
-        # Load the column specification
-        @table_columns = action_tabler_columns
-
-        # Assign addtional parameters
-        @table_parameters = params[@table_model.name.parameterize] if action_tabler_pass_params
-
         respond_to do |format|
-          format.html {action_tabler_for_html}
-          format.json {action_tabler_for_json}
+          format.html {render "action_tabler/table"}
+          format.json {render :json => table_handler.data_package(params)}
         end # respond_to
       end # datatable_index
 
-      ###
-      # Display Rendering
-      ###
-
-      # Render the datable html index, which provides the browser display wrapper for the table data
-      def action_tabler_for_html
-        # Assign the table css class
-        @table_class = action_tabler_table_class
-        
-        # Assign the table DOM id
-        @table_id = @table_model.name.underscore + "_table"
-
-        # Assign auto width setting
-        @table_auto_width = action_tabler_auto_width
-
-        render "action_tabler/table"
-      end # datatable_html_index
-
-      # Build the DataTables column definition list
-      def datatables_column_definitions
-        count = -1
-        action_tabler_columns.collect {|col| count += 1; datatables_column_definition_for(col, count)}
-      end # datatables_column_definitions
-
-      # Build an individual DataTables column definition
-      def datatables_column_definition_for(column, count)
-        this_column = column.clone
-        this_column.delete(:label)
-        this_column[:sName] = this_column.delete(:name)
-        
-        this_column[:sType] ||= action_tabler_column_type_for(column[:name], action_tabler_model) if action_tabler_auto_type
-
-        this_column[:bSearchable] = this_column.delete(:searchable) if this_column.has_key?(:searchable)
-        this_column[:bSortable] = this_column.delete(:sortable) if this_column.has_key?(:sortable)
-        this_column[:aTargets] = [count]
-
-        "{" + this_column.collect{|k,v| render_datatables_attribute(k, v, column)}.compact.join(", ") + "}"
-      end # datatables_column_definition_for
-
-      # Render passed parameters for a Data Table table definition
-      def render_passed_parameters(options)
-        "function ( aoData ) { aoData.push( " + 
-        options.collect{|k,v| '{ "name": "' + @table_model.name.parameterize + 
-                              '[' + k + ']", "value": "' + v + '"}' }.join(", ") + 
-        " ); }"
-      end # render_pass_parameters
-
-      # Render an attribute for a DataTables column definition
-      def render_datatables_attribute(name, value, options = {})
-        this_name = name.to_s
-        if value.nil?
-          return
-        elsif this_name.starts_with?("b")
-          '"' + this_name + '": ' + (value ? 'true' : 'false')
-        elsif this_name.starts_with?("i")
-          '"' + this_name + '": "' + value.to_i.to_s + '"'
-        elsif this_name.starts_with?("ao")
-          '"' + this_name + '": ' + "[#{value.join(", \n")}]"
-        elsif this_name.starts_with?("a")
-          '"' + this_name + '": ' + value.to_json.html_safe
-        elsif this_name.starts_with?("fn", "m")
-          '"' + this_name + '": ' + render_datatables_fn_or_m(value, options)
-        elsif this_name.starts_with?("f")
-          '"' + this_name + '": "' + value.to_f.to_s + '"'
-        else
-          '"' + this_name + '": "' + value.to_s + '"'
-        end
-      end
-
-      # Render a function or method column attribute for a DataTables column definition.
-      def render_datatables_fn_or_m(value, options)
-        if value.kind_of?(Proc)
-          value.call(options)
-        elsif value.kind_of?(Symbol)
-          self.send(value, options)
-        elsif value.kind_of?(String)
-          lookup_context.formats << :js
-          template_exists?(value, lookup_context.prefixes, true) ? render_to_string(:partial => value, :locals => {:options => options}) : value
-        else
-          ""
-        end
-      end
-
-      # Look up an ActiveRecord column type and translate to DataTables column type.
-      def action_tabler_column_type_for(name, model=nil)
-        # Set the default model if not passed
-        model ||= action_tabler_model
-        
-        # We can really only do this if we have ActiveRecord or equivalent
-        return nil unless model.respond_to?(:columns_hash)
-
-        # Ensure we have a string
-        name = name.to_s
-
-        # Determine if we have a relation
-        if name.include?(".")
-          names = name.split(".")
-          # Discover relation model name
-          reflection = model.reflect_on_association(names[0].to_sym)
-          # Recurse with realtion model and name
-          action_tabler_column_type_for(name.gsub("#{names[0]}.", ""), reflection.klass)
-        else
-          # Look up and return the Datatables column type
-          ActionTabler::JqueryDatatables.column_type_for(model.columns_hash[name].class)
-        end
-      end
-
-      ###
-      # Data Rendering
-      ###
-
-      # Render the table data
-      def action_tabler_for_json
-        # Select the requested records
-        @records = @table_model.where(@table_parameters).
-                                where(action_tabler_global_conditions).
-                                where(action_tabler_column_conditions).
-                                limit(params[:iDisplayLength]).
-                                offset(params[:iDisplayStart]).
-                                order(action_tabler_sort_order)
-        # Count the total records available
-        records_count = @table_model.where(@table_parameters).
-                                     where(action_tabler_global_conditions).
-                                     where(action_tabler_column_conditions).
-                                     count
-        # Find out total records, including those not found by a search specification
-        total_count = @table_model.where(@table_parameters).count
-
-        @column_names = []
-
-        # Build a hash with json safe column names
-        @records = @records.inject([]) do |result, record|
-          result << action_tabler_columns.inject([])  do |this, column|
-            this << eval("record.#{column[:name]}")
-            @column_names << column[:name].to_s
-            this
-          end
-          result
-        end
-
-        # Render the data as json
-        render :json => { :iTotalRecords => total_count, 
-                          :iTotalDisplayRecords => records_count,
-                          :sNames => @column_names, 
-                          :aaData => @records,
-                          :sEcho => params[:sEcho].to_i }
-      end # datatable_json_index
-
-      # Calculate global finder were clause
-      def action_tabler_global_conditions
-        # Check to see if there's a search parameter
-        unless params[:sSearch].to_s.empty?
-          # Build a LIKE condition string with searchable fields
-          # NOTE: This ignores client-side specified searchable fields
-          search_string = action_tabler_searchable_columns.collect {|c| "#{column[:name]} LIKE :keyword"}.join(" OR ")
-          
-          # Assemble the condition string along with the search parameter
-          [search_string, {:keyword => "%#{params[:sSearch].to_s}%"}]
-        end
-      end
-
-      # Calculate where clause for individual column filtering
-      def action_tabler_column_conditions
-        action_tabler_searchable_columns.inject({}) do |result, column|
-          search_string = params["sSearch_#{action_tabler_columns.index(column)}"].to_s
-          unless search_string.empty?
-            result[column[:name]] = search_string
-          end
-          result
-        end
-      end
-
-      # List searchable columns
-      def action_tabler_searchable_columns
-        action_tabler_columns.select{|column| column[:searchable] != false}
-      end
-
-      # Returns the finder order clause
-      def action_tabler_sort_order
-        sort_conditions = params.inject([]) do |result, (k, v)|
-          # Find all of the parameters which start with iSortCol
-          if k.match(/iSortCol_(\d+)/) && i = k.match(/iSortCol_(\d+)/)[1]
-            # Add this sort condition to the temporary array
-            if action_tabler_columns[v.to_i][:sortable] != false
-              result << "#{action_tabler_columns[v.to_i][:name]} #{params['sSortDir_' + i.to_s]}"
-            end
-          end
-          result
-        end
-
-        # Join the array into a sort string
-        sort_conditions.join(", ").strip
-      end
-
     end # InstanceMethods
   end #AbstractController  
 end

data/lib/action_tabler/railtie.rb

@@ -15,28 +15,27 @@ module ActionTabler
     end
 
     def initialize_configuration(config)
+      ActionTabler::Handler.configuration = {}
 
       # Check and set default column definitions
       if config.respond_to?(:action_tabler_columns)
         if config.action_tabler_columns.kind_of?(Array) || 
-           config.action_tabler_columns.kind_of?(Symbol) ||
-           config.action_tabler_columns.kind_of?(Proc)
-          AbstractController::Base.action_tabler_columns = config.action_tabler_columns
+          config.action_tabler_columns.kind_of?(Symbol) ||
+          config.action_tabler_columns.kind_of?(Proc)
+          ActionTabler::Handler.configuration[:columns] = config.action_tabler_columns
         else
           raise ArgumentError, "config.action_tabler_columns expected Symbol, Array, or Proc (got #{config.action_tabler_attributes.class.name})"
         end
       else
-        AbstractController::Base.action_tabler_columns = []
+        ActionTabler::Handler.configuration[:columns] = []
       end
      
       # Set other configuration options
-      AbstractController::Base.action_tabler_columns = (config.respond_to?(:action_tabler_columns) ? config.action_tabler_columns : [])
-      AbstractController::Base.action_tabler_table_class = config.respond_to?(:action_tabler_table_class) ? config.action_tabler_table_class : nil
-      AbstractController::Base.action_tabler_auto_width = config.respond_to?(:action_tabler_auto_width) ? config.action_tabler_auto_width : true
-      AbstractController::Base.action_tabler_action = config.respond_to?(:action_tabler_action) ? config.action_tabler_action : "table"
-      AbstractController::Base.action_tabler_auto_type = config.respond_to?(:action_tabler_auto_type) ? config.action_tabler_auto_type : true
-      AbstractController::Base.action_tabler_pass_params = config.respond_to?(:action_tabler_pass_params) ? config.action_tabler_pass_params : false
-      AbstractController::Base.action_tabler_table_options = config.respond_to?(:action_tabler_table_options) ? config.action_tabler_table_options : {}
+      ActionTabler::Handler.configuration[:table_class] = config.respond_to?(:action_tabler_table_class) ? config.action_tabler_table_class : nil
+      ActionTabler::Handler.configuration[:action] = config.respond_to?(:action_tabler_action) ? config.action_tabler_action : "table"
+      ActionTabler::Handler.configuration[:auto_type] = config.respond_to?(:action_tabler_auto_type) ? config.action_tabler_auto_type : true
+      ActionTabler::Handler.configuration[:pass_params] = config.respond_to?(:action_tabler_pass_params) ? config.action_tabler_pass_params : false
+      ActionTabler::Handler.configuration[:table_options] = config.respond_to?(:action_tabler_table_options) ? config.action_tabler_table_options : {}
       
     end
   end

data/lib/action_tabler/table_handler.rb

@@ -0,0 +1,83 @@
+module ActionTabler
+  class Handler
+    class_attribute :configuration
+
+    include ActionTabler::Utilities
+    include ActionTabler::DataTables
+
+    def initialize(controller, columns = [], options = {}, &block)
+      @columns = []
+      @table_options = {}
+
+      # Load essential column-related options
+      @model = (options[:class_name] || controller.controller_name).classify.constantize
+      @auto_type = options[:auto_type] || configuration[:auto_type]
+
+      # Check to see what we've been passed
+      if columns.kind_of?(Hash)
+        # Set options to columns if columns not passed in parameters
+        options = columns
+      elsif columns == :auto
+        # Auto populate columns if specified
+        auto_columns
+      elsif columns.kind_of?(Array)
+        columns.collect{|c| column(c)}
+      end
+
+      # Populate columns from block
+      instance_eval(&block) if block.kind_of?(Proc)
+
+      # Add configuration columns if specified
+      if configuration[:columns].kind_of?(Array)
+        configuration[:columns].collect{|c| column(c)}
+      end
+
+      # Auto specify columns if they're empty and the config is set to auto
+      if @columns.empty? && configuration[:columns] == :auto
+        auto_columns
+      end
+
+      if @columns.empty?
+        raise ArgumentError, "No columns defined for has_table_action"
+      end
+
+      # Load options
+      @pass_params = options[:pass_params] || configuration[:pass_params]
+      @table_class = options[:table_class] || configuration[:table_class]
+      
+      @table_options.update(configuration[:table_options])
+      @table_options.update(options[:table_options] || {})
+    end
+    
+    # Add a table column definition
+    def column(name, opts={})
+      # Check what we're getting
+      if name.kind_of?(Hash)
+        # If it's a hash, leave as is
+        column = name
+        raise ArgumentError, "column definition requires a name" if column[:name].to_s.empty?
+      elsif name.kind_of?(Symbol) || name.kind_of?(String)
+        # If it's a string or symbol, create a definition
+        column = {:name => name}
+        column.update(opts) if opts.kind_of?(Hash)
+      else
+        raise ArgumentError, "table_column name expects String, Symbol, or Hash (got #{name.class.name})"
+      end
+
+      # Ensure name is a string
+      column[:name] = column[:name].to_s
+
+      # Add label if not specified
+      column[:label] ||= column[:name].to_s.gsub(".", " ").titleize
+
+      # Add the column to out list
+      @columns << column
+    end
+
+    # Create column definitions using reflection
+    def auto_columns
+      @model.columns_hash.keys.collect{|k| column(k)}
+    end
+
+  end
+end

data/lib/action_tabler/utilities.rb

@@ -0,0 +1,43 @@
+module ActionTabler
+  module Utilities
+
+    # Existing search conditions if enabled
+    def exitisting_conditions(params)
+      params[@model.name.parameterize] if @pass_params
+    end
+
+    # List searchable columns
+    def searchable_columns
+      @columns.select{|column| column[:searchable] != false}
+    end
+
+    # Returns a fully qualified column name for SQL statements
+    def column_for_sql(name, model = nil)
+      visit_attribute(name){|name, model| [model.arel_table.name, name].join(".")}
+    end
+
+    # Helps work with fully qualified attributes, usually to generate SQL
+    def visit_attribute(name, model = nil, &block)
+      # Set the default model if not passed
+      model ||= @model
+      
+      # We can really only do this if we have ActiveRecord or equivalent
+      return nil unless model.respond_to?(:columns_hash)
+
+      # Ensure we have a string
+      name = name.to_s
+
+      # Determine if we have a relation
+      if name.include?(".")
+        names = name.split(".")
+        # Discover relation model
+        reflection = model.reflect_on_association(names[0].to_sym)
+        # Recurse with realtion model and name
+        column_for_sql(name.gsub("#{names[0]}.", ""), reflection.klass)
+      else
+        block.call(name, model)
+      end
+    end
+
+  end
+end

data/lib/action_tabler/version.rb

@@ -1,3 +1,3 @@
 module ActionTabler
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/action_tabler.rb

@@ -1,31 +1,9 @@
-require 'action_tabler/jquery_datatables'
+require 'action_tabler/utilities'
+require 'action_tabler/data_tables'
+require 'action_tabler/table_handler'
 require 'action_tabler/has_table_action'
 require 'action_tabler/mapper'
 require 'action_tabler/railtie' if defined?(Rails)
 
 module ActionTabler
-  def initialize_configuration(config)
-
-    # Check and set default column definitions
-    if config.respond_to?(:action_tabler_columns)
-      if config.action_tabler_columns.kind_of?(Array) || 
-         config.action_tabler_columns.kind_of?(Symbol) ||
-         config.action_tabler_columns.kind_of?(Proc)
-        AbstractController::Base.action_tabler_columns = config.action_tabler_columns
-      else
-        raise ArgumentError, "config.action_tabler_columns expected Symbol, Array, or Proc (got #{config.action_tabler_attributes.class.name})"
-      end
-    else
-      AbstractController::Base.action_tabler_columns = []
-    end
-   
-    # Set other configuration options
-    AbstractController::Base.action_tabler_columns = (config.respond_to?(:action_tabler_columns) ? config.action_tabler_columns : [])
-    AbstractController::Base.action_tabler_table_class = config.respond_to?(:action_tabler_table_class) ? config.action_tabler_table_class : nil
-    AbstractController::Base.action_tabler_auto_width = config.respond_to?(:action_tabler_auto_width) ? config.action_tabler_auto_width : true
-    AbstractController::Base.action_tabler_action = config.respond_to?(:action_tabler_action) ? config.action_tabler_action : "table"
-    AbstractController::Base.action_tabler_auto_type = config.respond_to?(:action_tabler_auto_type) ? config.action_tabler_auto_type : true
-    AbstractController::Base.action_tabler_pass_params = config.respond_to?(:action_tabler_pass_params) ? config.action_tabler_pass_params : false
-    AbstractController::Base.action_tabler_table_options = config.respond_to?(:action_tabler_table_options) ? config.action_tabler_table_options : {}    
-  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: action_tabler
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - lhalff
@@ -97,11 +97,14 @@ files:
 - app/views/action_tabler/_table_footer.html.erb
 - app/views/action_tabler/_table_header.html.erb
 - app/views/action_tabler/table.html.erb
-- lib/action_tabler/column_type_for.rb
+- lib/action_tabler/data_tables/data_handler.rb
+- lib/action_tabler/data_tables/display_handler.rb
+- lib/action_tabler/data_tables.rb
 - lib/action_tabler/has_table_action.rb
-- lib/action_tabler/jquery_datatables.rb
 - lib/action_tabler/mapper.rb
 - lib/action_tabler/railtie.rb
+- lib/action_tabler/table_handler.rb
+- lib/action_tabler/utilities.rb
 - lib/action_tabler/version.rb
 - lib/action_tabler.rb
 - lib/tasks/table_view_tasks.rake

data/lib/action_tabler/column_type_for.rb

@@ -1,19 +0,0 @@
-module ActionTabler
-  module ColumnTypeFor
-    extend ActiveSupport::Concern
-    
-    module ClassMethods
-      # Returns a display column type for an attribute using reflection.
-      def action_tabler_column_type_for(attribute, model)
-        attribute = attribute.to_s
-        attributes = attribute.split(".")
-        if attributes.length > 1
-          reflection = model.reflect_on_association(attributes[0].to_sym)
-          reflection.klass.action_tabler_column_type_for(attribute.gsub("#{attributes[0]}.", ""))
-        else
-          ActionTabler::JqueryDatatables.column_type_for(model.columns_hash[attribute].class)
-        end
-      end
-    end # ClassMethods
-  end # ActionTablerOptions  
-end # ActionTabler

data/lib/action_tabler/jquery_datatables.rb

@@ -1,16 +0,0 @@
-module ActionTabler
-	module JqueryDatatables
-		def self.column_type_for(col_type)
-			case col_type
-			when :datetime, :date, :time, :timestamp
-				"date"
-			when :integer, :float, :decimal, :binary
-				"numeric"
-			when :text
-				"html"
-			else
-				"string"
-			end
-		end
-	end
-end