data_tables-responder 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b8e8b8bde92df9cf464672c0272403a5b10025e
-  data.tar.gz: f777b05dc78a0b3e2e5cc6cbeeb021069502b162
+  metadata.gz: e79c11cbef86746b623368d109260dbc13752ba5
+  data.tar.gz: 7420babe2bad5e577d259f337d52edce56c6c54b
 SHA512:
-  metadata.gz: a50cabb76cb4539b913fd7a4d839fec3400dfa3a3862a51a1a0106234b2dd4c81a225abe823670ffc300eba6edee6e690ff64d9c47e575c7ab2b8f51402f1927
-  data.tar.gz: d6a683c1f43ad56869ec4d4adcfed6aec6a785c898e84f57ae9d742f38444632486bb08ecf4465a2f62014b8ef429313f4c1a626e322a1b28827c2467c513196
+  metadata.gz: 628bb80e343d030ed42a07735b38c841231cc9b14c3b74dede6e308af88e97b073e38e53aa469b829b7999ca7654c537b54a187b695906d4af530e21df27b02d
+  data.tar.gz: 0049ae6598ae3ac3eaa0bd1c15d343f49f72cf99264434f96e5dae80375e293e25c8bb56bd14109e66ccd88d85dedc4b0606dd86c4426c5c5b5131663880fa30

data/data_tables-responder.gemspec

@@ -26,9 +26,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  rails_versions = ['>= 4.1', '< 6']
+
   spec.add_dependency 'active_model_serializers', '~> 0.10.4'
-  spec.add_dependency 'count_estimate'
+  spec.add_dependency 'railties', rails_versions
+  spec.add_dependency 'quick_count', ['>= 0.0.3', '< 0.1.0']
 
+  spec.add_development_dependency 'activerecord', rails_versions
+  spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'bundler', '~> 1.12'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'

data/lib/data_tables/active_model_serializers/adapter/pagination.rb

@@ -29,15 +29,16 @@ module DataTables
         private
 
         def get_records_filtered
-          if records_total < 1_000_000
-            @collection.unscope(:limit, :offset).count(@collection.model.primary_key).to_i
+          to_filter = @collection.unscope(:limit, :offset)
+          if !to_filter.respond_to?(:count_estimate) || records_total < 1_000_000
+            to_filter.count(@collection.model.primary_key).to_i
           else
-            @collection.unscope(:limit, :offset).count_estimate.to_i
+            to_filter.count_estimate.to_i
           end
         end
 
         def get_records_total
-          count = @collection.model.all.count_estimate.to_i
+          count = @collection.model.quick_count
           if count < 1_000_000
             count = @collection.model.all.count(@collection.model.primary_key).to_i
           end

data/lib/data_tables/modules/order.rb

@@ -0,0 +1,63 @@
+module DataTables
+  module Modules
+    class Order
+
+      attr_reader :scope, :context
+
+      def initialize(scope, request_parameters)
+        @scope = scope.dup
+        @request_parameters = request_parameters
+      end
+
+      def order
+        # default_order = @request_parameters.dig(:order, :value)
+
+        model = @scope.try(:model) || @scope
+        columns = orderable_columns(@request_parameters[:order], @request_parameters[:columns])
+
+        orders = DataTables::Responder.flat_keys_to_nested columns
+
+        order_by, join_hash = build_order(model, orders)
+
+        @scope = @scope.joins(join_hash)
+
+        order_by.inject(@scope) { |r, o| r.order(o) }
+      end
+
+      def build_order(model, in_hash, join_hash = nil)
+        # Tuple!
+        return in_hash.inject([]) { |sum, (k, h)|
+          case h
+          when Hash
+            if (klass = model.reflect_on_association(k).try(:klass))
+
+              new_sum, join_class = build_order(klass, h)
+
+              join_hash = join_class.nil? ? [k] : {k => join_class}
+
+              sum += new_sum
+            else
+              warn("trying to reflect on #{k} but #{model.class.name} has no such association.")
+            end
+          else
+            sum << model.arel_table[k].send(h) if model.column_names.include?(k.to_s)
+          end
+          sum
+        }, join_hash
+      end
+
+      protected
+
+      def orderable_columns(orders, columns)
+        sums = {}
+        (orders || []).inject(sums) do |sum, order|
+          if (name = columns[order[:column]][:data]).present?
+            sum[name] = order[:dir]
+          end
+        end
+        sums
+      end
+
+    end
+  end
+end

data/lib/data_tables/modules/pagination.rb

@@ -1,4 +1,3 @@
-require 'count_estimate'
 
 module DataTables
   module Modules

data/lib/data_tables/modules/search.rb

@@ -2,67 +2,71 @@ module DataTables
   module Modules
     class Search
 
-      attr_reader :collection, :context
+      attr_reader :scope, :context
 
-      def initialize(collection, request_parameters)
-        @collection = collection
+      def initialize(scope, request_parameters)
+        @scope = scope
         @request_parameters = request_parameters
       end
 
       def search
         default_search = @request_parameters.dig(:search, :value)
 
-        model = @collection.try(:model) || @collection
-        arel_table = model.arel_table
+        model = @scope.try(:model) || @scope
         columns = searchable_columns(default_search)
 
         searches = DataTables::Responder.flat_keys_to_nested columns
 
-        search_by = build_search(model, searches)
+        search_by, join_hash = build_search(model, searches)
 
-        @collection.where(search_by.reduce(:and))
-      end
+        @scope = @scope.joins(join_hash)
 
-      def build_search(model, searches)
-        # join_type = Arel::Nodes::OuterJoin
-        join_type = Arel::Nodes::InnerJoin
+        @scope.where(search_by.reduce(:and))
+      end
 
-        searches.inject([]) do |queries, junk|
-          column, query = junk
+      def build_search(model, in_hash, join_hash = nil)
+        # Tuple!
+        return in_hash.inject([]) { |queries, (column, query)|
           case query
           when Hash
-            assoc = model.reflect_on_association(column)
-            assoc_klass = assoc.klass
-
-            join = join_type.new(assoc_klass.arel_table,
-              Arel::Nodes::On.new(
-                model.arel_table[assoc.foreign_key].eq(assoc_klass.arel_table[assoc.active_record_primary_key])
-            ))
-            @collection = @collection.joins(join)
-            queries << build_search(assoc_klass, query).reduce(:and)
+            if (assoc = model.reflect_on_association(column))
+              new_queries, join_class = build_search(assoc.klass, query)
+
+              join_hash = join_class.nil? ? [column] : {column => join_class}
+
+              queries << new_queries.reduce(:and)
+            else
+              warn("trying to reflect on #{column} but #{model.class.name} has no such association.")
+            end
           else
-            col_s = column.to_s
-            case (k = model.columns.find(nil) { |c| c.name == col_s })&.type
-            when :string
-              # I'm pretty sure this is safe from SQL Injection
-              queries << model.arel_table[k.name].matches("%#{query}%")
-            when :integer
-              if value = query&.to_i
-                queries << model.arel_table[k.name].eq(value)
-              end
-            when :datetime
-              datetime = Time.parse(query)
-              range = (datetime-1.second)..(datetime+1.second)
-              queries << model.arel_table[k.name].between(range)
+            search_by_type(model, column, query) do |result|
+              queries << result
             end
           end
-
           queries
-        end
+        }, join_hash
       end
 
       protected
 
+      def search_by_type(model, column, query, &block)
+        result = case model.columns_hash[column.to_s]&.type
+        when :string
+          # I'm pretty sure this is safe from SQL Injection
+          model.arel_table[column].matches("%#{query}%")
+        when :integer
+          model.arel_table[column].eq(value) if value = query&.to_i
+        when :datetime
+          datetime = Time.parse(query)
+          range = (datetime-1.second)..(datetime+1.second)
+          model.arel_table[column].between(range)
+        end
+
+        yield(result) if !result.nil? && block_given?
+
+        result
+      end
+
       def searchable_columns(default_search)
         @searchable_columns = {}
         @request_parameters[:columns]&.inject(@searchable_columns) do |a, b|
@@ -77,8 +81,6 @@ module DataTables
         @searchable_columns
       end
 
-      private
-
     end
   end
 end

data/lib/data_tables/responder/railtie.rb

@@ -1,6 +1,7 @@
 require 'rails/railtie'
 require 'action_controller'
 require 'action_controller/railtie'
+require 'quick_count/railtie'
 
 module DataTables
   module Responder

data/lib/data_tables/responder/version.rb

@@ -1,5 +1,5 @@
 module DataTables
   module Responder
-    VERSION = '0.3.2'
+    VERSION = '0.4.0'
   end
 end

data/lib/data_tables/responder.rb

@@ -1,7 +1,9 @@
+require 'data_tables'
 require "data_tables/responder/version"
 
 require 'data_tables/modules/pagination'
 require 'data_tables/modules/search'
+require 'data_tables/modules/order'
 
 require 'data_tables/active_model_serializers/adapter'
 require 'data_tables/responder/railtie' if defined? ::Rails::Railtie
@@ -12,26 +14,14 @@ module DataTables
     def self.respond(original_scope, params)
       model = original_scope.try(:model) || original_scope
 
-      filtered_results = original_scope&.dup || model.none
-      hashed_orders = transmute_datatable_order(params[:order], params[:columns])
-      orders = flat_keys_to_nested hashed_orders
+      filtered_scope = original_scope&.dup || model.none
 
-      order_by = orders.collect do |k, order|
-        if order.is_a? Hash
-          if (klass = model.reflect_on_association(k).try(:klass))
-            filtered_results = filtered_results.joins(k)
-            klass.arel_table[order.first.first].send(order.first.last)
-          end
-        else
-          { k => order }
-        end
-      end
+      filtered_scope = order(filtered_scope, params)
 
-      filtered_results = search(filtered_results, params)
+      filtered_scope = search(filtered_scope, params)
 
       # Rails.logger.warn "SEARCH BY: #{search_by}"
-      filtered_results = order_by.inject(filtered_results) { |r, o| r.order(o) }
-      filtered_results = paginate(original_scope, filtered_results, params)
+      filtered_scope = paginate(original_scope, filtered_scope, params)
     end
 
     def self.flat_keys_to_nested(hash)
@@ -42,27 +32,17 @@ module DataTables
       end
     end
 
-
-    def self.paginate(original_scope, filtered_results, params)
-      Modules::Pagination.new(original_scope, filtered_results, params).paginate
+    def self.paginate(original_scope, filtered_scope, params)
+      Modules::Pagination.new(original_scope, filtered_scope, params).paginate
     end
 
-    def self.search(filtered_results, params)
-      Modules::Search.new(filtered_results, params).search
+    def self.search(filtered_scope, params)
+      Modules::Search.new(filtered_scope, params).search
     end
 
-    def self.transmute_datatable_order(orders, columns)
-      Hash[if orders.is_a? Array
-        orders.collect do |order|
-          if (name = columns[order[:column]][:data]).present?
-            [name, order[:dir]]
-          else
-            nil
-          end
-        end
-      else
-        []
-      end.compact]
+    def self.order(filtered_scope, params)
+      Modules::Order.new(filtered_scope, params).order
     end
+
   end
 end

data/lib/data_tables.rb

@@ -0,0 +1,6 @@
+
+module DataTables
+  def self.root
+    @root ||= Pathname.new(File.dirname(File.expand_path(File.dirname(__FILE__), '/../')))
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_tables-responder
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Dale Stevens
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-01 00:00:00.000000000 Z
+date: 2017-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -25,14 +25,74 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.10.4
 - !ruby/object:Gem::Dependency
-  name: count_estimate
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
   type: :runtime
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: quick_count
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -96,10 +156,12 @@ files:
 - bin/console
 - bin/setup
 - data_tables-responder.gemspec
+- lib/data_tables.rb
 - lib/data_tables/active_model_serializers/adapter.rb
 - lib/data_tables/active_model_serializers/adapter/meta.rb
 - lib/data_tables/active_model_serializers/adapter/pagination.rb
 - lib/data_tables/active_model_serializers/register_dt_renderer.rb
+- lib/data_tables/modules/order.rb
 - lib/data_tables/modules/pagination.rb
 - lib/data_tables/modules/search.rb
 - lib/data_tables/responder.rb