rails_serverside_datatables 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd41b1c19949506f4a964d42f82d149295cb5109
+  data.tar.gz: df8b9eece21d75a403cb4624793d5e4db0062eb2
+SHA512:
+  metadata.gz: e193ecab2bc9f0e41bcdc55edc3bb67599878a89b8dc101eb559aafc4f5021854c74d5881eafe8c3a220b1a082abe7ce976a77ac623be0a83d6dbe980aab9962
+  data.tar.gz: 01b3fab809850eefc44bda16446140f7295638901f09069a0295d2423adbafae31f17438a7d779426a224b517e96b6b1311695984a6a8dc56c5b05cc96447109

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+*.gem

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.14.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Oskar Kirmis
+
+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,116 @@
+# Rails Serverside Datatables made easy
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails_serverside_datatables'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails_serverside_datatables
+
+## Usage
+
+### Basic usage
+
+Lets say we have the following model `User`:
+
+```
+firstname | lastname | score
+----------+----------+-------
+Jane      | Doe      | 42
+John      | Doe      | 23
+...       | ...      | ...
+```
+
+To create a datatable you can sort and filter, just create a controller method like this one:
+
+```ruby
+class UsersController < ApplicationController
+    include RailsServersideDatatables
+
+    # ...
+    
+    def ajax
+      datatable( [
+        { display_name: 'Firstname', expression: :firstname },
+        { display_name: 'Lastname',  expression: :lastname },
+        { display_name: 'Score',     expression: :score }
+      ], User.all )
+    end
+    
+    # ...
+
+end
+```
+
+Add the required entry to the `routes.rb`, e.g.:
+
+`get '/users/datatable_ajax', to: 'users#ajax'`
+
+Now you can reference you datatable by either creating the table on your own and initialize it using datatables... or you just use the following code in your view:
+
+`<%= serverside_datatable( users_ajax_path, 'user-table', class: 'my-css-class' ) %>`
+
+### Computed columns
+
+Let's say you only want to show the name in the form `lastname, firstname` in one column and double the score adding 'points':
+
+```ruby
+class UsersController < ApplicationController
+    include RailsServersideDatatables
+
+    # ...
+    
+    def ajax
+      datatable( [
+        { display_name: 'Firstname', expression: [ :lastname, ' ', :firstname ] },
+        { display_name: 'Score',     expression: [ text_cast( num_op( :score, '*', 2 ) ), ' points' ] }
+      ], User.all )
+    end
+    
+    # ...
+
+end
+```
+
+### Decorator functions
+
+If you want to display the data in a custom style, you can use structured data (e.g. additional data queried you can then use in the decorator method) and a decorator block. 
+
+The structured data can be passed in the `config` parameter. Every key that is not a predefined parameter like `display_name` is used as an additional expression queried from the database:
+
+```ruby
+class UsersController < ApplicationController
+    include RailsServersideDatatables
+
+    # ...
+    
+    def ajax
+      datatable( [
+        Column.new( :name, [ :lastname, ' ', :firstname ], display_name: 'Full name', uid: :id ) {
+          |value, data| view_context.link_to value, user_path( data[:uid] )
+        },
+        Column.new( :score, :score, display_name: 'Score' ) {
+          |value, _| "#{value} points"
+        }
+      ], User.all )
+    end
+    
+    # ...
+
+end
+```
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/rails_serverside_datatables.rb

@@ -0,0 +1,15 @@
+require_relative 'rails_serverside_datatables/column'
+require_relative 'rails_serverside_datatables/expression_functions'
+require_relative 'rails_serverside_datatables/data_table'
+
+require_relative 'rails_serverside_datatables/views/railtie' if defined?( Rails )
+
+module RailsServersideDatatables
+  def datatable( column_definitions, query, parameters = nil )
+
+    table = DataTable.new( query, parameters || params )
+    column_definitions.each { |column| table.add_column column }
+
+    render json: table.as_json
+  end
+end

data/lib/rails_serverside_datatables/column.rb

@@ -0,0 +1,89 @@
+require 'active_record'
+require 'cgi'
+require_relative 'expressions'
+
+module RailsServersideDatatables
+
+  class Column
+    CONFIGURATION_KEYS = [ :display_name, :column_filtering, :sorting, :filtering ]
+
+    attr_accessor :decorator
+    attr_accessor :display_name, :column_filtering, :sorting, :filtering
+
+    def initialize( name, definition, config = {}, &block )
+      @name       = name
+      @definition = ExprTreeNode.create_by_type definition
+      @structured = config.reject {
+            |c| CONFIGURATION_KEYS.include? c
+        }.to_a.map {
+            |s| [s.first, ExprTreeNode.create_by_type(s.last ) ]
+        }.to_h
+
+      @decorator  = block
+
+      @display_name     = config.fetch( :display_name, name.to_s.capitalize )
+      @column_filtering = config.fetch( :column_filtering, true )
+      @sorting          = config.fetch( :sorting, true )
+      @filtering        = config.fetch( :filtering, true )
+    end
+
+    def order_definition=( definition )
+      @order_definition = definition
+    end
+
+    def structured( record )
+      @structured.to_a.map do |s|
+        [s.first, record.read_attribute(helper_column_name s.first)]
+      end.to_h
+    end
+
+    def value( record )
+      decorated record.read_attribute( main_column_name ), structured( record )
+    end
+
+    def select
+      @structured.to_a.map { |c| ExpressionAlias.new( c.last, helper_column_name(c.first) ) } +
+          [ ExpressionAlias.new( @definition, main_column_name ) ]
+    end
+
+    def order( direction = :ASC )
+      return Nothing.new unless sorting
+      OrderBy.new( @order_definition || main_column_name, direction )
+    end
+
+    def column_filter( filter )
+      return Nothing.new unless column_filtering
+      create_filter( filter )
+    end
+
+    def filter( filter )
+      return Nothing.new unless filtering
+      create_filter( filter )
+    end
+
+    def configuration
+      {
+          filtering: filtering, sorting: sorting,
+          column_filtering: true, display_name: display_name,
+          name: @name
+      }
+    end
+
+    private
+    def create_filter( filter )
+      FilterByText.new( @definition, filter )
+    end
+
+    def decorated( main, structured )
+      @decorator.nil? ? CGI.escapeHTML( main ) : @decorator.call( main, structured )
+    end
+
+    def main_column_name
+      "#{@name.to_s}_main".to_sym
+    end
+
+    def helper_column_name( structured_label )
+      "#{@name.to_s}_raw_#{structured_label.to_s}".to_sym
+    end
+  end
+end

data/lib/rails_serverside_datatables/data_table.rb

@@ -0,0 +1,143 @@
+require_relative 'column'
+
+module RailsServersideDatatables
+  class DataTable
+
+    def initialize( query, parameters )
+      @columns    = []
+      @parameters = parameters
+
+      @query         = query
+      @total_records = query.size
+    end
+
+    def add_column( definition, structured = {}, &block )
+      if definition.is_a? Column
+        @columns.push definition
+      else
+        if block.nil?
+          @columns.push Column.new( "cc_#{@columns.size}".to_sym, definition[:expression], structured )
+        else
+          @columns.push( Column.new( "cc_#{@columns.size}".to_sym, definition[:expression], structured ) do |value, structured|
+            block.call(value, structured)
+          end)
+        end
+
+        @columns.last.display_name = definition.fetch( :display_name, "#{@columns.size}" )
+      end
+    end
+
+    def as_json
+      return configuration if config_request?
+
+      apply_select
+      apply_column_filters
+      apply_global_filter
+
+      @records_filtered = @query.size
+
+      apply_order
+      apply_offset
+      apply_limit
+
+      {
+          draw: @parameters[ :draw ] || 1,
+          recordsTotal: @total_records,
+          recordsFiltered: @records_filtered,
+          data: @query.map { |record| @columns.map { |col| col.value( record ) } }
+      }
+    end
+
+    def config_request?
+      @parameters[ 'dt_config' ] == 'true'
+    end
+
+    protected
+    def configuration
+      {
+          columns: @columns.map { |c| c.configuration }
+      }
+    end
+
+    def apply_offset
+      @query = @query.offset( offset )
+    end
+
+    def apply_limit
+      @query = @query.limit( limit )
+    end
+
+    def apply_select
+      @query = @query.select( ExpressionList.new( @columns.map { |c| c.select }.flatten ).to_s )
+    end
+
+    def apply_column_filters
+      conditions = ExprTreeNode.new( 'AND', Type::OPERATOR, true )
+      column_filters.each { |filter| conditions.add_argument filter }
+
+      @query = @query.where( conditions.to_s ) if conditions.arguments?
+    end
+
+    def apply_global_filter
+      unless global_filter?
+        return
+      end
+
+      filter = ExprTreeNode.new( 'OR', Type::OPERATOR, false )
+      global_filter.each { |f| filter.add_argument f }
+
+      if filter.arguments?
+        @query = @query.where( filter.to_s )
+      end
+    end
+
+    def apply_order
+      criteria = order
+
+      if criteria.expression.arguments?
+        @query = @query.order( order.to_s )
+      end
+    end
+
+
+    def offset
+      @parameters[:start] || 0
+    end
+
+    def limit
+      @parameters[:length] || 100
+    end
+
+    def column_filters
+      ( @parameters[:columns] || {} ).to_a.map do |column|
+        filter = ( column.last[ :search ] || { value: nil } )[ :value ]
+
+        if filter.present?
+          @columns[ column.last[:data].to_i ].filter( filter )
+        else
+          nil
+        end
+      end.reject { |v| v.nil? }
+    end
+
+    def global_filter_text
+      (@parameters[ :search ] || { value: nil } )[ :value ]
+    end
+
+    def global_filter?
+      global_filter_text.present?
+    end
+
+    def global_filter
+      @columns.map { |c| c.filter( global_filter_text ) }
+    end
+
+    def order
+      ExpressionList.new(
+          ( @parameters[ :order ] || {} ).values.map { |column|
+            @columns[ column[:column].to_i ].order( column[:dir] )
+          }
+      )
+    end
+  end
+end

data/lib/rails_serverside_datatables/expression_functions.rb

@@ -0,0 +1,33 @@
+require_relative 'expressions'
+
+module RailsServersideDatatables
+
+  def if_then( test_expr, comparison_value, then_expr, else_expr )
+    IfThen.new( test_expr, comparison_value, then_expr, else_expr )
+  end
+
+  def not_null( first, *rest )
+    FirstNotNull.new( first, *rest )
+  end
+
+  def text_cast( expression )
+    CastToText.new( expression )
+  end
+
+  def num_cast( expression )
+    CastToNumeric.new( expression )
+  end
+
+  def num_op( a, op, b )
+    NumOp.new( a, op, b )
+  end
+
+  def expr_alias( expression, name )
+    ExpressionAlias.new( expression, name )
+  end
+
+  def raw_expr( expr )
+    ExprTreeNode.raw expr
+  end
+
+end

data/lib/rails_serverside_datatables/expression_tree_node.rb

@@ -0,0 +1,99 @@
+module RailsServersideDatatables
+  module Type
+    COLUMN = :column
+    STRING = :string
+    NUMERIC = :numeric
+    FUNCTION = :function
+    OPERATOR = :operator
+    NULL = :null
+    RAW = :raw
+  end
+
+  class Nothing
+  end
+
+  class ExprTreeNode
+
+    def initialize(token, type, force_brackets = true)
+      @token = token
+      @type = type
+      @arguments = []
+      @force_brackets = force_brackets
+    end
+
+    def add_argument(argument)
+      @arguments.push ExprTreeNode.create_by_type(argument) unless argument.is_a? Nothing
+    end
+
+    def arguments?
+      @arguments.any?
+    end
+
+    def to_s
+      case @type
+        when Type::RAW
+          return @token.to_s
+        when Type::COLUMN
+          return ExprTreeNode.format_column @token
+        when Type::STRING
+          return ExprTreeNode.format_string @token
+        when Type::NUMERIC
+          return @token.is_a?(Numeric) ? @token.to_s : @token.to_f.to_s
+        when Type::FUNCTION
+          return ExprTreeNode.format_function @token, @arguments
+        when Type::OPERATOR
+          return ExprTreeNode.format_operator @token, @arguments, @force_brackets
+        when Type::NULL
+          return 'NULL'
+        else
+          raise 'Invalid fragment type passed.'
+      end
+    end
+
+    def self.create_by_type(type)
+      if type.is_a? Numeric
+        return ExprTreeNode.new(type, Type::NUMERIC)
+      elsif type.is_a?(Expression)
+        return type.expression
+      elsif type.nil?
+        return raw('NULL')
+      elsif type.is_a? Symbol
+        return ExprTreeNode.new(type, Type::COLUMN)
+      elsif type.is_a? String
+        return ExprTreeNode.new(type, Type::STRING)
+      elsif type.is_a? ExprTreeNode
+        return type
+      elsif type.is_a? Array
+        f = ExprTreeNode.new('||', Type::OPERATOR)
+        type.each { |e| f.add_argument e }
+        return f
+      else
+        raise 'Invalid type'
+      end
+    end
+
+    def self.raw(expr)
+      ExprTreeNode.new(expr.to_s, Type::RAW)
+    end
+
+    private
+
+    def self.format_column(name)
+      name.to_s.split('.').map { |f| '"' + f + '"' }.join '.'
+    end
+
+    def self.format_string(name)
+      "#{ActiveRecord::Base.sanitize name}"
+    end
+
+    def self.format_function(name, arguments)
+      name.to_s.upcase + '(' + arguments.map { |arg| arg.to_s }.join(',') + ')'
+    end
+
+    def self.format_operator(operator, arguments, brackets)
+      term = arguments.map { |arg| arg.to_s }.join(" #{operator} ")
+
+      brackets ? '(' + term + ')' : term
+    end
+  end
+end

data/lib/rails_serverside_datatables/expressions.rb

@@ -0,0 +1,118 @@
+require_relative 'expression_tree_node'
+
+module RailsServersideDatatables
+  class Expression
+    attr_reader :expression
+
+    def to_s
+      expression.to_s
+    end
+
+    protected
+    def raw( expr )
+      ExprTreeNode.raw(expr )
+    end
+  end
+
+  class IfThen < Expression
+
+    def initialize( testexpr, comparison_val, thenexpr, elseexpr )
+      expression = ExprTreeNode.new('', Type::OPERATOR ) # Concat the statements only
+
+      expression.add_argument raw( 'CASE' )
+      expression.add_argument testexpr
+
+      if comparison_val.nil?
+        expression.add_argument raw( 'IS NULL' )
+        comparison_val = raw( true )
+      end
+
+      expression.add_argument raw( 'WHEN' )
+      expression.add_argument comparison_val
+      expression.add_argument raw( 'THEN' )
+      expression.add_argument thenexpr
+      expression.add_argument raw( 'ELSE' )
+      expression.add_argument elseexpr
+      expression.add_argument raw( 'END' )
+
+      @expression = expression
+    end
+  end
+
+  class FirstNotNull < Expression
+    def initialize( test_value, *default )
+      f = ExprTreeNode.new(:coalesce, Type::FUNCTION )
+      f.add_argument test_value
+
+      default.each { |d|  f.add_argument d }
+      @expression = f
+    end
+  end
+
+  class CastToText < Expression
+    def initialize( expression )
+      f = ExprTreeNode.new('::', Type::OPERATOR )
+      f.add_argument expression
+      f.add_argument raw( 'text' )
+      @expression = f
+    end
+  end
+
+  class CastToNumeric < Expression
+    def initialize( expression )
+      f = ExprTreeNode.new('::', Type::OPERATOR )
+      f.add_argument expression
+      f.add_argument raw( 'numeric' )
+      @expression = f
+    end
+  end
+
+  class ExpressionAlias < Expression
+    def initialize( expression, name )
+      f = ExprTreeNode.new('AS', Type::OPERATOR, false )
+      f.add_argument expression
+      f.add_argument name
+
+      @expression = f
+    end
+  end
+
+  class FilterByText < Expression
+    def initialize( expression, query )
+      f = ExprTreeNode.new('ILIKE', Type::OPERATOR, false )
+      f.add_argument CastToText.new( expression )
+      f.add_argument "%#{query}%"
+
+      @expression = f
+    end
+  end
+
+  class OrderBy < Expression
+    def initialize( expression, direction = :ASC )
+      f = ExprTreeNode.new('', Type::OPERATOR, false )
+      f.add_argument expression
+      f.add_argument ExprTreeNode.raw( direction.to_s.downcase == 'desc' ? 'DESC' : 'ASC' )
+
+      @expression = f
+    end
+  end
+
+  class ExpressionList < Expression
+    def initialize( expressions )
+      f = ExprTreeNode.new(',', Type::OPERATOR, false )
+      expressions.each { |expr| f.add_argument expr }
+
+      @expression = f
+    end
+  end
+
+  class NumOp < Expression
+    def initialize( a, op, b )
+      f = ExprTreeNode.new( op.to_s, Type::OPERATOR )
+      f.add_argument CastToNumeric.new( a )
+      f.add_argument CastToNumeric.new( b )
+
+      @expression = f
+    end
+  end
+end

data/lib/rails_serverside_datatables/views/datatable.html.erb

@@ -0,0 +1,43 @@
+<table<%= config.to_a.map { |attr| " #{attr.first}=\"#{h attr.last}\""}.join ' ' %>>
+  <thead>
+    <% columns.each do |column| %>
+    <th><%= column[:display_name] %></th>
+    <% end %>
+  </thead>
+  <tbody></tbody>
+  <% if filterable.any? %>
+  <tfoot>
+    <% columns.each do |column| %>
+    <th>
+      <% if column[:column_filtering] %>
+        <input type="text" placeholder="<%= column[:display_name] %>" id="<%=h config[:id] %>-column-filter-<%=h column[:name] %>" />
+      <% else %>
+        &nbsp;
+      <% end %>
+    </th>
+    <% end %>
+  </tfoot>
+  <% end %>
+</table>
+
+<script type="text/javascript">
+  $(document).ready( function() {
+      var table = $('#<%= config[:id] %>').DataTable({
+          ajax: "<%=h serverside_path %>",
+          serverSide: true,
+          processing: true
+      });
+
+      <% if filterable.any? %>
+      table.columns().every( function () {
+          var that = this;
+
+          $( 'input', this.footer() ).on( 'keyup change', function () {
+              if ( that.search() !== this.value ) {
+                  that.search( this.value ).draw();
+              }
+          } );
+      } );
+      <% end %>
+  });
+</script>

data/lib/rails_serverside_datatables/views/railtie.rb

@@ -0,0 +1,9 @@
+require_relative 'view_helpers'
+
+module RailsServersideDatatables
+  class Railtie < Rails::Railtie
+    initializer 'rails_serverside_datatables.view_helpers' do
+      ActionView::Base.send :include, ViewHelpers
+    end
+  end
+end

data/lib/rails_serverside_datatables/views/view_helpers.rb

@@ -0,0 +1,53 @@
+module RailsServersideDatatables
+
+  module ViewHelpers
+    def serverside_datatable( serverside_path, id, config = {}, parameters = {} )
+      # Our table requires an id
+      config[ :id ] = id
+
+      # Fetch the internal definition of the table
+      raw_configuration = serverside_datatable_config_request( serverside_path, parameters )
+
+      columns = []
+      begin
+        # Try to parse the (hopefully) JSON encoded response
+        configuration = JSON.parse( raw_configuration )
+
+        # Parse column information
+        configuration[ 'columns' ].each do |column|
+          columns.push( column.to_a.map { |f| [f.first.to_sym, f.last] }.to_h )
+        end
+
+      rescue Exception => e
+        raise 'Auto config failed - invalid response. Could not parse response. Details: ' + e.message
+      end
+
+      # Required in erb file...
+      filterable = columns.select { |c| c[:column_filtering] }
+
+
+      # Render the actual content
+      ERB.new(
+          File.read( File.dirname( __FILE__ ) + '/datatable.html.erb' )
+      ).result( binding ).html_safe
+    end
+
+    private
+    def serverside_datatable_config_request( url, parameters )
+      parameters[ 'dt_config'  ]   = true
+
+      # Route request internally
+      request = Rack::MockRequest.env_for(
+          url, params: parameters.to_query
+      ).merge({ 'rack.session': session })
+
+      # Fetch configuration from the serverside definition
+      response = Rails.application.routes.call( request )
+
+      raise 'Auto config failed - invalid response. HTTP error code: ' + response.first unless response.first == 200
+
+      # Return the acutal content
+      response.last.body
+    end
+  end
+end

data/rails_serverside_datatables.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rails_serverside_datatables'
+  spec.version       = '0.1.1'
+  spec.authors       = ['Oskar Kirmis']
+  spec.email         = ['kirmis@st.ovgu.de']
+
+  spec.summary       = %q{This gem allows you to implement serverside processing (filtering and sorting) easily for datatables, even with computed columns.}
+  spec.description   = %q{This gem allows you to implement serverside processing (filtering and sorting) easily for datatables, even with computed columns. That allows you to perform filtering and sorting on complex expressions on database level while being very easy to use when this complexity is not required.}
+  spec.homepage      = 'https://git.iftrue.de/okirmis/rails_serverside_datatables'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '>= 4.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: rails_serverside_datatables
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Oskar Kirmis
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: This gem allows you to implement serverside processing (filtering and
+  sorting) easily for datatables, even with computed columns. That allows you to perform
+  filtering and sorting on complex expressions on database level while being very
+  easy to use when this complexity is not required.
+email:
+- kirmis@st.ovgu.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rails_serverside_datatables.rb
+- lib/rails_serverside_datatables/column.rb
+- lib/rails_serverside_datatables/data_table.rb
+- lib/rails_serverside_datatables/expression_functions.rb
+- lib/rails_serverside_datatables/expression_tree_node.rb
+- lib/rails_serverside_datatables/expressions.rb
+- lib/rails_serverside_datatables/views/datatable.html.erb
+- lib/rails_serverside_datatables/views/railtie.rb
+- lib/rails_serverside_datatables/views/view_helpers.rb
+- rails_serverside_datatables.gemspec
+homepage: https://git.iftrue.de/okirmis/rails_serverside_datatables
+licenses:
+- MIT
+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.6.10
+signing_key: 
+specification_version: 4
+summary: This gem allows you to implement serverside processing (filtering and sorting)
+  easily for datatables, even with computed columns.
+test_files: []