dbee-active_record 2.0.1 → 2.1.0.pre.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ff03ff4358df26cd80685c990ec5c24d2998988c5766d39bace3961f0902caa
-  data.tar.gz: 282d6172b8b6ae6cf809711f271938c2dabd0fcf5dd2dd377aab3acd53cd83d3
+  metadata.gz: 75d42ea7f3b391ad5014264a4b914339bf7dff8582aebe85c4c3180576ae7648
+  data.tar.gz: e63553d0dcc906a38b336767dfcf10bcc162807682ae866f4450a80185993b8e
 SHA512:
-  metadata.gz: 920601f06a18f8bf4b8ad450b4ecda4a484059ee7ccc0afee2cff955c10b9098303332ba121cc638a0e9ba925b5067c24ecdd7c8e6beb8a339448182f2a5f0de
-  data.tar.gz: 25811b6619d35c0373f62f9061a15ed5e3574010969b7b5bbefae9110c9194a870704365248309bc8cc49a5c4770af0d6ede7fc9a9cacc01c550f1f3c709d8e7
+  metadata.gz: f727e65305615a6e5b2450654ce4bb174674970be4b6855922035dac6bc8378862a003f0c1ec4677433d560dee4f5ca3b9094b57a4be8eae6a7d78720c805910
+  data.tar.gz: 21d91630d8ba8407550dcdd6d8a7aab9bc7dc52ad39679ed5b673f59263f2761e55505c61b8cafcc2ce09a31fee1571e58e9fffc76b24f1dd7a5d3d62e3b4ef7

data/.rubocop.yml

@@ -1,6 +1,20 @@
-Metrics/LineLength:
+AllCops:
+  TargetRubyVersion: 2.5
+
+Layout/LineLength:
   Max: 100
 
+Lint/RaiseException:
+  Enabled: True
+
+Lint/StructNewOverride:
+  Enabled: True
+
+Metrics/AbcSize:
+  Max: 16
+  Exclude:
+    - spec/db_helper.rb
+
 Metrics/BlockLength:
   ExcludedMethods:
     - let
@@ -13,18 +27,19 @@ Metrics/BlockLength:
     - spec/dbee/**/*
     - dbee-active_record.gemspec
 
+Metrics/ClassLength:
+  Max: 125
+
 Metrics/MethodLength:
   Max: 25
   Exclude:
     - spec/db_helper.rb
 
-AllCops:
-  TargetRubyVersion: 2.4
+Style/HashEachMethods:
+  Enabled: True
 
-Metrics/AbcSize:
-  Max: 16
-  Exclude:
-    - spec/db_helper.rb
+Style/HashTransformKeys:
+  Enabled: True
 
-Metrics/ClassLength:
-  Max: 125
+Style/HashTransformValues:
+  Enabled: True

data/.ruby-version

@@ -1 +1 @@
-2.6.3
+2.6.6

data/.travis.yml

@@ -6,16 +6,12 @@ services:
   - mysql
 rvm:
   # Build on the latest stable of all supported Rubies (https://www.ruby-lang.org/en/downloads/):
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
+  - 2.5.8
+  - 2.6.6
+  - 2.7.1
 env:
   - AR_VERSION=5
   - AR_VERSION=6
-matrix:
-  exclude:
-    - rvm: 2.4.6
-      env: AR_VERSION=6
 cache: bundler
 before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+# 2.1.0 (TBD)
+
+### Additions:
+
+* Implemented Dbee::Query::Field#aggregator
+* Implemented Dbee::Query::Field#filters
+
+### Changes:
+
+* Bumped minimum Ruby version to 2.5
+
+# 2.0.4 (February 13th, 2020)
+
+* use Arel#in for Equal filters when there is more than one value
+* use Arel#not_in for NotEqual filters when there are is than one value
+
+# 2.0.3 (January 7th, 2020)
+
+* Added/tested support for Dbee 2.0.3
+* Added support for Ruby 2.6.5
+
+# 2.0.2 (November 7th, 2019)
+
+* Added/tested support for Dbee 2.0.2
+* Added support for Ruby 2.3.8
+
 # 2.0.1 (October 25th, 2019)
 
 * Development dependency updates.

data/dbee-active_record.gemspec

@@ -15,11 +15,19 @@ Gem::Specification.new do |s|
   s.email       = ['mruggio@bluemarblepayroll.com']
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.bindir      = 'exe'
+  s.executables = []
   s.homepage    = 'https://github.com/bluemarblepayroll/dbee-active_record'
   s.license     = 'MIT'
+  s.metadata    = {
+    'bug_tracker_uri' => 'https://github.com/bluemarblepayroll/dbee-active_record/issues',
+    'changelog_uri' => 'https://github.com/bluemarblepayroll/dbee-active_record/blob/master/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/dbee-active_record',
+    'homepage_uri' => s.homepage,
+    'source_code_uri' => s.homepage
+  }
 
-  s.required_ruby_version = '>= 2.4.6'
+  s.required_ruby_version = '>= 2.5'
 
   ar_version = ENV['AR_VERSION'] || ''
 
@@ -34,15 +42,15 @@ Gem::Specification.new do |s|
     end
 
   s.add_dependency('activerecord', activerecord_version)
-  s.add_dependency('dbee', '~>2')
+  s.add_dependency('dbee', '=2.1.0.pre.alpha')
 
   s.add_development_dependency('guard-rspec', '~>4.7')
   s.add_development_dependency('mysql2', '~>0.5')
   s.add_development_dependency('pry', '~>0')
   s.add_development_dependency('rake', '~> 13')
   s.add_development_dependency('rspec', '~> 3.8')
-  s.add_development_dependency('rubocop', '~>0.75.1')
+  s.add_development_dependency('rubocop', '~>0.81.0')
   s.add_development_dependency('simplecov', '~>0.17.0')
-  s.add_development_dependency('simplecov-console', '~>0.5.0')
+  s.add_development_dependency('simplecov-console', '~>0.7.0')
   s.add_development_dependency('sqlite3', '~>1')
 end

data/lib/dbee/providers/active_record_provider/expression_builder.rb

@@ -7,26 +7,24 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'expression_builder/constraint_maker'
-require_relative 'expression_builder/order_maker'
-require_relative 'expression_builder/select_maker'
-require_relative 'expression_builder/where_maker'
+require_relative 'expression_builder/constraint'
+require_relative 'expression_builder/order'
+require_relative 'expression_builder/select'
+require_relative 'expression_builder/where'
 
 module Dbee
   module Providers
     class ActiveRecordProvider
       # This class can generate an Arel expression tree.
       class ExpressionBuilder
-        extend Forwardable
-
         class MissingConstraintError < StandardError; end
 
-        def_delegators :statement, :to_sql
-
         def initialize(model, table_alias_maker, column_alias_maker)
           @model              = model
           @table_alias_maker  = table_alias_maker
           @column_alias_maker = column_alias_maker
+          @requires_group_by  = false
+          @group_by_columns   = []
 
           clear
         end
@@ -49,13 +47,25 @@ module Dbee
           self
         end
 
+        def to_sql
+          if requires_group_by
+            @requires_group_by = false
+            statement.group(group_by_columns) unless group_by_columns.empty?
+            @group_by_columns = []
+          end
+
+          statement.to_sql
+        end
+
         private
 
         attr_reader :base_table,
                     :statement,
                     :model,
                     :table_alias_maker,
-                    :column_alias_maker
+                    :column_alias_maker,
+                    :requires_group_by,
+                    :group_by_columns
 
         def tables
           @tables ||= {}
@@ -70,7 +80,7 @@ module Dbee
 
           key_path    = filter.key_path
           arel_column = key_paths_to_arel_columns[key_path]
-          predicate   = WhereMaker.instance.make(filter, arel_column)
+          predicate   = Where.instance.make(filter, arel_column)
 
           build(statement.where(predicate))
 
@@ -82,22 +92,40 @@ module Dbee
 
           key_path    = sorter.key_path
           arel_column = key_paths_to_arel_columns[key_path]
-          predicate   = OrderMaker.instance.make(sorter, arel_column)
+          predicate   = Order.instance.make(sorter, arel_column)
 
           build(statement.order(predicate))
 
           self
         end
 
+        def add_filter_key_paths(filters)
+          filters.each_with_object({}) do |filter, memo|
+            arel_key_column = add_key_path(filter.key_path)
+
+            memo[arel_key_column] = filter
+          end
+        end
+
         def add_field(field)
-          add_key_path(field.key_path)
+          arel_value_column           = add_key_path(field.key_path)
+          arel_key_columns_to_filters = add_filter_key_paths(field.filters)
 
-          key_path    = field.key_path
-          arel_column = key_paths_to_arel_columns[key_path]
-          predicate   = SelectMaker.instance.make(field, arel_column, column_alias_maker)
+          predicate = Select.instance.make(
+            field,
+            arel_key_columns_to_filters,
+            arel_value_column,
+            column_alias_maker
+          )
 
           build(statement.project(predicate))
 
+          if field.aggregator?
+            @requires_group_by = true
+          else
+            group_by_columns << arel_value_column
+          end
+
           self
         end
 
@@ -123,7 +151,7 @@ module Dbee
         def table(name, model, previous_table)
           table = make_table(model.table, name)
 
-          on = ConstraintMaker.instance.make(model.constraints, table, previous_table)
+          on = Constraint.instance.make(model.constraints, table, previous_table)
 
           raise MissingConstraintError, "for: #{name}" unless on
 
@@ -142,16 +170,16 @@ module Dbee
         end
 
         def add_key_path(key_path)
-          return if key_paths_to_arel_columns.key?(key_path)
+          return key_paths_to_arel_columns[key_path] if key_paths_to_arel_columns.key?(key_path)
 
           ancestors = model.ancestors!(key_path.ancestor_names)
 
           table = traverse_ancestors(ancestors)
 
           arel_column = table[key_path.column_name]
-          key_paths_to_arel_columns[key_path] = arel_column
 
-          self
+          # Note that this returns arel_column
+          key_paths_to_arel_columns[key_path] = arel_column
         end
 
         def build(new_expression)

data/lib/dbee/providers/active_record_provider/expression_builder/{constraint_maker.rb → constraint.rb}

@@ -12,9 +12,19 @@ module Dbee
     class ActiveRecordProvider
       class ExpressionBuilder
         # Can derive constraints for Arel table JOIN statements.
-        class ConstraintMaker
+        class Constraint
           include Singleton
 
+          def make(constraints, table, previous_table)
+            constraints.inject(nil) do |memo, constraint|
+              method = CONSTRAINT_RESOLVERS[constraint.class]
+
+              raise ArgumentError, "constraint unhandled: #{constraint.class.name}" unless method
+
+              method.call(constraint, memo, table, previous_table)
+            end
+          end
+
           CONCAT_METHOD = lambda do |on, arel_column, value|
             on ? on.and(arel_column.eq(value)) : arel_column.eq(value)
           end
@@ -44,16 +54,6 @@ module Dbee
           }.freeze
 
           private_constant :CONSTRAINT_RESOLVERS
-
-          def make(constraints, table, previous_table)
-            constraints.inject(nil) do |memo, constraint|
-              method = CONSTRAINT_RESOLVERS[constraint.class]
-
-              raise ArgumentError, "constraint unhandled: #{constraint.class.name}" unless method
-
-              method.call(constraint, memo, table, previous_table)
-            end
-          end
         end
       end
     end

data/lib/dbee/providers/active_record_provider/expression_builder/{order_maker.rb → order.rb}

@@ -12,16 +12,9 @@ module Dbee
     class ActiveRecordProvider
       class ExpressionBuilder
         # Derives Arel#order predicates.
-        class OrderMaker
+        class Order
           include Singleton
 
-          SORTER_EVALUATORS = {
-            Query::Sorters::Ascending => ->(column) { column },
-            Query::Sorters::Descending => ->(column) { column.desc }
-          }.freeze
-
-          private_constant :SORTER_EVALUATORS
-
           def make(sorter, arel_column)
             method = SORTER_EVALUATORS[sorter.class]
 
@@ -29,6 +22,13 @@ module Dbee
 
             method.call(arel_column)
           end
+
+          SORTER_EVALUATORS = {
+            Query::Sorters::Ascending => ->(column) { column },
+            Query::Sorters::Descending => ->(column) { column.desc }
+          }.freeze
+
+          private_constant :SORTER_EVALUATORS
         end
       end
     end

data/lib/dbee/providers/active_record_provider/expression_builder/select.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  module Providers
+    class ActiveRecordProvider
+      class ExpressionBuilder
+        # Derives Arel#project predicates.
+        class Select
+          include Singleton
+
+          def make(field, arel_key_nodes_to_filters, arel_value_node, alias_maker)
+            column_alias = quote(alias_maker.make(field.display))
+            predicate    = expression(field, arel_key_nodes_to_filters, arel_value_node)
+            predicate    = aggregate(field, predicate)
+
+            predicate.as(column_alias)
+          end
+
+          private
+
+          AGGREGRATOR_EVALUATORS = {
+            nil => ->(arel_node) { arel_node },
+            Query::Field::Aggregator::AVE => ->(node) { Arel::Nodes::Avg.new([node]) },
+            Query::Field::Aggregator::COUNT => ->(node) { Arel::Nodes::Count.new([node]) },
+            Query::Field::Aggregator::MAX => ->(node) { Arel::Nodes::Max.new([node]) },
+            Query::Field::Aggregator::MIN => ->(node) { Arel::Nodes::Min.new([node]) },
+            Query::Field::Aggregator::SUM => ->(node) { Arel::Nodes::Sum.new([node]) }
+          }.freeze
+
+          private_constant :AGGREGRATOR_EVALUATORS
+
+          def quote(value)
+            ActiveRecord::Base.connection.quote(value)
+          end
+
+          def aggregate(field, predicate)
+            AGGREGRATOR_EVALUATORS[field.aggregator].call(predicate)
+          end
+
+          def expression(field, arel_key_nodes_to_filters, arel_value_node)
+            if field.filters?
+              case_statement   = Arel::Nodes::Case.new
+              filter_predicate = make_filter_predicate(arel_key_nodes_to_filters)
+
+              case_statement.when(filter_predicate).then(arel_value_node)
+            else
+              arel_value_node
+            end
+          end
+
+          def make_filter_predicate(arel_key_nodes_to_filters)
+            predicates = arel_key_nodes_to_filters.map do |arel_key_node, filter|
+              Where.instance.make(filter, arel_key_node)
+            end
+
+            predicates.inject(predicates.shift) do |memo, predicate|
+              memo.and(predicate)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbee/providers/active_record_provider/expression_builder/where.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  module Providers
+    class ActiveRecordProvider
+      class ExpressionBuilder
+        # Derives Arel#where predicates.
+        class Where
+          include Singleton
+
+          def make(filter, arel_column)
+            # If the filter has a value of nil, then simply return an IS NULL predicate
+            return make_is_null_predicate(arel_column) unless filter.value
+
+            values = Array(filter.value).flatten
+
+            # This logic helps ensure that if a null exists that it translates to an IS NULL
+            # predicate and does not get put into an in or not_in clause.
+            predicates = values.include?(nil) ? [make_is_null_predicate(arel_column)] : []
+            predicates += make_predicates(filter, arel_column, values - [nil])
+
+            # Chain all predicates together
+            predicates.inject(predicates.shift) do |memo, predicate|
+              memo.or(predicate)
+            end
+          end
+
+          private
+
+          FILTER_EVALUATORS = {
+            Query::Filters::Contains => ->(node, val) { node.matches("%#{val}%") },
+            Query::Filters::Equals => ->(node, val) { node.eq(val) },
+            Query::Filters::GreaterThan => ->(node, val) { node.gt(val) },
+            Query::Filters::GreaterThanOrEqualTo => ->(node, val) { node.gteq(val) },
+            Query::Filters::LessThan => ->(node, val) { node.lt(val) },
+            Query::Filters::LessThanOrEqualTo => ->(node, val) { node.lteq(val) },
+            Query::Filters::NotContain => ->(node, val) { node.does_not_match("%#{val}%") },
+            Query::Filters::NotEquals => ->(node, val) { node.not_eq(val) },
+            Query::Filters::NotStartWith => ->(node, val) { node.does_not_match("#{val}%") },
+            Query::Filters::StartsWith => ->(node, val) { node.matches("#{val}%") }
+          }.freeze
+
+          private_constant :FILTER_EVALUATORS
+
+          def make_predicates(filter, arel_column, values)
+            if use_in?(filter, values)
+              [arel_column.in(values)]
+            elsif use_not_in?(filter, values)
+              [arel_column.not_in(values)]
+            else
+              make_or_predicates(filter, arel_column, values)
+            end
+          end
+
+          def use_in?(filter, values)
+            filter.is_a?(Query::Filters::Equals) && values.length > 1
+          end
+
+          def use_not_in?(filter, values)
+            filter.is_a?(Query::Filters::NotEquals) && values.length > 1
+          end
+
+          def make_or_predicates(filter, arel_column, values)
+            values.map do |value|
+              make_predicate(arel_column, filter.class, value)
+            end
+          end
+
+          def make_predicate(arel_column, filter_class, value)
+            method = FILTER_EVALUATORS[filter_class]
+
+            raise ArgumentError, "cannot compile filter: #{filter}" unless method
+
+            method.call(arel_column, value)
+          end
+
+          def make_is_null_predicate(arel_column)
+            make_predicate(arel_column, Query::Filters::Equals, nil)
+          end
+        end
+      end
+    end
+  end
+end