ajax-datatables-rails-alt-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 633a87bfa8ebe8db19aa7d3a44f1a0f8765f7b8fb3896cc1500f02497a7695ab
+  data.tar.gz: cca2fac25cd0e05b640a294af7b8a7a5adf22fecb36f303753b39d562ab6bc69
+SHA512:
+  metadata.gz: fcdd7838a0ee3548681031d4bcd915d596d76694f5494b4414d115993a94df74f541296ac89228f99d081017abbb9e362d00cfbd1451407b7e273c741a1c7e8d
+  data.tar.gz: fef94a972f61f816a420229e44043a9d24f9ee4ce7bacb79974f2a5247a567e4fe732786b2ac8daf7f86c0748624436fe7a3f8e22ce336154af022f75d6b9473

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.1
+before_install: gem install bundler -v 2.0.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## 0.1.0
+
+* Inital version

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,98 @@
+PATH
+  remote: .
+  specs:
+    ajax-datatables-rails-alt-api (0.1.0)
+      ajax-datatables-rails (~> 1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (5.2.3)
+      actionview (= 5.2.3)
+      activesupport (= 5.2.3)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.2.3)
+      activesupport (= 5.2.3)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    ajax-datatables-rails (1.0.0)
+      railties (>= 4.2)
+    builder (3.2.3)
+    byebug (11.0.1)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.5)
+    crass (1.0.4)
+    diff-lcs (1.3)
+    erubi (1.8.0)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    loofah (2.2.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (0.9.2)
+    mini_portile2 (2.4.0)
+    minitest (5.11.3)
+    nokogiri (1.10.3)
+      mini_portile2 (~> 2.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.7.0)
+      byebug (~> 11.0)
+      pry (~> 0.10)
+    rack (2.0.7)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
+    railties (5.2.3)
+      actionpack (= 5.2.3)
+      activesupport (= 5.2.3)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.19.0, < 2.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    thor (0.20.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ajax-datatables-rails-alt-api!
+  bundler (~> 2.0)
+  pry (~> 0.12)
+  pry-byebug (~> 3)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.0.1

data/README.md

@@ -0,0 +1,68 @@
+# AjaxDatatablesRails::AltApi
+
+This is an alternative API to the `ajax-datatables-rails gem`. The motivation for this was that we had a lot of datatables written agains an older version of ajax-datatables-rails. The newer version of ajax-datatables-rails was incompatible with our older implementation of datatables, so it required a major refactor effort. There were certain things in the recent ajax-datatables-rails API felt redundant, and if a major refactor was needed, a reimagined API started to be devloped.
+
+This uses ajax-datatables-rails under the hood. Idealy, this or something similar may influence future versions of ajax-datatables-rails.
+
+## Features
+
+There are some additional features this API provides.
+
+* Makes it easy to define the column definitions in the client JS. The column definitions are based on the same definitions that you declare in the datatable.
+* Cells rendering automatically can delegate to the record or view. So the cell rendering blocks can easily access method defined on the view or the record.
+* Columns are defined once, with the goal of reducing redundancy.
+* Debugging mismatch problems with jQuery datatables can be frustrating. There is some code to help debug these tricky situations. There are still many improvements that can be done with this, but it is a start.
+
+## Usage
+
+Inside your application datatable or the individual datatables, include the module.
+
+```Ruby
+class ApplicationDatatable < AjaxDatatablesRails::ActiveRecord
+  include AjaxDatatablesRails::AltApi
+end
+```
+
+Example datatable:
+
+```Ruby
+class UserDatatable < ApplicationDatatable
+  base_model 'User'
+
+  # The default behavior is that the column is searchable, sortable, and renders the value.
+  column(:first_name)
+  # Column names can be arbitrary. This example references a relationship
+  # alternatively, the block can be more explicit { |user| user.company.name } or { record.company.name }
+  column(:company_name, source: 'Company.name') { company.name }
+  column(:address, display_only: true) { format_address(address) }
+
+  # This example auto uses both the view's `l` method and `updated_at` (from the user record)
+  column(:updated_at, searchable: false) { l(updated_at, :short) }
+  # In this example, `:links` is not tied to the record. So `display_only` is used so it is not searchable or sortable.
+  # You can call `record` in the block to refer to the record passed to the cell renderer.
+  column(:links, display_only: true) { link_to("Show", user_path(record)) }
+
+
+  # assuming there is an address relationship to the user, you could expose searchable attrs this way
+  search_only_attributes %w[Address.city
+                            Address.state_name
+                            Address.country
+                            Address.country_name
+                            Address.postal_code]
+
+  # some method called by a cell renderer block
+  def format_address(address)
+    # makes the address pretty
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ajax-datatables-rails-alt-api.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ajax-datatables-rails-alt-api.gemspec

@@ -0,0 +1,45 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ajax-datatables-rails/alt-api/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ajax-datatables-rails-alt-api"
+  spec.version       = AjaxDatatablesRails::AltApi::VERSION
+  spec.authors       = ["Sean McCleary"]
+  spec.email         = ["seanmcc@gmail.com"]
+
+  spec.summary       = %q{This is an alternate API to ajax-datatables-rails.}
+  spec.description   = <<~DESCRIPTION
+    The goal of this gem is to provide a backwards compatible extension of the
+    ajax-datatables-rails gem that provides an alternate API that reduces
+    duplication.
+  DESCRIPTION
+  spec.homepage      = "https://github.com/Shipstr/fleet/#{spec.name}"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = spec.homepage
+    spec.metadata["changelog_uri"] = "https://raw.githubusercontent.com/fleet/#{spec.name}/master/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |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 "ajax-datatables-rails", "~> 1.0.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.12"
+  spec.add_development_dependency "pry-byebug", "~> 3"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ajax/datatables/rails/alt/api"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ajax-datatables-rails/alt-api/datatable.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'ajax-datatables-rails/alt-api/datatable/column_def'
+require 'ajax-datatables-rails/alt-api/datatable/view_columns'
+
+module AjaxDatatablesRails
+  module AltApi
+    # Just include this in your application datatable
+    # `include 'ajax-datatables-rails/alt-api/datatable'`
+    module Datatable
+      def self.included(base)
+        base.extend(ClassMethods)
+
+        extend Forwardable
+
+        attr_reader :view, :current_record
+        alias_method :record, :current_record
+        alias_method :r, :record
+      end
+
+      # module class methods
+      module ClassMethods
+        # This is the primary ActiveRecord model the datatable represents.
+        # For example, if you have writing a UserDatatable, and that is
+        # a list of User records, 'User' would be the base model.
+        def base_model(model_class)
+          @base_model = model_class
+        end
+
+        # This adds a ColumnDef to the columns. Order in which column is called
+        # is important. The column order is the same as they will be returned
+        # to the client. To see a full list of options, see the ColumnDef class.
+        def column(*new_column_args, &block)
+          columns << ColumnDef.new(*new_column_args, &block)
+        end
+
+        def columns
+          @columns ||= []
+        end
+
+        # Use this in the `columns` option in the JS initialization of Datatable.
+        # Call this method in the view.
+        # There are times that when conditionally showing columns, the column
+        # conditionals need access to the datatable instance.
+        # Example:
+        #   <table data-datatable-columns="<%= UsersDatatable.js_columns %>">
+        #     <th>Name</th>
+        #     <th>Email</th>
+        #   </table>
+        #   <script>
+        #     var table = $('#my-datatable');
+        #     table.DataTable({
+        #       columns: JSON.parse(table.data('datatable-columns'))
+        #     })
+        #   </script>
+        def js_columns(only: [], exclude: [])
+          cols = if only.present?
+                   columns.select { |c| only.include?(c.attr_name) }
+                 elsif exclude.present?
+                   columns.reject { |c| exclude.include?(c.attr_name) }
+                 else
+                   columns
+                 end
+          cols.reject! { |c| c.attr_name.to_s.starts_with?('search_only') }
+          cols.map(&:as_json).compact.to_json
+        end
+
+        # This is used for tests
+        def column_params
+          new({}).columns.map(&:as_json).each_with_index.reduce({}) do |accum, (h, i)|
+            accum[i] = { **h, search: { value: '', regex: 'false' } }
+            accum
+          end
+        end
+
+        def search_only_attributes(attrs)
+          attrs.each do |attr|
+            key_name = :"search_only__#{attr.downcase.tr('.', '_')}"
+            columns << ColumnDef.new(key_name, source: attr, search_only: true)
+          end
+        end
+      end
+
+      def initialize(params, opts = {})
+        @view = opts[:view_context]
+        super
+      end
+
+      # applies the current datatable instance to the columns
+      def columns
+        @columns ||= self.class.columns.each { |c| c.datatable = self }
+      end
+
+      # There are times that when conditionally showing columns, the column
+      # conditionals need access to the datatable instance.
+      def js_columns(only: [], exclude: [])
+        columns
+        self.class.js_columns(only: only, exclude: exclude)
+      end
+
+      def base_model
+        self.class.instance_variable_get(:@base_model)
+      end
+
+      def view_columns
+        raise NotImplementedError, 'Columns not defined' if columns.empty?
+
+        @view_columns ||= begin
+          columns.each_with_object(ViewColumns.new) do |col, cols|
+            cols[col.attr_name] = col.view_column
+            cols
+          end
+        end
+      end
+
+      def data
+        raise NotImplementedError if columns.empty?
+
+        records_with_error_logging.map do |record|
+          @current_record = record
+          delegate_to_view_and_record(record)
+
+          columns.each_with_object({}) do |col, row|
+            row[col.attr_name] = col.render(record)
+            row
+          end
+        end
+      end
+
+      def delegate_to_view_and_record(record) # rubocop:disable Lint/MethodLength,Lint/UnusedMethodArgument
+        singleton_class.class_eval do
+          def method_missing(meth, *args)
+            if record.respond_to?(meth)
+              record.send(meth, *args)
+            elsif view.respond_to?(meth)
+              view.send(meth, *args)
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(meth, _include_all)
+            record.respond_to?(meth) || view.respond_to?(meth) || super
+          end
+        end
+      end
+
+      # There are some hard to debug scenarios that come up with ajax-datatables-rails.
+      # This helps debug some problems. Usually the bug is caused by some mismatched
+      # expectation between what the view_columns are and how it is being used.
+      def records_with_error_logging
+        @records ||= records
+      rescue NoMethodError => e
+        if e.name == :fetch && e.receiver.nil?
+          Rails.logger.error "#{self.class.name} column problem. view_columns: #{view_columns.pretty_inspect}"
+        end
+        raise e
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/alt-api/datatable/column_def.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  module AltApi
+    module Datatable
+      # This is a datatable column definition
+      class ColumnDef
+        ColumnDefError = Class.new(StandardError)
+
+        attr_reader :attr_name, :source, :sortable, :visible, :searchable,
+                    :search_only, :cond, :cell_renderer, :condition
+        attr_accessor :datatable
+
+        def initialize(attr_name, # rubocop:disable Metrics/ParameterLists,Metrics/AbcSize
+                       source: nil,
+                       sortable: true,
+                       visible: true,
+                       searchable: true,
+                       condition: nil,
+                       cond: :like,
+                       search_only: false,
+                       display_only: false,
+                       &cell_renderer)
+          @attr_name = attr_name
+          @source = source
+          if display_only
+            visible = true
+            searchable = false
+            sortable = false
+          end
+          if search_only
+            visible = false
+            searchable = true
+            sortable = false
+          end
+          @condition = condition
+          @visible = visible
+          @sortable = visible ? sortable : false
+          @cell_renderer = cell_renderer
+          @searchable = searchable
+          @search_only = search_only
+          @cond = cond
+          @datatable = nil
+        end
+
+        # Used to serialize options passed to the JS datatable initializer columns
+        def as_json
+          if condition_met?
+            {data: attr_name, visible: visible, sortable: sortable}
+          end
+        end
+
+        def view_column
+          {source: search_source,
+           orderable: to_bool(sortable),
+           searchable: to_bool(searchable),
+           cond: cond}
+        end
+
+        def render?
+          visible && condition_met?
+        end
+
+        def render(record) # rubocop:disable Metrics/AbcSize
+          return unless render?
+
+          if cell_renderer
+            if cell_renderer.arity == 1
+              datatable.instance_exec(record, &cell_renderer)
+            else
+              datatable.instance_exec(&cell_renderer)
+            end
+          elsif record.respond_to?(attr_name)
+            record.send(attr_name)
+          else
+            raise ColumnDefError, "Unable to render #{attr_name} for datatable: #{datatable.class.name}"
+          end
+        end
+
+        private
+
+        def search_source
+          base_model = datatable.base_model
+          src = source
+          src ||= "#{base_model}.#{attr_name}" if base_model
+          unless src
+            raise ColumnDefError, "Unable to infer source for column #{attr_name}"
+          end
+
+          src
+        end
+
+        def condition_met?
+          if condition.present? && condition.is_a?(Proc)
+            unless datatable
+              raise ColumnDefError, "`datatable` is nil when evaling condition: #{attr_name}"
+            end
+
+            datatable.instance_exec(&condition)
+          else
+            true
+          end
+        end
+
+        def to_bool(val)
+          if val.is_a?(Proc)
+            datatable.instance_exec(&val)
+          else
+            val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/alt-api/datatable/view_columns.rb

@@ -0,0 +1,17 @@
+module AjaxDatatablesRails
+  module AltApi
+    module Datatable
+      # DataTables can be really tricky to debug when attributes don't align.
+      # I added this to help a little
+      class ViewColumns < Hash
+        def [](key)
+          super(key).tap do |r|
+            if r.nil?
+              Rails.logger.warn "-- Datatable view column key missing: #{key}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module AjaxDatatablesRails
+  module AltApi
+    VERSION = '0.1.0'.freeze
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'ajax-datatables-rails'
+require 'ajax-datatables-rails/alt-api/version'
+require 'ajax-datatables-rails/alt-api/datatable'
+
+module AjaxDatatablesRails
+  # This is an alternate API for ajax_datatables_rails
+  module AltApi
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: ajax-datatables-rails-alt-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sean McCleary
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-05-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ajax-datatables-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: |
+  The goal of this gem is to provide a backwards compatible extension of the
+  ajax-datatables-rails gem that provides an alternate API that reduces
+  duplication.
+email:
+- seanmcc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- ajax-datatables-rails-alt-api.gemspec
+- bin/console
+- bin/setup
+- lib/ajax-datatables-rails/alt-api/datatable.rb
+- lib/ajax-datatables-rails/alt-api/datatable/column_def.rb
+- lib/ajax-datatables-rails/alt-api/datatable/view_columns.rb
+- lib/ajax-datatables-rails/alt-api/version.rb
+- lib/ajax-datatables-rails/alt_api.rb
+homepage: https://github.com/Shipstr/fleet/ajax-datatables-rails-alt-api
+licenses: []
+metadata:
+  homepage_uri: https://github.com/Shipstr/fleet/ajax-datatables-rails-alt-api
+  source_code_uri: https://github.com/Shipstr/fleet/ajax-datatables-rails-alt-api
+  changelog_uri: https://raw.githubusercontent.com/fleet/ajax-datatables-rails-alt-api/master/CHANGELOG.md
+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: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: This is an alternate API to ajax-datatables-rails.
+test_files: []