flexible_datatables 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a13f848d1e7169a66d108830a47d8289e6476c33
-  data.tar.gz: 3d2bfa335369d77870971e5085a5a70bb26171ed
+  metadata.gz: 22a22794a1f6a65928133accc5770f4f8bcc2567
+  data.tar.gz: afeb755aaa7c2f7525a2c9f3c9a19aea0d17e197
 SHA512:
-  metadata.gz: d1dae4b484f9791480a47c4a9ffdb968f074f5c09bf13a9e21a4b9aa347a21a05e479e38b2ddfe2bcd468d54249f4c536fa48d9c1f29d5ab2f3dbd15f3122759
-  data.tar.gz: eb9b00b5cf65177cd9f05671a4b51ebe91e9319e68c3ce5cf0f031f0e765486d26cafb827c0550230a67bab8df1f985ef2cb53ede217e7cda5393cfe6c9f720b
+  metadata.gz: f1da69724072382a1b800f9e5eb7d7264a0e3095469b2da4538997963c6c210355b1192ced4aca938296b79b476298ef4974ca71cecb5abc28088604030385a2
+  data.tar.gz: 534c1713cd72815d2b4a1f6c4e4fd529aa10d45173def7ba4032152efea5308969a0795ff164a768e455d2f5f02ee3d0bfb51fd1c0efd56f9843d537c17c0461

data/CHANGELOG

@@ -3,7 +3,18 @@ Change Log
 
 All notable changes to the project are documented in this file.
 
-[1.0.0] - 2015-02-14
+[v1.0.1] - 2015-02-15
 --------------------
 
-Version 1 release of the library.
+ca4badc Don't use 'blank?', which is an enhancement to Ruby from Rails, because obviously the code won't work outside of Rails
+e621434 refer to the default DummyPaginator using the full namespace
+4bb3085 Instantiate a Settings object when Configurator is defined, so default settings are available without needing to call Configurator.configuration first
+513db65 pull in paginators and configurator definitions first
+95d38a5 tweak file list
+2308215 use rdoc for the README
+
+[v1.0.0] - 2015-02-14
+--------------------
+
+38c6db1 initial commit
+

data/CHANGELOG.md

@@ -3,7 +3,18 @@ Change Log
 
 All notable changes to the project are documented in this file.
 
-[1.0.0] - 2015-02-14
+[v1.0.1] - 2015-02-15
 --------------------
 
-Version 1 release of the library.
+ca4badc Don't use 'blank?', which is an enhancement to Ruby from Rails, because obviously the code won't work outside of Rails
+e621434 refer to the default DummyPaginator using the full namespace
+4bb3085 Instantiate a Settings object when Configurator is defined, so default settings are available without needing to call Configurator.configuration first
+513db65 pull in paginators and configurator definitions first
+95d38a5 tweak file list
+2308215 use rdoc for the README
+
+[v1.0.0] - 2015-02-14
+--------------------
+
+38c6db1 initial commit
+

data/README.rdoc

@@ -0,0 +1,107 @@
+= Flexible Datatables
+Easily integrate {JQuery Datatables}[https://www.datatables.net] (with Ajax) into your Ruby / Rails web applications.
+
+== Introduction
+Flexible Datatables wraps array-like objects (ActiveRecord::Relation collections, etc) that JQuery Datatables can read (via ajax) from your Ruby / Rails web application.
+
+== Features
+* Any arbitrary array-like collection of data, from plain old ruby arrays to complicated ActiveRecord (or Arel, or plain SQL) query results, can be passed on to JQuery Datatables with very little configuration overhead.
+* Server-side pagination with {Kaminari}[https://github.com/amatsuda/kaminari] can be used, out of the box.
+
+== Background
+This library was inspired by Ryan Bates' excellent {Railscast episode}[http://railscasts.com/episodes/340-datatables] and the {ajax-datatables-rails}[https://github.com/antillas21/ajax-datatables-rails] gem.
+
+So why not just use {ajax-datatables-rails}[https://github.com/antillas21/ajax-datatables-rails]?
+
+1. I wanted to be free to use (abuse) SQL to generate the result set to be passed to DataTables.  The {ajax-datatables-rails}[https://github.com/antillas21/ajax-datatables-rails] library constructs ActiveRecord queries on the application's behalf, based on user-supplied column names.
+2. I also wanted to the ability to sort on any kind of column, from integer column types to non-string / non-text based columns, to aggregate functions, and so on.
+3. Although I usually choose PostgreSQL as my Rails DB backend of choice, I wanted to be able to pass in any kind of array-like collection (or even use a different database backend altogether).
+
+== Installation
+1. First, make sure you have {DataTables}[https://www.datatables.net] installed.
+   You have a few choices here.  If you are integrating DataTables with a Rails project, the easiest route is via the {jquery-datatables-rails}[https://github.com/rweng/jquery-datatables-rails] gem.  Be sure to follow the installation instructions if you choose this route.
+   You can also use {bower}[https://github.com/rharriso/bower-rails], or you can even leverage DataTables' {cdn}[https://cdn.datatables.net/].
+
+2. Add this line to your application's <tt>Gemfile</tt>:
+
+     gem 'flexible_datatables'
+
+   And then execute:
+
+     $ bundle
+
+   Or install it yourself as:
+
+     $ gem install flexible_datatables
+
+3. (optional)  Create the file <tt>config/initializers/flexible_datatables.rb</tt>.  You can use this to override default values (such as the choice of pagination).
+
+     FlexibleDatatables.configuration do |settings|
+       # settings.paginator = FlexibleDatatables::KaminariPaginator
+       settings.paginator = FlexibleDatatables::SimplePaginator
+       # settings.items_per_page = 10
+     end
+
+== Usage
+=== Rails
+<b>NOTE</b>
+
+Flexible Datatables isn't required if you wish to use DataTables to transform an html <tt>table</tt> without using ajax (see the first part of the {DataTables RailsCast}[http://railscasts.com/episodes/340-datatables?view=asciicast] for reference).
+
+The benefit of using Flexible Datatables comes when one wishes to have DataTables tables displaying data from a Rails backend using ajax.
+
+==== Controller
+1. Flexible Datatables requires the <tt>draw</tt>, <tt>start</tt>, <tt>length</tt>, and <tt>order</tt> keys from the <tt>params</tt> hash.  Initialize a new <tt>FlexibleDatatables::Datatable</tt> object and pass in those values.
+
+     datatable = FlexibleDatatables::Datatable.new(params.slice(:draw, :start, :length, :order))
+
+2. Pass in a collection of objects (which can come from anywhere; an array, an ActiveRecord query, etc)
+
+     datatable.collection = MyModel.all
+
+3. Tell your <tt>Datatable</tt> object what your columns are and how to arrange them into rows.
+
+     datatable.format_grid(%w(first_column, second_column, third_column) do |record|
+       [record.first_column, record.second_column, record.third_column]
+     end
+
+4. Instruct Rails to render your <tt>Datatable</tt> object as <tt>JSON</tt>.  Your controller may look something like this:
+
+     respond_to do |format|
+       format.html
+       format.json do
+         datatable = FlexibleDatatables::Datatable.new(params.slice(:draw, :start, :length, :order))
+         datatable.collection = MyModel.all
+         datatable.format_grid(%w(first_column, second_column, third_column) do |record|
+           [record.first_column, record.second_column, record.third_column]
+         end
+         render json: datatable
+       end
+     end
+
+==== View
+1. Define a <tt>table</tt> with an <tt>id</tt> attribute.
+2. Give the <tt>table</tt> a <tt>data-source</tt> attribute that points to the route that DataTables will use to get the json data over ajax.
+3. Give this <tt>table</tt> a <tt>thead</tt> with some header columns, and an empty <tt>tbody</tt> declaration.
+
+==== JavaScript
+Finally, in a javascript file, call <tt>.DataTable()</tt> and pass in values for the <tt>processing</tt>, <tt>serverSide</tt>, <tt>ajax</tt>, and <tt>pagingType</tt> parameters.
+
+  $ ->
+    $('#my_table_id').DataTable
+      processing: true
+      serverSide: true
+      ajax: $('#my_table_id').data('source')
+      pagingType: "full_numbers"
+
+== Contributing
+
+1. Fork it
+2. Create your feature branch (<tt>git checkout -b my-new-feature</tt>)
+3. Commit your changes (<tt>git commit -am 'Added some feature'</tt>)
+4. Push to the branch (<tt>git push origin my-new-feature</tt>)
+5. Create new Pull Request
+
+== License
+
+GPL-3.0+

data/lib/flexible_datatables.rb

@@ -1,3 +1,8 @@
+require 'ostruct'
+require 'flexible_datatables/paginators'
+require 'flexible_datatables/configurator'
+require 'flexible_datatables/datatable'
+
 module FlexibleDatatables
   def self.configuration
     Configurator.configuration do |config|
@@ -9,8 +14,3 @@ module FlexibleDatatables
     Configurator.settings
   end
 end
-
-require 'ostruct'
-require 'flexible_datatables/datatable'
-require 'flexible_datatables/configurator'
-require 'flexible_datatables/paginators'

data/lib/flexible_datatables/configurator.rb

@@ -5,12 +5,12 @@ module FlexibleDatatables
 
       def initialize
         @items_per_page = 10
-        @paginator = DummyPaginator
+        @paginator = ::FlexibleDatatables::DummyPaginator
       end
     end
 
+    @@settings = Settings.new
     def self.configuration
-      @@settings ||= Settings.new
       yield(@@settings)
     end
 

data/lib/flexible_datatables/datatable.rb

@@ -21,8 +21,8 @@ module FlexibleDatatables
       }
     end
 
-    def format_grid(cols)
-      @columns = cols unless cols.blank?
+    def format_grid(cols = [])
+      @columns = cols unless cols.empty?
       records = collection.order("#{sort_column} #{sort_direction}")
       @grid = paginate(records).map { |record| yield(record) }
     end

data/lib/flexible_datatables/version.rb

@@ -1,3 +1,3 @@
 module FlexibleDatatables
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexible_datatables
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Dave Corning
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-14 00:00:00.000000000 Z
+date: 2015-02-15 00:00:00.000000000 Z
 dependencies: []
 description: Flexible Datatables wraps array-like objects (ActiveRecord::Relation
   collections, etc) that JQuery Datatables can read (via ajax) from your Ruby / Rails
@@ -20,7 +20,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG
 - CHANGELOG.md
-- README.md
+- README.rdoc
 - lib/flexible_datatables.rb
 - lib/flexible_datatables/configurator.rb
 - lib/flexible_datatables/datatable.rb
@@ -55,3 +55,4 @@ specification_version: 4
 summary: Easily integrate JQuery Datatables (with Ajax) into your Ruby / Rails web
   applications.
 test_files: []
+has_rdoc: 

data/README.md

@@ -1,112 +0,0 @@
-# Flexible Datatables
-
-Easily integrate [JQuery Datatables](https://www.datatables.net) (with Ajax) into your Ruby / Rails web applications.
-
-## Introduction
-Flexible Datatables wraps array-like objects (ActiveRecord::Relation collections, etc) that JQuery Datatables can read (via ajax) from your Ruby / Rails web application.
-
-## Features
-* Any arbitrary array-like collection of data, from plain old ruby arrays to complicated ActiveRecord (or Arel, or plain SQL) query results, can be passed on to JQuery Datatables with very little configuration overhead.
-* Server-side pagination with [Kaminari](https://github.com/amatsuda/kaminari) can be used, out of the box.
-
-## Background
-This library was inspired by Ryan Bates' excellent [Railscast episode](http://railscasts.com/episodes/340-datatables) and the [ajax-datatables-rails](https://github.com/antillas21/ajax-datatables-rails) gem.
-
-So why not just use [ajax-datatables-rails](https://github.com/antillas21/ajax-datatables-rails)?
-
-1. I wanted to be free to use (abuse) SQL to generate the result set to be passed to DataTables.  The [ajax-datatables-rails](https://github.com/antillas21/ajax-datatables-rails) library constructs ActiveRecord queries on the application's behalf, based on user-supplied column names.
-2. I also wanted to the ability to sort on any kind of column, from integer column types to non-string / non-text based columns, to aggregate functions, and so on.
-3. Although I usually choose PostgreSQL as my Rails DB backend of choice, I wanted to be able to pass in any kind of array-like collection (or even use a different database backend altogether).
-
-## Installation
-1. First, make sure you have [DataTables](https://www.datatables.net) installed.
-
-    You have a few choices here.  If you are integrating DataTables with a Rails project, the easiest route is via the [jquery-datatables-rails](https://github.com/rweng/jquery-datatables-rails) gem.  Be sure to follow the installation instructions if you choose this route.
-
-    You can also use [bower](https://github.com/rharriso/bower-rails), or you can even leverage DataTables' [cdn](https://cdn.datatables.net/).
-
-2. Add this line to your application's `Gemfile`:
-
-        gem 'flexible_datatables'
-
-    And then execute:
-
-        $ bundle
-
-    Or install it yourself as:
-
-        $ gem install flexible_datatables
-3. (optional)  Create the file `config/initializers/flexible_datatables.rb`.  You can use this to override default values (such as the choice of pagination).
-```ruby
-FlexibleDatatables.configuration do |settings|
-  # settings.paginator = FlexibleDatatables::KaminariPaginator
-  settings.paginator = FlexibleDatatables::SimplePaginator
-  # settings.items_per_page = 10
-end
-```
-
-## Usage
-### Rails
-*NOTE*
-
-Flexible Datatables isn't required if you wish to use DataTables to transform an html `table` without using ajax (see the first part of the [DataTables RailsCast](http://railscasts.com/episodes/340-datatables?view=asciicast) for reference).
-
-The benefit of using Flexible Datatables comes when one wishes to have DataTables tables displaying data from a Rails backend using ajax.
-
-#### Controller
-Flexible Datatables requires the `draw`, `start`, `length`, and `order` keys from the `params` hash.  Initialize a new `FlexibleDatatables::Datatable` object and pass in those values.
-```ruby
-datatable = FlexibleDatatables::Datatable.new(params.slice(:draw, :start, :length, :order))
-```
-Pass in a collection of objects (which can come from anywhere; an array, an ActiveRecord query, etc)
-```ruby
-datatable.collection = MyModel.all
-```
-Tell your `Datatable` object what your columns are and how to arrange them into rows.
-```ruby
-datatable.format_grid(%w(first_column, second_column, third_column) do |record|
- [record.first_column, record.second_column, record.third_column]
-end
-```
-Instruct Rails to render your `Datatable` object as `JSON`.  Your controller may look something like this:
-```ruby
-respond_to do |format|
- format.html
- format.json do
-   datatable = FlexibleDatatables::Datatable.new(params.slice(:draw, :start, :length, :order))
-   datatable.collection = MyModel.all
-   datatable.format_grid(%w(first_column, second_column, third_column) do |record|
-     [record.first_column, record.second_column, record.third_column]
-   end
-   render json: datatable
-   end
-end
-```
-
-#### View
-Define a `table` with an `id` attribute.
-Give the `table` a `data-source` attribute that points to the route that DataTables will use to get the json data over ajax.
-Give this `table` a `thead` with some header columns, and an empty `tbody` declaration.
-
-#### JavaScript
-Finally, in a javascript file, call `.DataTable()` and pass in values for the `processing`, `serverSide`, `ajax`, and `pagingType` parameters.
-```Coffeescript
-$ ->
-  $('#my_table_id').DataTable
-    processing: true
-    serverSide: true
-    ajax: $('#my_table_id').data('source')
-    pagingType: "full_numbers"
-```
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-## License
-
-GPL-3.0+