dbee-active_record 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e71321e2f9366122dfbcc7bbfa5a18be43693e6d0c7eda44cf06221e646bef33
-  data.tar.gz: f59ad369064af84ba7cd387df7b0c072eb38bf6658d7342320e158e5d297c65a
+  metadata.gz: 8ec480363c33c49f4dd4cd5de9023b6ddad2f3d8b39ee90b4a67bc282a2b35f3
+  data.tar.gz: 6db9e48a3bb04e73ae91f01c63640b36db530f04a06245462b4e4d72e2f083c0
 SHA512:
-  metadata.gz: 6ad043966cba813e731ab4e7d53cf22fc359ec6a2000097b18719d0bf7a317c3521c8785999cfc99f31b5d091724337afad62ff62c02aca19f448d37989eecbc
-  data.tar.gz: eb496b07348bbb79a2cd97be2816ea696186ac8068172ca38f521d22343cf3f80f67c71bf99adeb0022f723643dbc579e145641afb814a1772237ff92e35ef82
+  metadata.gz: 694720a4ff3a557ebdf03cf94bb38010e9c52eacbf188c26f4b3e6e6c7adbd08353e31aae214797bbc79e7493f9d53f178b866b017e4c5feba13a23d253b1449
+  data.tar.gz: 7ba4120f8e7ddc71b2f7d2783c854f9f6ac5b1935260fb7c769d96f1e0ac900ffa8cbb2b3233dd7ccd4d3e7b38d4c702dc9a142a29fd45a2258b0e27ad69ad42

data/.rubocop.yml

@@ -6,7 +6,7 @@ Layout/LineLength:
   Max: 100
 
 Metrics/AbcSize:
-  Max: 16
+  Max: 17
   Exclude:
     - spec/db_helper.rb
 

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 2.1.2 (October 15th, 2020)
+
+* Improved test coverage for Where maker
+* Fixed bug in Where maker which resulted in only IS NULL predicates being generated, even in cases
+  of when IS NOT NULL intended.
+
 # 2.1.1 (July 15th, 2020)
 
 ### Additions:

data/README.md

@@ -11,7 +11,7 @@ This library is a plugin for [Dbee](https://github.com/bluemarblepayroll/dbee).
 To install through Rubygems:
 
 ````
-gem install install dbee-active_record
+gem install dbee-active_record
 ````
 
 You can also add this to your Gemfile:

data/dbee-active_record.gemspec

@@ -11,8 +11,8 @@ Gem::Specification.new do |s|
     By default Dbee ships with no underlying SQL generator.  This library will plug in ActiveRecord into Dbee and Dbee will use it for SQL generation.
   DESCRIPTION
 
-  s.authors     = ['Matthew Ruggio']
-  s.email       = ['mruggio@bluemarblepayroll.com']
+  s.authors     = ['Matthew Ruggio', 'Craig Kattner']
+  s.email       = ['mruggio@bluemarblepayroll.com', 'ckattner@bluemarblepayroll.com']
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.bindir      = 'exe'
@@ -47,10 +47,11 @@ Gem::Specification.new do |s|
   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('pry-byebug')
   s.add_development_dependency('rake', '~> 13')
   s.add_development_dependency('rspec', '~> 3.8')
-  s.add_development_dependency('rubocop', '~>0.88.0')
-  s.add_development_dependency('simplecov', '~>0.18.5')
+  s.add_development_dependency('rubocop', '~>0.90.0')
+  s.add_development_dependency('simplecov', '~>0.19.0')
   s.add_development_dependency('simplecov-console', '~>0.7.0')
   s.add_development_dependency('sqlite3', '~>1')
 end

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

@@ -16,14 +16,20 @@ module Dbee
           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
+            # If the filter has a value of nil, then simply return an IS (NOT) NULL predicate
+            return make_is_null_predicate(arel_column, filter.class) if filter.value.nil?
 
             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 =
+              if values.include?(nil)
+                [make_is_null_predicate(arel_column, filter.class)]
+              else
+                []
+              end
+
             predicates += make_predicates(filter, arel_column, values - [nil])
 
             # Chain all predicates together
@@ -47,7 +53,20 @@ module Dbee
             Query::Filters::StartsWith => ->(node, val) { node.matches("#{val}%") }
           }.freeze
 
-          private_constant :FILTER_EVALUATORS
+          NULL_PREDICATE_MAP = {
+            Query::Filters::Contains => Query::Filters::Equals,
+            Query::Filters::Equals => Query::Filters::Equals,
+            Query::Filters::GreaterThan => Query::Filters::Equals,
+            Query::Filters::GreaterThanOrEqualTo => Query::Filters::Equals,
+            Query::Filters::LessThan => Query::Filters::Equals,
+            Query::Filters::LessThanOrEqualTo => Query::Filters::Equals,
+            Query::Filters::NotContain => Query::Filters::NotEquals,
+            Query::Filters::NotEquals => Query::Filters::NotEquals,
+            Query::Filters::NotStartWith => Query::Filters::NotEquals,
+            Query::Filters::StartsWith => Query::Filters::Equals
+          }.freeze
+
+          private_constant :FILTER_EVALUATORS, :NULL_PREDICATE_MAP
 
           def make_predicates(filter, arel_column, values)
             if use_in?(filter, values)
@@ -81,8 +100,9 @@ module Dbee
             method.call(arel_column, value)
           end
 
-          def make_is_null_predicate(arel_column)
-            make_predicate(arel_column, Query::Filters::Equals, nil)
+          def make_is_null_predicate(arel_column, requested_filter_class)
+            actual_filter_class = NULL_PREDICATE_MAP[requested_filter_class]
+            make_predicate(arel_column, actual_filter_class, nil)
           end
         end
       end

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

@@ -10,7 +10,7 @@
 module Dbee
   module Providers
     class ActiveRecordProvider
-      VERSION = '2.1.1'
+      VERSION = '2.1.2'
     end
   end
 end

data/spec/dbee/providers/active_record_provider/makers/where_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-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.
+#
+
+require 'spec_helper'
+require 'db_helper'
+
+# rubocop:disable Layout/LineLength
+# Disable the line length cop beause there are some lengthy 'expected' SQL strings in spec which
+# cannot be shortened.
+describe Dbee::Providers::ActiveRecordProvider::Makers::Where do
+  before(:all) { connect_to_db(:sqlite) }
+
+  let(:subject) { described_class.instance }
+  let(:column) { Arel::Table.new(:test)[:foo] }
+
+  describe 'equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" = 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NULL OR "test"."foo" IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'not equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" != 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NOT NULL OR "test"."foo" NOT IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" NOT IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE '%a%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE '%a%' OR "test"."foo" LIKE '%b%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE '%a%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE '%a%' OR "test"."foo" NOT LIKE '%b%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'starts with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE 'a%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE 'a%' OR "test"."foo" LIKE 'b%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not start with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE 'a%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE 'a%' OR "test"."foo" NOT LIKE 'b%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" > 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" > 'a') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" > 'a' OR "test"."foo" > 'b') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" >= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" >= 'a') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" >= 'a' OR "test"."foo" >= 'b') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" < 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" < 'a') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" < 'a' OR "test"."foo" < 'b') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" <= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" <= 'a') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" <= 'a' OR "test"."foo" <= 'b') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+end
+# rubocop:enable Layout/LineLength

data/spec/spec_helper.rb

@@ -35,7 +35,7 @@ def fixture(*filename)
 end
 
 def yaml_fixture_files(*directory)
-  Dir[File.join('spec', 'fixtures', *directory, '*.yaml')].map do |filename|
+  Dir[File.join('spec', 'fixtures', *directory, '**', '*.yaml')].map do |filename|
     [
       filename,
       yaml_file_read(filename)

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: dbee-active_record
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Matthew Ruggio
+- Craig Kattner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-15 00:00:00.000000000 Z
+date: 2020-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -92,6 +93,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !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:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -126,28 +141,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.88.0
+        version: 0.90.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.88.0
+        version: 0.90.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.5
+        version: 0.19.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.5
+        version: 0.19.0
 - !ruby/object:Gem::Dependency
   name: simplecov-console
   requirement: !ruby/object:Gem::Requirement
@@ -180,6 +195,7 @@ description: "    By default Dbee ships with no underlying SQL generator.  This
   will plug in ActiveRecord into Dbee and Dbee will use it for SQL generation.\n"
 email:
 - mruggio@bluemarblepayroll.com
+- ckattner@bluemarblepayroll.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -212,6 +228,7 @@ files:
 - spec/config/database.yaml.ci
 - spec/db_helper.rb
 - spec/dbee/providers/active_record_provider/expression_builder_spec.rb
+- spec/dbee/providers/active_record_provider/makers/where_spec.rb
 - spec/dbee/providers/active_record_provider_spec.rb
 - spec/fixtures/active_record_snapshots/five_table_query.yaml
 - spec/fixtures/active_record_snapshots/multiple_same_table_query_with_static_constraints.yaml
@@ -262,6 +279,7 @@ test_files:
 - spec/config/database.yaml.ci
 - spec/db_helper.rb
 - spec/dbee/providers/active_record_provider/expression_builder_spec.rb
+- spec/dbee/providers/active_record_provider/makers/where_spec.rb
 - spec/dbee/providers/active_record_provider_spec.rb
 - spec/fixtures/active_record_snapshots/five_table_query.yaml
 - spec/fixtures/active_record_snapshots/multiple_same_table_query_with_static_constraints.yaml