ajax-datatables-rails-coveralls 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ff475314e5279552f9dd3661de1d9b46703234c
+  data.tar.gz: 19c310b583dba22cfc3f0785186b280aabac68cc
+SHA512:
+  metadata.gz: b3672cfae84d784dcdb7b513fbcb356873a5196a5de25103d738d60a83911dea2f339120c32882f0e53f1a09a1ce1d5c8f33f5af58469689f717e4f40f195a16
+  data.tar.gz: 0dbec84b3df0b5a493f5800273958ddcd1b696b206fea5f9efb1222a46af78e83682f1a461929756b71083c6f2c3c5ca95897345d2768d1a7a3e539d1f948738

data/.gitignore

@@ -0,0 +1,17 @@
+*.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

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

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/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/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ajax-datatables-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Joel Quenneville
+
+MIT License
+
+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,142 @@
+# ajax-datatables-rails
+
+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. 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.
+
+## Installation
+
+Add these lines to your application's Gemfile:
+
+    gem 'jquery-datatables-rails'
+    gem 'ajax-datatables-rails'
+
+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
+Run the following command:
+
+    $ rails generate ajaxdatatable 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
+
+#### Initializer
+```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)
+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 `@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
+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)
+end
+```
+
+#### Data
+```ruby
+def data
+  users.map do |user|
+    [
+      # comma separated list of the values for each cell of a table row
+    ]
+  end
+end
+```
+
+This method builds a 2d array that is used by datatables to construct the html table. Insert the values you want on each column.
+
+```ruby
+def data
+  users.map do |user|
+    [
+      user.f_name,
+      user.l_name,
+      user.bio
+    ]
+  end
+end
+```
+
+#### Get Raw Records
+```ruby
+def get_raw_records
+  # insert query here
+end
+```
+
+This is where your query goes.
+
+```ruby
+def get_raw_records
+  User.all
+end
+```
+
+### Controller
+Set up the controller to respond to JSON
+
+```ruby
+def index
+  respond_to do |format|
+    format.html
+    format.json { render json: UsersDatatable.new(view_context) }
+  end
+end
+```
+
+### View
+* Set up an html `<table>` with a `<thead>` and `<tbody>`
+* Add in your table headers if desired
+* Don't add any rows to the body of the table, datatables does this automatically
+* Add a data attribute to the `<table>` tag with the url of the JSON feed
+
+The resulting view may look like this:
+
+```erb
+<table id="user-table", data-source="<%= users_path(format: :json) %>">
+  <thead>
+    <tr>
+      <th>First Name</th>
+      <th>Last Name</th>
+      <th>Brief Bio</th>
+    </tr>
+  </thead>
+  <tbody>
+  </tbody>
+</table>
+```
+
+### Javascript
+Finally, the javascript to tie this all together. In the appropriate `js.coffee` file:
+
+```coffeescript
+$ ->
+  $('#users-table').dataTable
+    bProcessing: true
+    bServerSide: true
+    sAjaxSource: $('#users-table').data('source')
+```
+
+## 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

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/ajax-datatables-rails.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ajax-datatables-rails', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Joel Quenneville", "Nick Merwin"]
+  gem.email         = ["joel.quenneville@collegeplus.org", "n@mer.io"]
+  gem.description   = %q{Fork for Coveralls app}
+  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-coveralls"
+  gem.require_paths = ["lib"]
+  gem.version       = AjaxDatatablesRails::VERSION
+
+  gem.add_development_dependency "rspec"
+end

data/lib/ajax-datatables-rails.rb

@@ -0,0 +1,79 @@
+# 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: get_raw_record_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

data/lib/generators/ajaxdatatable/USAGE

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe AjaxDatatablesRails do
+  describe "as_json" do
+    it "should return the correct json feed"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'ajax-datatables-rails'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: ajax-datatables-rails-coveralls
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joel Quenneville
+- Nick Merwin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-18 00:00:00.000000000 Z
+dependencies:
+- !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'
+description: Fork for Coveralls app
+email:
+- joel.quenneville@collegeplus.org
+- n@mer.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rvmrc"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ajax-datatables-rails.gemspec
+- 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
+- spec/ajax-datatables-rails/ajax_datatables_rails_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+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/spec_helper.rb