action_tabler 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# ActionTabler
+
+ActionTabler provides a drop in table action for your Rails controllers using [DataTables](http://www.datatables.net/).
+
+## Installation
+
+1. Add to your Gemfile:
+
+        gem 'action_tabler'
+
+1. Install the gem:
+
+        bundle install
+
+1. Include the datatables javascript in application.js:
+
+        //= require action_tabler
+
+1. Include the datatables css in application.css
+
+         *= require action_tabler
+
+## Quickstart
+
+Once you've installed ActionTabler, you can add a fully functional table page to a resource.
+
+1. Define a table-enabled resourceful route for your controller:
+
+         resources_with_tables :your_thing
+
+1. Add a declaration to your_thing_controller.rb:
+
+         has_table_action :created_at, :title
+
+1. Start your server and navigate to "your_thing/table"
+
+## Configuration
+
+The following options can be configured with a Rails initializer:
+
+- `action_tabler_columns`: Array of column specifications. See complete documentation below. Default is nil.
+- `action_tabler_table_class`: Table html class. Default is nil.
+- `action_tabler_auto_width`: Datatables auto width setting. Default is true.
+- `action_tabler_action`: The controller action name for a table. Default is "table".
+- `action_tabler_auto_type`: Automatically populate datatables column types based on Rails column introspection. Default is true.
+- `action_tabler_pass_params`: Use request paramters associated with the table resource (eg. "[customers]last_name=Smith") to pre-filter the table data. Default is false, in a trade off of less magic for more security.
+- `action_tabler_table_options`: Additional DataTables table options, features and callbacks. See the has_table_action :table_options documentation below. Default is empty.
+
+All of these options can be overridden by the `has_table_action` or `action_tabler_options` declarations.
+
+## `has_table_action(columns, opts)`
+
+The `has_table_action` declaration will add a table display action to a controller.
+
+### columns
+
+The column parameter describes what will be displayed in your table.
+
+It is either an array or the symbol `:auto`.
+
+When :auto, ActionTabler will use reflection to display all of the resource's columns in the table it generates. Use of this option is strong discouraged, but can be used to just make somthing happen, even if it happens insecurely.
+
+An array will define a list of columns to display.
+
+A string or symbol in an array will add the corresponding model attribute or method using the default column options.
+
+You can customize a particular column's options by passing a hash. Each hash can or should have the values below (DataTables equivalents are given in parenthases):
+
+- `name`: The attribute name. This can be a relationship attribute. For example, if you have an order which belongs to a customer which has a name attribute, you can specify "customer.name". (`mDataProp` and `sName`) *Required.*
+- `label`: The table column heading for this attribute. Default is the attribute name will be titleized. (`sName`)
+- `searchable`: Include this column in search box calls. Default is true. (`bSearchable`)
+- `sortable`: Provide sort controls for this column. Default is true. (`bSortable`)
+
+Options not listed above will be passed through to DataTables, so that you can access options like `sClass`, `sWidth`, or `sVisible`. For the special handling of the sType column, see the `:auto_type` option below. For more on the special handling of DataTables `fn` or `m` options see the "Datatables fn and m Options" below.
+
+You can learn more about DataTable column options in the [DataTables Column Usage documentation](http://www.datatables.net/usage/columns).
+
+This parameter can either be passed as the first argument or as a block. For example:
+
+        has_table_action [:first_name, :last_name], :pass_params => true
+
+or
+
+        has_table_action(:pass_params => true) do
+          column :title
+          column :author,
+          column :created_at, :label => "Entered", :searchable => false
+        end
+
+### :action option
+
+Unless specified otherwise in your Rails configuration, ActionTabler assigns it's table display method to a method called "table." You can override this with the action option, with something like "index," for example.
+
+### :auto_type option
+
+Specify whether to populate your column definitions with DataTable's data types using Rails reflections. This will not override any sType speficications you manually configure. Default is true unless otherwise configured.
+
+### :pass_params option
+
+Specifies whether to use paramters associated with the table resource to pre-filter the table data.
+
+### :class_name option
+
+ActionTabler likes resourceful routes, so it will guess the model from the controller name. You can override this with the class_name option.
+
+### :table_class option
+
+This specifies the html class(es) for your table.
+
+### :table_options option
+
+You can specify a hash of additional DataTables options, features and callbacks. This will be added to or override your action_tabler_table_options configuration. See "Datatables fn and m Options" below for more on the special handling of DataTables `fn` or `m` options. Please note: you cannot override overriding such options as `bProcessing`, `bServerSide`, `sAjaxSource`, `aoColumnDefs`, or `fnServerParams` could have unintended consequences.
+
+See the DataTables web site for more about DataTables [Options](http://www.datatables.net/usage/options), [Features](http://www.datatables.net/usage/features), and [Callbacks](http://www.datatables.net/usage/callbacks).
+
+## Datatables `fn` and `m` Options
+
+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.
+- Proc: a Proc which will passed the current column definition hash.
+
+## Running Tests
+
+    $ bundle install
+    $ rspec spec
+
+## Credits
+
+Copyright (c) 2013 Larry Halff, released under the MIT license

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActionTabler'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/assets/javascripts/action_tabler.js

@@ -0,0 +1,2 @@
+//= require dataTables/jquery.dataTables
+//= require dataTables/jquery.dataTables.bootstrap

data/app/assets/stylesheets/action_tabler.css

@@ -0,0 +1 @@
+//= require dataTables/jquery.dataTables

data/app/assets/stylesheets/action_tabler_bootstrap.css

@@ -0,0 +1,2 @@
+//= require dataTables/jquery.dataTables
+//= require dataTables/jquery.dataTables.bootstrap

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

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

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

@@ -0,0 +1,20 @@
+<table cellpadding="0" cellspacing="0" border="0"<% if @table_class %> class="@table_class"<% end %> id="<%= @table_id %>">
+	<thead>
+		<tr>
+			<% for column in @table_columns do %>
+				<th><%= column[:label] %></th>
+			<% end %>
+		</tr>
+	</thead>
+	<tbody>
+		<tr>
+			<td colspan="5" class="dataTables_empty">Loading data from server</td>
+		</tr>
+	</tbody>
+</table>
+
+<script type="text/javascript" charset="utf-8">
+	$(document).ready(function() {
+		$('#<%= @table_id %>').dataTable( <%= render_datatables_table_definitions.html_safe %> ); 
+	} );
+</script>

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

@@ -0,0 +1,3 @@
+<%= render :partial => "action_tabler/table_header" %>
+<%= render :partial => "action_tabler/table" %>
+<%= render :partial => "action_tabler/table_footer" %>

data/lib/action_tabler/column_type_for.rb

@@ -0,0 +1,19 @@
+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/has_table_action.rb

@@ -0,0 +1,334 @@
+module ActionTabler
+  module HasTableAction
+    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 
+    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] || {})
+
+        include DeclaredInstanceMethods
+
+        # Define the table action method
+        define_method(action_tabler_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
+      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}
+        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?(".")
+          # Discover relation model name
+          reflection = model.reflect_on_association(name.split(".")[0].to_sym)
+          # Recurse with realtion model and name
+          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/jquery_datatables.rb

@@ -0,0 +1,16 @@
+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

data/lib/action_tabler/mapper.rb

@@ -0,0 +1,21 @@
+module ActionTabler
+  module Routing
+    module Mapper
+
+      # Add a routing mapper for a list of resourceful controllers with tables
+      def resources_with_tables *args
+        resources *args do
+          get 'table', :on => :collection
+        end
+      end
+
+      # Add a routing mapper for a single resourceful controller with tables
+      def resource_with_tables *args
+        resource *args do
+          get 'table', :on => :collection
+        end
+
+      end
+    end
+  end
+end

data/lib/action_tabler/railtie.rb

@@ -0,0 +1,43 @@
+module ActionTabler
+	class Engine < ::Rails::Engine
+  end
+
+  class ActionTablerRailtie < Rails::Railtie
+    railtie_name :action_tabler
+    
+    initializer "action_tabler" do
+      AbstractController::Base.send :include, ActionTabler::HasTableAction
+      ActionDispatch::Routing::Mapper.send :include, ActionTabler::Routing::Mapper
+    end
+
+    config.to_prepare do
+      ActionTablerRailtie.initialize_configuration(Rails.configuration)
+    end
+
+    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
+end

data/lib/action_tabler/version.rb

@@ -0,0 +1,3 @@
+module ActionTabler
+  VERSION = "0.1"
+end

data/lib/action_tabler.rb

@@ -0,0 +1,31 @@
+require 'action_tabler/jquery_datatables'
+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

data/lib/tasks/table_view_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :table_view do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: action_tabler
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- lhalff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-06-05 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 3
+        - 2
+        - 13
+        version: 3.2.13
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jquery-datatables-rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 1
+        - 11
+        - 2
+        version: 1.11.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec-rails
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 2
+        - 13
+        - 1
+        version: 2.13.1
+  type: :development
+  version_requirements: *id004
+description: A drop in table action for your Rails controllers using DataTables.
+email: 
+- email@larryhalff.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- app/assets/javascripts/action_tabler.js
+- app/assets/stylesheets/action_tabler.css
+- app/assets/stylesheets/action_tabler_bootstrap.css
+- app/views/action_tabler/_comma_spacer.html.erb
+- app/views/action_tabler/_table.html.erb
+- 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/has_table_action.rb
+- lib/action_tabler/jquery_datatables.rb
+- lib/action_tabler/mapper.rb
+- lib/action_tabler/railtie.rb
+- lib/action_tabler/version.rb
+- lib/action_tabler.rb
+- lib/tasks/table_view_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: https://github.com/lhalff/action_tabler
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: has_table_index mixin for ActionController
+test_files: []
+