ajax-datatables-rails 0.0.1 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07fee37ffeee9afc526dfe9f6e3bc348fa7a0025
+  data.tar.gz: 775fc632420c285f59e0f44e7ccb09d3b6b9e63d
+SHA512:
+  metadata.gz: c3a210c5d90332b96b23a36ce135254c382929332fb7cc0a84b0097aadcd5504d55b56cbd37d28c829cd13c8670da35c5d497635495e2c708afa4ad8b52de322
+  data.tar.gz: 7c31ff0b9f69466d788a68db525c13fe208ef59c06e16b13f06abe5de32d5484a3e0d94fbe8534d09932e759a8f4d0d77b035b6e78206cd827ff1c32a0a8ec34

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# CHANGELOG
+
+## 0.1.0
+* A fresh start. Sets base class name to: `AjaxDatatablesRails::Base`.
+* Extracts pagination functions to mixable modules.
+  * A user would have the option to stick to the base
+    `AjaxDatatablesRails::Extensions::SimplePaginator` or replace it with
+    `AjaxDatatablesRails::Extensions::Kaminari` or
+    `AjaxDatatablesRails::Extensions::WillPaginate`, depending on what he/she is using to handle record pagination.
+* 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. 
+  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`.

data/README.md

@@ -1,60 +1,105 @@
 # ajax-datatables-rails
 
+[![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)
+
+### Under new management
+
+> Hi,
+>
+> New maintainer here. Just to let you know that we have
+> released version 0.1.0 which includes breaking changes.
+>
+> Please check the [CHANGELOG](https://github.com/antillas21/ajax-datatables-rails/blob/master/CHANGELOG.md) to learn about these changes.
+>
+> All changes have been documented below.
+
+
 Datatables is a nifty jquery plugin that adds the ability to paginate, sort, and search your html tables. When dealing with large tables (more than a couple hundred rows) however, we run into performance issues. These can be fixed by using server-side pagination, but this breaks some datatables functionality.
 
-`ajax-datatables-rails` is a wrapper around datatable's ajax methods that allow synchronization with server-side pagination in a rails app. 
+`ajax-datatables-rails` is a wrapper around datatable's ajax methods that allow synchronization with server-side pagination in a rails app. It was inspired by this [Railscast](http://railscasts.com/episodes/340-datatables). I needed to implement a similar solution in a couple projects I was working on so I extracted it out into a gem.
+
+## ORM support
+
+Currently `AjaxDatatablesRails` only supports `ActiveRecord` as ORM for performing database queries.
+
+Adding support for `Sequel`, `Mongoid` and `MongoMapper` is a planned feature for this gem. If you'd be interested in contributing to speed development, please [open an issue](https://github.com/antillas21/ajax-datatables-rails/issues/new) and get in touch.
 
 ## Installation
 
 Add these lines to your application's Gemfile:
 
     gem 'jquery-datatables-rails'
-    gem 'ajax-datatables-rails'
+    gem 'rails-datatables'
 
 And then execute:
 
     $ bundle
 
 ## Usage
-*The following examples assume that we are setting up ajax-datatables-rails for an index of users from a `User` model*
-### Model
+*The following examples assume that we are setting up rails-datatables for an index of users from a `User` model*
+
+### Generate
 Run the following command:
 
-    $ rails generate ajaxdatatable User
+    $ rails generate datatable User
+
 
-This will generate a file named `users_datatable.rb` in `app/datatables`. Open the file and customize in the functions as directed by the comments
+This will generate a file named `user_datatable.rb` in `app/datatables`. Open the file and customize in the functions as directed by the comments.
 
-#### Initializer
+Take a look [here](#generator-syntax) for an explanation about the generator syntax.
+
+### Customize
 ```ruby
-def initialize(view)
-  @model_name = User
-  @columns = # insert array of column names here
-  @searchable_columns = #insert array of columns that will be searched
-  super(view)
+# uncomment the appropriate paginator module,
+# depending on gems available in your project.
+# include AjaxDatatablesRails::Extensions::Kaminari
+# include AjaxDatatablesRails::Extensions::WillPaginate
+# include AjaxDatatablesRails::Extensions::SimplePaginator
+
+def sortable_columns
+  # list columns inside the Array in string dot notation.
+  # Example: 'users.email'
+  @sortable_columns ||= []
+end
+
+def searchable_columns
+  # list columns inside the Array in string dot notation.
+  # Example: 'users.email'
+  @searchable_columns ||= []
 end
 ```
 
-* For `@columns`, assign an array of the database columns that correspond to the columns in our view table. For example `[users.f_name, users.l_name, users.bio]`. This array is used for sorting by various columns
+* For `paginator options`, just uncomment the paginator you would like to use, given
+the gems bundled in your project. For example, if your models are using `Kaminari`, uncomment `AjaxDatatablesRails::Extensions::Kaminari`. You may remove all commented lines.
+  * `SimplePaginator` is the most basic of them all, it falls back to passing `offset` and `limit` at the database level (through `ActiveRecord` of course, as that is the only ORM supported for the time being).
+
+* For `sortable_columns`, assign an array of the database columns that correspond to the columns in our view table. For example `[users.f_name, users.l_name, users.bio]`. This array is used for sorting by various columns.
 
-* For `@searchable_columns`, assign an array of the database columns that you want searchable by datatables. For example `[users.f_name, users.l_name]`
+* 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: 
+This gives us:
 ```ruby
-def initialize(view)
-  @model_name = User
-  @columns = [users.f_name, users.l_name, users.bio]
-  @searchable_columns = [users.f_name, users.l_name]
-  super(view)
+include AjaxDatatablesRails::Extensions::Kaminari
+
+def sortable_columns
+  @sortable_columns ||= ['users.f_name', 'users.l_name', 'users.bio']
+end
+
+def searchable_columns
+  @searchable_columns ||= ['users.f_name', 'users.l_name']
 end
+
 ```
 
-#### Data
+### Map data
 ```ruby
 def data
-  users.map do |user|
+  records.map do |record|
     [
-      # comma separated list of the values for each cell of a table row
-    ]
+        # comma separated list of the values for each cell of a table row
+        # example: record.attribute,
+      ]
   end
 end
 ```
@@ -63,11 +108,11 @@ This method builds a 2d array that is used by datatables to construct the html t
 
 ```ruby
 def data
-  users.map do |user|
+  records.map do |record|
     [
-      user.f_name,
-      user.l_name,
-      user.bio
+      record.f_name,
+      record.l_name,
+      record.bio
     ]
   end
 end
@@ -88,6 +133,8 @@ def get_raw_records
 end
 ```
 
+Obviously, you can construct your query as required for the use case the datatable is used. Example: `User.active.with_recent_messages`.
+
 ### Controller
 Set up the controller to respond to JSON
 
@@ -95,11 +142,13 @@ Set up the controller to respond to JSON
 def index
   respond_to do |format|
     format.html
-    format.json { render json: UsersDatatable.new(view_context) }
+    format.json { render json: UserDatatable.new(view_context) }
   end
 end
 ```
 
+Don't forget to make sure the proper route has been added to `config/routes.rb`.
+
 ### View
 * Set up an html `<table>` with a `<thead>` and `<tbody>`
 * Add in your table headers if desired
@@ -109,7 +158,7 @@ end
 The resulting view may look like this:
 
 ```erb
-<table id="user-table", data-source="<%= users_path(format: :json) %>">
+<table id="users-table", data-source="<%= users_path(format: :json) %>">
   <thead>
     <tr>
       <th>First Name</th>
@@ -131,8 +180,68 @@ $ ->
     bProcessing: true
     bServerSide: true
     sAjaxSource: $('#users-table').data('source')
+    sPaginationType: 'full_numbers'
+    # optional, if you want full pagination controls.
+    # Check dataTables documentation to learn more about
+    # available options.
+```
+
+or, if you're using plain javascript:
+```javascript
+// users.js
+
+jQuery(document).ready(function() {
+  $('#users-table').dataTable({
+    'bProcessing': true,
+    'bServerSide': true,
+    'sAjaxSource': $('#users-table').data('source'),
+    'sPaginationType': 'full_numbers',
+    // optional, if you want full pagination controls.
+    // Check dataTables documentation to learn more about
+    // available options.
+  });
+});
 ```
 
+### Additional Notes
+
+#### Options
+
+An `AjaxDatatablesRails::Base` inherited class can accept an options hash at initialization. This provides room for flexibility when required. Example:
+
+```ruby
+class UnrespondedMessagesDatatable < AjaxDatatablesRails::Base
+  # customized methods here
+end
+
+datatable = UnrespondedMessagesDatatable.new(view_context,
+  { :foo => { :bar => Baz.new }, :from => 1.month.ago }
+)
+
+datatable.options
+#=> { :foo => { :bar => #<Baz:0x007fe9cb4e0220> }, :from => 2014-04-16 19:55:28 -0700 }
+```
+
+#### Generator Syntax
+
+Also, a class that inherits from `AjaxDatatablesRails::Base` is not tied to an existing model, module, constant or any type of class in your Rails app. You can pass a name to your datatable class like this:
+
+
+```
+$ rails generate datatable users
+# returns a users_datatable.rb file with a UsersDatatable class
+
+$ rails generate datatable contact_messages
+# returns a contact_messages_datatable.rb file with a ContactMessagesDatatable class
+
+$ rails generate datatable UnrespondedMessages
+# returns an unresponded_messages_datatable.rb file with an UnrespondedMessagesDatatable class
+```
+
+
+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.
+
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1,6 +1,14 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
-task default: :spec
+task :default => :spec
+
+task :console do
+  require 'pry'
+  require 'rails'
+  require 'ajax-datatables-rails'
+  ARGV.clear
+  Pry.start
+end

data/lib/ajax-datatables-rails.rb

@@ -1,79 +1,8 @@
-# require 'rails'
-
-class AjaxDatatablesRails
-  
-  class MethodError < StandardError; end
-
-  VERSION = '0.0.1'
-    
-  attr_reader :columns, :model_name, :searchable_columns
-
-  def initialize(view)
-    @view = view
-  end
-
-  def method_missing(meth, *args, &block)
-    @view.send(meth, *args, &block)
-  end
-
-  def as_json(options = {})
-    {
-      sEcho: params[:sEcho].to_i,
-      iTotalRecords: @model_name.count,
-      iTotalDisplayRecords: filtered_record_count,
-      aaData: data
-    }
-  end
-
-private
-
-  def data
-    raise MethodError, "The method `data' is not defined."
-  end
-
-  def get_raw_records
-    raise MethodError, "The method `get_raw_records' is not defined."
-  end
-
-  def filtered_record_count
-    search_records(get_raw_records).count
-  end
-  
-  def fetch_records
-    search_records(sort_records(paginate_records(get_raw_records)))
-  end
-
-  def paginate_records(records)
-    records.offset((page - 1) * per_page).limit(per_page)
-  end
-
-  def sort_records(records)
-    records.order("#{sort_column} #{sort_direction}")
-  end
-
-  def search_records(records)
-    if params[:sSearch].present?
-      query = @searchable_columns.map do |column|
-        "#{column} LIKE :search"
-      end.join(" OR ")
-      records = records.where(query, search: "%#{params[:sSearch]}%")
-    end
-    return records
-  end
-
-  def page
-    params[:iDisplayStart].to_i/per_page + 1
-  end
-
-  def per_page
-    params[:iDisplayLength].to_i > 0 ? params[:iDisplayLength].to_i : 10
-  end
-
-  def sort_column
-    @columns[params[:iSortCol_0].to_i]
-  end
-
-  def sort_direction
-    params[:sSortDir_0] == "desc" ? "DESC" : "ASC"
-  end
-end
+require 'ajax-datatables-rails/version'
+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

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

@@ -0,0 +1,128 @@
+module AjaxDatatablesRails
+  class Base
+    extend Forwardable
+    class MethodNotImplementedError < StandardError; end
+
+    attr_reader :view, :options, :sortable_columns, :searchable_columns
+    def_delegator :@view, :params, :params
+
+    def initialize(view, options = {})
+      @view = view
+      @options = options
+    end
+
+    def sortable_columns
+      @sortable_columns ||= []
+    end
+
+    def searchable_columns
+      @searchable_columns ||= []
+    end
+
+    def data
+      fail(
+        MethodNotImplementedError,
+        'Please implement this method in your class.'
+      )
+    end
+
+    def get_raw_records
+      fail(
+        MethodNotImplementedError,
+        'Please implement this method in your class.'
+      )
+    end
+
+    def as_json(options = {})
+      {
+        :sEcho => params[:sEcho].to_i,
+        :iTotalRecords => get_raw_records.count,
+        :iTotalDisplayRecords => filter_records(get_raw_records).count,
+        :aaData => data
+      }
+    end
+
+    private
+
+    def records
+      @records ||= fetch_records
+    end
+
+    def fetch_records
+      records = get_raw_records
+      records = sort_records(records)
+      records = filter_records(records)
+      records = paginate_records(records)
+      records
+    end
+
+    def sort_records(records)
+      records.order("#{sort_column} #{sort_direction}")
+    end
+
+    def paginate_records(records)
+      fail(
+        MethodNotImplementedError,
+        'Please mixin a pagination extension.'
+      )
+    end
+
+    def filter_records(records)
+      records = simple_search(records)
+      records = composite_search(records)
+      records
+    end
+
+    def simple_search(records)
+      return records unless params[:sSearch]
+      conditions = build_conditions_for(params[:sSearch])
+      records = records.where(conditions) if conditions
+      records
+    end
+
+    def composite_search(records)
+      conditions = aggregate_query
+      records = records.where(conditions) if conditions
+      records
+    end
+
+    def build_conditions_for(query)
+      searchable_columns.map { |col| search_condition(col, query) }.reduce(:or)
+    end
+
+    def search_condition(column, value)
+      model, column = column.split('.')
+      model = model.singularize.titleize.constantize
+      model.arel_table[column.to_sym].matches("%#{value}%")
+    end
+
+    def aggregate_query
+      conditions = searchable_columns.each_with_index.map do |column, index|
+        value = params["sSearch_#{index}".to_sym]
+        search_condition(column, value) if value
+      end
+      conditions.compact.reduce(:and)
+    end
+
+    def offset
+      (page - 1) * per_page
+    end
+
+    def page
+      (params[:iDisplayStart].to_i / per_page) + 1
+    end
+
+    def per_page
+      params.fetch(:iDisplayLength, 10).to_i
+    end
+
+    def sort_column
+      sortable_columns[params[:iSortCol_0].to_i]
+    end
+
+    def sort_direction
+      options = %w(desc asc)
+      options.include?(params[:sSortDir_0]) ? params[:sSortDir_0].upcase : 'ASC'
+    end
+  end
+end

data/lib/ajax-datatables-rails/extensions/kaminari.rb

@@ -0,0 +1,12 @@
+module AjaxDatatablesRails
+  module Extensions
+    module Kaminari
+
+      private
+      
+      def paginate_records(records)
+        records.page(page).per(per_page)
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/extensions/simple_paginator.rb

@@ -0,0 +1,12 @@
+module AjaxDatatablesRails
+  module Extensions
+    module SimplePaginator
+
+      private
+      
+      def paginate_records(records)
+        records.offset(offset).limit(per_page)
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/extensions/will_paginate.rb

@@ -0,0 +1,12 @@
+module AjaxDatatablesRails
+  module Extensions
+    module WillPaginate
+
+      private
+      
+      def paginate_records(records)
+        records.paginate(:page => page, :per_page => per_page)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module AjaxDatatablesRails
+  VERSION = '0.1.0'
+end

data/lib/generators/rails/datatable_generator.rb

@@ -0,0 +1,39 @@
+require 'rails/generators'
+
+module Rails
+  module Generators
+    class DatatableGenerator < ::Rails::Generators::Base
+      desc 'Creates a *_datatable model in the app/datatables directory.'
+      source_root File.expand_path('../templates', __FILE__)
+      argument :name, :type => :string
+
+      def generate_datatable
+        file_prefix = set_filename(name)
+        @datatable_name = set_datatable_name(name)
+        template 'datatable.rb', File.join(
+          'app/datatables', "#{file_prefix}_datatable.rb"
+        )
+      end
+
+      private
+
+      def set_filename(name)
+        name.include?('_') ? name : name.to_s.underscore
+      end
+
+      def set_datatable_name(name)
+        name.include?('_') ? build_name(name) : capitalize(name)
+      end
+
+      def build_name(name)
+        pieces = name.split('_')
+        pieces.map(&:titleize).join
+      end
+
+      def capitalize(name)
+        return name if name[0] == name[0].upcase
+        name.capitalize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+class <%= @datatable_name %>Datatable < AjaxDatatablesRails::Base
+  # uncomment the appropriate paginator module,
+  # depending on gems available in your project.
+  # include AjaxDatatablesRails::Extensions::Kaminari
+  # include AjaxDatatablesRails::Extensions::WillPaginate
+  # include AjaxDatatablesRails::Extensions::SimplePaginator
+
+  def sortable_columns
+    # list columns inside the Array in string dot notation.
+    # Example: 'users.email'
+    @sortable_columns ||= []
+  end
+
+  def searchable_columns
+    # list columns inside the Array in string dot notation.
+    # Example: 'users.email'
+    @searchable_columns ||= []
+  end
+
+  private
+
+  def data
+    records.map do |record|
+      [
+        # comma separated list of the values for each cell of a table row
+        # example: record.attribute,
+      ]
+    end
+  end
+
+  def get_raw_records
+    # insert query here
+  end
+
+  # ==== Insert 'presenter'-like methods below if necessary
+end

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

@@ -1,7 +1,163 @@
 require 'spec_helper'
 
-describe AjaxDatatablesRails do
-  describe "as_json" do
-    it "should return the correct json feed"
+describe AjaxDatatablesRails::Base do
+  class Column
+    def matches(query)
+      []
+    end
   end
-end
+
+  class User
+    def self.arel_table
+      { :foo => Column.new }
+    end
+  end
+
+  params = {
+    :sEcho => '0', :sSortDir_0 => 'asc',
+    :iSortCol_0 => '1', :iDisplayStart => '11'
+  }
+  let(:view) { double('view', :params => params) }
+
+  describe 'an instance' do
+    it 'requires a view_context' do
+      expect { AjaxDatatablesRails::Base.new }.to raise_error
+    end
+
+    it 'accepts an options hash' do
+      datatable = AjaxDatatablesRails::Base.new(view, :foo => 'bar')
+      expect(datatable.options).to eq(:foo => 'bar')
+    end
+  end
+
+  describe 'helper methods' do
+    describe '#offset' do
+      it 'defaults to 0' do
+        default_view = double('view', :params => {})
+        datatable = AjaxDatatablesRails::Base.new(default_view)
+        expect(datatable.send(:offset)).to eq(0)
+      end
+
+      it 'matches the value on view params[:iDisplayStart] minus 1' do
+        paginated_view = double('view', :params => { :iDisplayStart => '11' })
+        datatable = AjaxDatatablesRails::Base.new(paginated_view)
+        expect(datatable.send(:offset)).to eq(10)
+      end
+    end
+
+    describe '#page' do
+      it 'calculates page number from params[:iDisplayStart] and #per_page' do
+        paginated_view = double('view', :params => { :iDisplayStart => '11' })
+        datatable = AjaxDatatablesRails::Base.new(paginated_view)
+        expect(datatable.send(:page)).to eq(2)
+      end
+    end
+
+    describe '#per_page' do
+      it 'defaults to 10' do
+        datatable = AjaxDatatablesRails::Base.new(view)
+        expect(datatable.send(:per_page)).to eq(10)
+      end
+
+      it 'matches the value on view params[:iDisplayLength]' do
+        other_view = double('view', :params => { :iDisplayLength => 20 })
+        datatable = AjaxDatatablesRails::Base.new(other_view)
+        expect(datatable.send(:per_page)).to eq(20)
+      end
+    end
+
+    describe '#sort_column' do
+      it 'returns a column name from the #sorting_columns array' do
+        sort_view = double('view', :params => { :iSortCol_0 => '1' })
+        datatable = AjaxDatatablesRails::Base.new(view)
+        datatable.stub(:sortable_columns) { ['foo', 'bar', 'baz'] }
+
+        expect(datatable.send(:sort_column)).to eq('bar')
+      end
+    end
+
+    describe '#sort_direction' do
+      it 'matches value of params[:sSortDir_0]' do
+        sorting_view = double('view', :params => { :sSortDir_0 => 'desc' })
+        datatable = AjaxDatatablesRails::Base.new(sorting_view)
+        expect(datatable.send(:sort_direction)).to eq('DESC')
+      end
+
+      it 'can only be one option from ASC or DESC' do
+        sorting_view = double('view', :params => { :sSortDir_0 => 'foo' })
+        datatable = AjaxDatatablesRails::Base.new(sorting_view)
+        expect(datatable.send(:sort_direction)).to eq('ASC')
+      end
+    end
+
+    describe '#sortable_columns' do
+      it 'returns an array representing database columns' do
+        datatable = AjaxDatatablesRails::Base.new(view)
+        expect(datatable.sortable_columns).to eq([])
+      end
+    end
+
+    describe '#searchable_columns' do
+      it 'returns an array representing database columns' do
+        datatable = AjaxDatatablesRails::Base.new(view)
+        expect(datatable.searchable_columns).to eq([])
+      end
+    end
+  end
+
+  describe 'perform' do
+    let(:results) { double('Collection', :offset => [], :limit => []) }
+    let(:view) { double('view', :params => {}) }
+    let(:datatable) { AjaxDatatablesRails::Base.new(view) }
+
+    describe '#paginate_records' do
+      it 'raises a MethodNotImplementedError' do
+        expect { datatable.send(:paginate_records, []) }.to raise_error(
+          AjaxDatatablesRails::Base::MethodNotImplementedError
+        )
+      end
+    end
+
+    describe '#sort_records' do
+      it 'calls #order on a collection' do
+        results.should_receive(:order)
+        datatable.send(:sort_records, results)
+      end
+    end
+
+    describe '#filter_records' do
+      let(:records) { double('User', :where => []) }
+      let(:search_view) { double('view', :params => { :sSearch => 'foo' }) }
+
+      it 'applies search like functionality on a collection' do
+        datatable = AjaxDatatablesRails::Base.new(search_view)
+        datatable.stub(:searchable_columns) { ['users.foo'] }
+
+        records.should_receive(:where)
+        datatable.send(:filter_records, records)
+      end
+    end
+  end
+
+  describe 'hook methods' do
+    let(:datatable) { AjaxDatatablesRails::Base.new(view) }
+
+    describe '#data' do
+      it 'raises a MethodNotImplementedError' do
+        expect { datatable.data }.to raise_error(
+          AjaxDatatablesRails::Base::MethodNotImplementedError,
+          'Please implement this method in your class.'
+        )
+      end
+    end
+
+    describe '#get_raw_records' do
+      it 'raises a MethodNotImplementedError' do
+        expect { datatable.get_raw_records }.to raise_error(
+          AjaxDatatablesRails::Base::MethodNotImplementedError,
+          'Please implement this method in your class.'
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+class KaminariDatatable < AjaxDatatablesRails::Base
+  include AjaxDatatablesRails::Extensions::Kaminari
+end
+
+describe KaminariDatatable do
+  describe '#paginate_records' do
+    let(:users_database) do
+      double('User',
+        :all => double('RecordCollection',
+          :page => double('Array', :per => [])
+        )
+      )
+    end
+
+    let(:datatable) { KaminariDatatable.new(double('view', :params => {})) }
+    let(:records) { users_database.all }
+
+    it 'calls #page on passed record collection' do
+      records.should_receive(:page)
+      datatable.send(:paginate_records, records)
+    end
+
+    it 'calls #per_page on passed record collection' do
+      arry = double('Array', :per => [])
+      records.stub(:page).and_return(arry)
+      arry.should_receive(:per)
+      datatable.send(:paginate_records, records) 
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+class SimplePaginateDatatable < AjaxDatatablesRails::Base
+  include AjaxDatatablesRails::Extensions::SimplePaginator
+end
+
+describe SimplePaginateDatatable do
+  describe '#paginate_records' do
+    let(:users_database) do
+      double('User',
+        :all => double('RecordCollection',
+          :offset => double('Array', :limit => [])
+        )
+      )
+    end
+
+    let(:datatable) { SimplePaginateDatatable.new(double('view', :params => {})) }
+    let(:records) { users_database.all }
+
+    it 'calls #offset on passed record collection' do
+      records.should_receive(:offset)
+      datatable.send(:paginate_records, records)
+    end
+
+    it 'calls #limit on passed record collection' do
+      arry = double('Array', :limit => [])
+      records.stub(:offset).and_return(arry)
+      arry.should_receive(:limit)
+      datatable.send(:paginate_records, records) 
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+class WillPaginateDatatable < AjaxDatatablesRails::Base
+  include AjaxDatatablesRails::Extensions::WillPaginate
+end
+
+describe WillPaginateDatatable do
+  describe '#paginate_records' do
+    let(:users_database) do
+      double('User',
+        :all => double('RecordCollection',
+          :paginate => double('Array', :per_page => [])
+        )
+      )
+    end
+
+    let(:datatable) { WillPaginateDatatable.new(double('view', :params => {})) }
+    let(:records) { users_database.all }
+
+    it 'calls #page and #per_page on passed record collection' do
+      records.should_receive(:paginate).with(:page=>1, :per_page=>10)
+      datatable.send(:paginate_records, records)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1 +1,3 @@
-require 'ajax-datatables-rails'
+require 'pry'
+require 'rails'
+require 'ajax-datatables-rails'

metadata

@@ -1,32 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: ajax-datatables-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Joel Quenneville
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-10 00:00:00.000000000 Z
+date: 2014-05-21 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
-    none: false
     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
-    none: false
     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
 email:
 - joel.quenneville@collegeplus.org
@@ -34,47 +101,51 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .rvmrc
-- Gemfile
-- LICENSE
-- README.md
-- Rakefile
-- ajax-datatables-rails.gemspec
+- lib/ajax-datatables-rails/base.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/ajaxdatatable/USAGE
-- lib/generators/ajaxdatatable/ajaxdatatable_generator.rb
-- lib/generators/ajaxdatatable/templates/datatable.rb
-- lib/generators/filterdatatable/USAGE
-- lib/generators/filterdatatable/templates/filter.rb
+- lib/generators/rails/datatable_generator.rb
+- lib/generators/rails/templates/datatable.rb
 - spec/ajax-datatables-rails/ajax_datatables_rails_spec.rb
+- spec/ajax-datatables-rails/kaminari_spec.rb
+- 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: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A wrapper around datatable's ajax methods that allow synchronization with
   server-side pagination in a rails app
 test_files:
 - spec/ajax-datatables-rails/ajax_datatables_rails_spec.rb
+- spec/ajax-datatables-rails/kaminari_spec.rb
+- spec/ajax-datatables-rails/simple_paginator_spec.rb
+- spec/ajax-datatables-rails/will_paginate_spec.rb
 - spec/spec_helper.rb

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/.rspec

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

data/.rvmrc

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-
-# This is an RVM Project .rvmrc file, used to automatically load the ruby
-# development environment upon cd'ing into the directory
-
-# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
-# Only full ruby name is supported here, for short names use:
-#     echo "rvm use 1.9.3" > .rvmrc
-environment_id="ruby-1.9.3-p125@ajax-datatables-rails"
-
-# Uncomment the following lines if you want to verify rvm version per project
-# rvmrc_rvm_version="1.11.0-pre" # 1.10.1 seams as a safe start
-# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
-#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
-#   return 1
-# }
-
-# First we attempt to load the desired environment directly from the environment
-# file. This is very fast and efficient compared to running through the entire
-# CLI and selector. If you want feedback on which environment was used then
-# insert the word 'use' after --create as this triggers verbose mode.
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
-  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
-then
-  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
-    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
-else
-  # If the environment file has not yet been created, use the RVM CLI to select.
-  rvm --create  "$environment_id" || {
-    echo "Failed to create RVM environment '${environment_id}'."
-    return 1
-  }
-fi
-
-# If you use bundler, this might be useful to you:
-# if [[ -s Gemfile ]] && {
-#   ! builtin command -v bundle >/dev/null ||
-#   builtin command -v bundle | grep $rvm_path/bin/bundle >/dev/null
-# }
-# then
-#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
-#   gem install bundler
-# fi
-# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
-# then
-#   bundle install | grep -vE '^Using|Your bundle is complete'
-# fi

data/ajax-datatables-rails.gemspec

@@ -1,19 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/ajax-datatables-rails', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.authors       = ["Joel Quenneville"]
-  gem.email         = ["joel.quenneville@collegeplus.org"]
-  gem.description   = %q{A gem that simplifies using datatables and hundreds of records via ajax}
-  gem.summary       = %q{A wrapper around datatable's ajax methods that allow synchronization with server-side pagination in a rails app}
-  gem.homepage      = ""
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "ajax-datatables-rails"
-  gem.require_paths = ["lib"]
-  gem.version       = AjaxDatatablesRails::VERSION
-  
-  gem.add_development_dependency "rspec"
-end

data/lib/generators/ajaxdatatable/USAGE

@@ -1,2 +0,0 @@
-Description:
-  The ajaxdatatable generator creates a *_datatable model in the app/datatables directory. This class inherits from AjaxDatatablesRails

data/lib/generators/ajaxdatatable/ajaxdatatable_generator.rb

@@ -1,8 +0,0 @@
-class AjaxdatatableGenerator < Rails::Generators::Base
-  source_root File.expand_path('../templates', __FILE__)
-  argument :model, type: :string
-
-  def generate_ajaxdatatable
-    template 'datatable.rb', File.join('app/datatables', "#{model.tableize}_datatable.rb")
-  end
-end

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

@@ -1,33 +0,0 @@
-class <%= model.classify.pluralize %>Datatable < AjaxDatatablesRails
-  
-  def initialize(view)
-    @model_name = <%= model.classify %>
-    @columns = # insert array of column names here
-    @searchable_columns = #insert array of columns that will be searched
-    super(view)
-  end
-  
-private
-
-    def data
-      <%= model.tableize %>.map do |<%= model.tableize.singularize %>|
-        [
-          # comma separated list of the values for each cell of a table row
-        ]
-      end
-    end
-
-    def <%= model.tableize %>
-      @<%= model.tableize %> ||= fetch_records
-    end
-
-    def get_raw_records
-      # insert query here
-    end
-    
-    def get_raw_record_count
-      search_records(get_raw_records).count
-    end
-    
-    # ==== Insert 'presenter'-like methods below if necessary
-end

data/lib/generators/filterdatatable/USAGE

@@ -1,2 +0,0 @@
-Description:
-  The ajaxdatatable generator creates a *_filter_datatable model in the app/datatables directory. This class overwrites the query in it's parent class

data/lib/generators/filterdatatable/templates/filter.rb

@@ -1,8 +0,0 @@
-class <%= model.classify.pluralize %>FilterDatatable < <%= model.classify.pluralize %>Datatable
-  
-private
-
-  def get_raw_records
-    # insert query here
-  end
-end