ajax-datatables-rails 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41e30fdcf9f0f29415c014aee01b74328f2faf2c
-  data.tar.gz: 3d58fa14346fbc70152eaa3851755e53cc6dc751
+  metadata.gz: 4dd7a0250f12d3ba425ebbadceec912cd9b5c8e3
+  data.tar.gz: 0f70205e103b95e91970f1a29c9da2149b52b9d2
 SHA512:
-  metadata.gz: a8673b396a04b6cc7fdf3412f5602d3753d072a53bf6c293b96a0a9e82f61981a443f9a820627f8d126d2c2f989037f463931185e09318e9ef22193c084a55c0
-  data.tar.gz: 217019709cb55ca0a495c81632b507a81f868cf7bbd115a73b6c635ab0b69b8f5838cc2b0343524f8c18ac963e671e5ef861512c68cd2dace7f5ee42038f2dd3
+  metadata.gz: 7b88ac6e283edd40600632948dc002a7d4361052dc611a0b87997145fb100c92e15652f2a10c7f0fb0c8d76708a78bd3df407f8d822e321b2a7c35171b195f9f
+  data.tar.gz: 442c3da29cddba54dc636b7ce2b325f5a0ef504b12b1994cb9150ce044ba2c8e40360b18b462ab5e5de9300ee57ef7d36aa0ae2ac53714ed7377461bcb125abd

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 0.2.1
+* Fix count method to work with select statements under Rails 4.1. Thanks to [Jason Mitchell](https://github.com/mitchej123) for the contribution.
+* Edits to `README` documentation about the `options` hash. Thanks to [Jonathan E Hogue](https://github.com/hoguej) for pointing out that previous documentation was confusing and didn't address its usage properly.
+* Edits to `README` documentation on complex model queries inside the `get_raw_records` method. A round of applause to [Zoltan Paulovics](https://github.com/zpaulovics) for contributing this awesome piece of documentation. :smile:
+* Adds typecast step to `search_condition` method, so now we support having non-text columns inside the `searchable_columns` array.
+* Adds support for multi-column sorting and multi-term search. Thanks to [Zoltan Paulovics](https://github.com/zpaulovics) for contributing this feature.
+* Adds optional config initializer, so we can have a base to typecast non text-based columns and perform searches depending on the use of `:mysql2`, `:sqlite3` or `:pg`. Thanks to [M. Saiqul Haq](https://github.com/saiqulhaq) for contributing this feature.
+
 ## 0.2.0
 * This version works with jQuery dataTables ver. 1.10 and it's new API syntax.
 * Added `legacy` branch to repo. If your project is working with jQuery
@@ -12,7 +20,7 @@
 
 ## 0.1.1
 * Fixes problem on `searchable_columns` where the corresponding model is
-a composite model name, e.g. `UserData`, `BillingAddress`. 
+a composite model name, e.g. `UserData`, `BillingAddress`.
 Thanks to [iruca3](https://github.com/iruca3) for the fix.
 
 ## 0.1.0
@@ -25,8 +33,8 @@ Thanks to [iruca3](https://github.com/iruca3) for the fix.
 * Removes dependency to pass in a model name to the generator. This way,
   the developer has more flexibility to implement whatever datatable feature is required.
 * Datatable constructor accepts an optional `options` hash to provide
-  more flexibility. 
+  more flexibility.
   See [README](https://github.com/antillas21/ajax-datatables-rails/blob/master/README.mds#options) for examples.
 * Sets generator inside the `Rails` namespace. To generate an
   `AjaxDatatablesRails` child class, just execute the
-  generator like this: `$ rails generate datatable NAME`.
+  generator like this: `$ rails generate datatable NAME`.

data/README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://travis-ci.org/antillas21/ajax-datatables-rails.svg?branch=master)](https://travis-ci.org/antillas21/ajax-datatables-rails)
 [![Gem Version](https://badge.fury.io/rb/ajax-datatables-rails.svg)](http://badge.fury.io/rb/ajax-datatables-rails)
+[![Code Climate](https://codeclimate.com/github/antillas21/ajax-datatables-rails/badges/gpa.svg)](https://codeclimate.com/github/antillas21/ajax-datatables-rails)
 
 ### Versions
 
@@ -37,7 +38,7 @@ Adding support for `Sequel`, `Mongoid` and `MongoMapper` is a planned feature fo
 
 Add these lines to your application's Gemfile:
 
-    gem 'jquery-datatables-rails', git: 'git://github.com/rweng/jquery-datatables-rails.git', branch: 'master'
+    gem 'jquery-datatables-rails'
     gem 'ajax-datatables-rails'
 
 And then execute:
@@ -49,7 +50,8 @@ jQuery dataTables to your Rails project. You can always add the plugin assets
 manually via the assets pipeline. If you decide to use the `jquery-datatables-rails` gem, please refer to its installation instructions [here](https://github.com/rweng/jquery-datatables-rails).
 
 ## Usage
-*The following examples assume that we are setting up rails-datatables for an index of users from a `User` model*
+*The following examples assume that we are setting up ajax-datatables-rails for an index of users from a `User` model, and that we are using postgresql as
+our db, because you __should be using it__, if not, please refer to the [Searching on non text-based columns](#searching-on-non-text-based-columns) entry in the Additional Notes section.*
 
 ### Generate
 Run the following command:
@@ -91,6 +93,7 @@ the gems bundled in your project. For example, if your models are using `Kaminar
 * For `searchable_columns`, assign an array of the database columns that you want searchable by datatables. For example `[users.f_name, users.l_name]`
 
 This gives us:
+
 ```ruby
 include AjaxDatatablesRails::Extensions::Kaminari
 
@@ -101,9 +104,10 @@ end
 def searchable_columns
   @searchable_columns ||= ['users.f_name', 'users.l_name']
 end
-
 ```
 
+[See here](#searching-on-non-text-based-columns) for notes regarding database config (if using something different from `postgre`).
+
 ### Map data
 ```ruby
 def data
@@ -148,6 +152,83 @@ end
 ```
 
 Obviously, you can construct your query as required for the use case the datatable is used. Example: `User.active.with_recent_messages`.
+__IMPORTANT:__ Make sure to return an `ActiveRecord::Relation` object as the end product of this method. Why? Because the result from
+this method, will be chained (for now) to `ActiveRecord` methods for sorting, filtering and pagination.
+
+#### Associated and nested models
+The previous example has only one single model. But what about if you have some associated nested models and in a report you want to show fields from these tables.
+
+Take an example that has an `Event, Course, Coursetype, Allocation, Teacher, Contact, Competency and CompetencyType` models. We want to have a datatables report which has the following column:
+```ruby
+        'coursetypes.name',
+        'courses.name',
+        'events.title',
+        'events.event_start',
+        'events.event_end',
+        'contacts.full_name',
+        'competency_types.name',
+        'events.status'
+```
+We want to sort and search on all columns of the list. The related definition would be:
+```ruby
+
+  def sortable_columns
+    @sortable_columns ||= [
+        'coursetypes.name',
+        'courses.name',
+        'events.title',
+        'events.event_start',
+        'events.event_end',
+        'contacts.last_name',
+        'competency_types.name',
+        'events.status'
+    ]
+  end
+
+  def searchable_columns
+    @searchable_columns ||= [
+        'coursetypes.name',
+        'courses.name',
+        'events.title',
+        'events.event_start',
+        'events.event_end',
+        'contacts.last_name',
+        'competency_types.name',
+        'events.status'
+    ]
+  end
+
+  def get_raw_records
+     Event.joins(
+      { course: :coursetype },
+      { allocations: {
+          teacher: [:contact, {competencies: :competency_type}]
+        }
+      }).distinct
+  end
+```
+
+__Some comments for the above code:__
+
+1. In the list we show `full_name`, but in `sortable_columns` and `searchable_columns` we use `last_name` from the `Contact` model. The reason is we can use only database columns as sort or search fields and the full_name is not a database field.
+
+2. In the `get_raw_records` method we have quite a complex query having one to many and may to many associations using the joins ActiveRecord method. The joins will generate INNER JOIN relations in the SQL query. In this case we do not include all event in the report if we have events which is not associated with any model record from the relation.
+
+3. To have all event records in the list we should use the `.includes` method, which generate LEFT OUTER JOIN relation of the SQL query. __IMPORTANT:__ Make sure to append `.references(:related_model)` with any associated model. That forces the eager loading of all the associated models by one SQL query, and the search condition for any column works fine. Otherwise the `:recordsFiltered => filter_records(get_raw_records).count(:all)` will generate 2 SQL queries (one for the Event model, and then another for the associated tables). The `:recordsFiltered => filter_records(get_raw_records).count(:all)` will use only the first one to return from the ActiveRecord::Relation object in `get_raw_records` and you will get an error message of __Unknown column 'yourtable.yourfield' in 'where clause'__ in case the search field value is not empty.
+
+So the query using the `.includes()` method is:
+
+```ruby
+  def get_raw_records
+     Event.includes(
+      { course: :coursetype },
+      { allocations: {
+          teacher: [:contact, { competencies: :competency_type }]
+        }
+      }
+      ).references(:course).distinct
+  end
+```
 
 ### Controller
 Set up the controller to respond to JSON
@@ -208,7 +289,7 @@ jQuery(document).ready(function() {
   $('#users-table').dataTable({
     "processing": true,
     "serverSide": true,
-    "ajax": $('#users-table').data('source')
+    "ajax": $('#users-table').data('source'),
     "pagingType": "full_numbers",
     // optional, if you want full pagination controls.
     // Check dataTables documentation to learn more about
@@ -219,9 +300,43 @@ jQuery(document).ready(function() {
 
 ### Additional Notes
 
+#### Searching on non text-based columns
+
+It always comes the time when you need to add a non-string/non-text based column to the `@searchable_columns` array, so you can perform searches against these column types (example: numeric, date, time).
+
+We recently added the ability to (automatically) typecast these column types and have this scenario covered. Please note however, if you are using something different from `postgre` (with the `:pg` gem), like `mysql` or `sqlite`, then you need to add an initializer in your application's `config/initializers` directory.
+
+If you don't perform this step (again, if using something different from `postgre`), your database will complain that it does not understand the default typecast used to enable such searches.
+
+You have two options to create this initializer:
+
+* use the provided (and recommended) generator (and then just edit the file);
+* create the file from scratch.
+
+To use the generator, from the terminal execute:
+
+```
+$ bundle exec rails generate datatable:config
+```
+
+Doing so, will create the `config/initializers/ajax_datatables_rails.rb` file with the following content:
+
+```ruby
+AjaxDatatablesRails.configure do |config|
+  # available options for db_adapter are: :pg, :mysql2, :sqlite3
+  # config.db_adapter = :pg
+end
+```
+
+Uncomment the `config.db_adapter` line and set the corresponding value to your
+database and gem. This is all you need.
+
+If you want to make the file from scratch, just copy the above code block into a file inside the `config/initializers` directory.
+
+
 #### Using view helpers
 
-Sometimes you'll need to use view helper methods like `link_to`, `h`, `mailto`, `edit_resource_path` in the returned JSON representation returned by the `data` method. 
+Sometimes you'll need to use view helper methods like `link_to`, `h`, `mailto`, `edit_resource_path` in the returned JSON representation returned by the `data` method.
 
 To have these methods available to be used, this is the way to go:
 
@@ -231,10 +346,10 @@ class MyCustomDatatable < AjaxDatatablesRails::Base
   def_delegator :@view, :link_to
   def_delegator :@view, :h
   def_delegator :@view, :mail_to
-  
+
   # or define them in one pass
   def_delegators :@view, :link_to, :h, :mailto, :edit_resource_path, :other_method
-  
+
   # now, you'll have these methods available to be used anywhere
   # example: mapping the 2d jsonified array returned.
   def data
@@ -261,9 +376,23 @@ end
 datatable = UnrespondedMessagesDatatable.new(view_context,
   { :foo => { :bar => Baz.new }, :from => 1.month.ago }
 )
+```
+So, now inside your class code, you can use those options like this:
+
+
+```ruby
+# let's see an example
+def from
+  @from ||= options[:from].beginning_of_day
+end
+
+def to
+  @to ||= Date.today.end_of_day
+end
 
-datatable.options
-#=> { :foo => { :bar => #<Baz:0x007fe9cb4e0220> }, :from => 2014-04-16 19:55:28 -0700 }
+def get_raw_records
+  Message.unresponded.where(received_at: from..to)
+end
 ```
 
 #### Generator Syntax
@@ -285,6 +414,16 @@ $ rails generate datatable UnrespondedMessages
 
 In the end, it's up to the developer which model(s), scope(s), relationship(s) (or else) to employ inside the datatable class to retrieve records from the database.
 
+## Tutorial
+
+Tutorial for Integrating `ajax-datatable-rails`, on  Rails 4 .
+
+[Part-1  The-Installation](https://github.com/antillas21/ajax-datatables-rails/wiki/Part-1----The-Installation)
+
+[Part 2 The Datatables with ajax functionality](https://github.com/antillas21/ajax-datatables-rails/wiki/Part-2-The-Datatables-with-ajax-functionality)
+
+The complete project code for this tutorial series is available on [github](https://github.com/trkrameshkumar/simple_app).
+
 
 ## Contributing
 

data/lib/ajax-datatables-rails.rb

@@ -1,8 +1,9 @@
 require 'ajax-datatables-rails/version'
+require 'ajax-datatables-rails/config'
 require 'ajax-datatables-rails/base'
 require 'ajax-datatables-rails/extensions/simple_paginator'
 require 'ajax-datatables-rails/extensions/kaminari'
 require 'ajax-datatables-rails/extensions/will_paginate'
 
 module AjaxDatatablesRails
-end
+end

data/lib/ajax-datatables-rails/base.rb

@@ -11,6 +11,10 @@ module AjaxDatatablesRails
       @options = options
     end
 
+    def config
+      @config ||= AjaxDatatablesRails.config
+    end
+
     def sortable_columns
       @sortable_columns ||= []
     end
@@ -36,8 +40,8 @@ module AjaxDatatablesRails
     def as_json(options = {})
       {
         :draw => params[:draw].to_i,
-        :recordsTotal =>  get_raw_records.count,
-        :recordsFiltered => filter_records(get_raw_records).count,
+        :recordsTotal =>  get_raw_records.count(:all),
+        :recordsFiltered => filter_records(get_raw_records).count(:all),
         :data => data
       }
     end
@@ -52,12 +56,16 @@ module AjaxDatatablesRails
       records = get_raw_records
       records = sort_records(records)
       records = filter_records(records)
-      records = paginate_records(records)
+      records = paginate_records(records) unless params[:length] == '-1'
       records
     end
 
     def sort_records(records)
-      records.order("#{sort_column} #{sort_direction}")
+      sort_by = []
+      params[:order].each_value do |item|
+        sort_by << "#{sort_column(item)} #{sort_direction(item)}"
+      end
+      records.order(sort_by.join(", "))
     end
 
     def paginate_records(records)
@@ -74,7 +82,7 @@ module AjaxDatatablesRails
     end
 
     def simple_search(records)
-      return records unless (params[:search] && params[:search][:value])
+      return records unless (params[:search].present? && params[:search][:value].present?)
       conditions = build_conditions_for(params[:search][:value])
       records = records.where(conditions) if conditions
       records
@@ -87,23 +95,37 @@ module AjaxDatatablesRails
     end
 
     def build_conditions_for(query)
-      searchable_columns.map { |col| search_condition(col, query) }.reduce(:or)
+      search_for = query.split(' ')
+      criteria = search_for.inject([]) do |criteria, atom|
+        criteria << searchable_columns.map { |col| search_condition(col, atom) }.reduce(:or)
+      end.reduce(:and)
+      criteria
     end
 
     def search_condition(column, value)
       model, column = column.split('.')
       model = model.singularize.titleize.gsub( / /, '' ).constantize
-      model.arel_table[column.to_sym].matches("%#{value}%")
+
+      casted_column = ::Arel::Nodes::NamedFunction.new('CAST', [model.arel_table[column.to_sym].as(typecast)])
+      casted_column.matches("%#{value}%")
     end
 
     def aggregate_query
       conditions = searchable_columns.each_with_index.map do |column, index|
-        value = params[:columns]["#{index}"][:search][:value]
+        value = params[:columns]["#{index}"][:search][:value] if params[:columns]
         search_condition(column, value) unless value.blank?
       end
       conditions.compact.reduce(:and)
     end
 
+    def typecast
+      case config.db_adapter
+      when :pg then 'VARCHAR'
+      when :mysql2 then 'CHAR'
+      when :sqlite3 then 'TEXT'
+      end
+    end
+
     def offset
       (page - 1) * per_page
     end
@@ -116,13 +138,13 @@ module AjaxDatatablesRails
       params.fetch(:length, 10).to_i
     end
 
-    def sort_column
-      sortable_columns[params[:order]['0'][:column].to_i]
+    def sort_column(item)
+      sortable_columns[item['column'].to_i]
     end
 
-    def sort_direction
+    def sort_direction(item)
       options = %w(desc asc)
-      options.include?(params[:order]['0'][:dir]) ? params[:order]['0'][:dir].upcase : 'ASC'
+      options.include?(item['dir']) ? item['dir'].upcase : 'ASC'
     end
   end
 end

data/lib/ajax-datatables-rails/config.rb

@@ -0,0 +1,24 @@
+require 'active_support/configurable'
+
+module AjaxDatatablesRails
+
+  # configure AjaxDatatablesRails global settings
+  #   AjaxDatatablesRails.configure do |config|
+  #     config.db_adapter = :pg
+  #   end
+  def self.configure &block
+    yield @config ||= AjaxDatatablesRails::Configuration.new
+  end
+
+  # AjaxDatatablesRails global settings
+  def self.config
+    @config ||= AjaxDatatablesRails::Configuration.new
+  end
+
+  class Configuration
+    include ActiveSupport::Configurable
+
+    # default db_adapter is pg (postgresql)
+    config_accessor(:db_adapter) { :pg }
+  end
+end

data/lib/ajax-datatables-rails/version.rb

@@ -1,3 +1,3 @@
 module AjaxDatatablesRails
-  VERSION = '0.2.0'
-end
+  VERSION = '0.2.1'
+end

data/lib/generators/datatable/config_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+
+module Datatable
+  module Generators
+    class ConfigGenerator < ::Rails::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      desc <<DESC
+Description:
+  Creates an initializer file for AjaxDatatablesRails configuration at config/initializers.
+DESC
+
+      def copy_config_file
+        template 'ajax_datatables_rails_config.rb', 'config/initializers/ajax_datatables_rails.rb'
+      end
+    end
+  end
+end

data/lib/generators/datatable/templates/ajax_datatables_rails_config.rb

@@ -0,0 +1,4 @@
+AjaxDatatablesRails.configure do |config|
+  # available options for db_adapter are: :pg, :mysql2, :sqlite3
+  # config.db_adapter = :pg
+end

data/spec/ajax-datatables-rails/ajax_datatables_rails_spec.rb

@@ -221,3 +221,81 @@ describe AjaxDatatablesRails::Base do
     end
   end
 end
+
+
+describe AjaxDatatablesRails::Configuration do
+  let(:config) { AjaxDatatablesRails::Configuration.new }
+
+  describe "default config" do
+    it "default db_adapter should :pg (postgresql)" do
+      expect(config.db_adapter).to eq(:pg)
+    end
+  end
+
+  describe "custom config" do
+    it 'should accept db_adapter custom value' do
+      config.db_adapter = :mysql2
+      expect(config.db_adapter).to eq(:mysql2)
+    end
+  end
+
+  describe '#typecast' do
+    params = {
+      :draw => '5',
+      :columns => {
+        "0" => {
+          :data => '0',
+          :name => '',
+          :searchable => true,
+          :orderable => true,
+          :search => { :value => '', :regex => false }
+        },
+        "1" => {
+          :data => '1',
+          :name => '',
+          :searchable => true,
+          :orderable => true,
+          :search => { :value => '', :regex => false }
+        }
+      },
+      :order => { "0" => { :column => '1', :dir => 'desc' } },
+      :start => '0',
+      :length => '10',
+      :search => { :value => '', :regex => false },
+      '_' => '1403141483098'
+    }
+    let(:view) { double('view', :params => params) }
+    let(:datatable) { AjaxDatatablesRails::Base.new(view) }
+
+    it 'returns VARCHAR if :db_adapter is :pg' do
+      expect(datatable.send(:typecast)).to eq('VARCHAR')
+    end
+
+    it 'returns CHAR if :db_adapter is :mysql2' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql2 }
+      expect(datatable.send(:typecast)).to eq('CHAR')
+    end
+
+    it 'returns TEXT if :db_adapter is :sqlite3' do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite3 }
+      expect(datatable.send(:typecast)).to eq('TEXT')
+    end
+  end
+end
+
+describe AjaxDatatablesRails do
+  describe "configurations" do
+    context "configurable from outside" do
+      before(:each) do
+        AjaxDatatablesRails.configure do |config|
+          config.db_adapter = :mysql2
+        end
+      end
+
+      it "should have custom value" do
+        expect(AjaxDatatablesRails.config.db_adapter).to eq(:mysql2)
+      end
+    end
+
+  end
+end

metadata

@@ -1,97 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: ajax-datatables-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Joel Quenneville
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-19 00:00:00.000000000 Z
+date: 2014-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: generator_spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
 description: A gem that simplifies using datatables and hundreds of records via ajax
@@ -101,12 +101,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/ajax-datatables-rails.rb
 - lib/ajax-datatables-rails/base.rb
+- lib/ajax-datatables-rails/config.rb
 - lib/ajax-datatables-rails/extensions/kaminari.rb
 - lib/ajax-datatables-rails/extensions/simple_paginator.rb
 - lib/ajax-datatables-rails/extensions/will_paginate.rb
 - lib/ajax-datatables-rails/version.rb
-- lib/ajax-datatables-rails.rb
+- lib/generators/datatable/config_generator.rb
+- lib/generators/datatable/templates/ajax_datatables_rails_config.rb
 - lib/generators/rails/datatable_generator.rb
 - lib/generators/rails/templates/datatable.rb
 - spec/ajax-datatables-rails/ajax_datatables_rails_spec.rb
@@ -114,11 +122,6 @@ files:
 - spec/ajax-datatables-rails/simple_paginator_spec.rb
 - spec/ajax-datatables-rails/will_paginate_spec.rb
 - spec/spec_helper.rb
-- CHANGELOG.md
-- Gemfile
-- LICENSE
-- Rakefile
-- README.md
 homepage: ''
 licenses: []
 metadata: {}
@@ -128,17 +131,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A wrapper around datatable's ajax methods that allow synchronization with