wcc-contentful 1.1.0 → 1.2.0

data/lib/wcc/contentful/store/query.rb

@@ -34,6 +34,17 @@ module WCC::Contentful::Store
       @extra = extra
     end
 
+    FALSE_VALUES = [
+      false, 0,
+      '0', :"0",
+      'f', :f,
+      'F', :F,
+      'false', :false, # rubocop:disable Lint/BooleanSymbol
+      'FALSE', :FALSE,
+      'off', :off,
+      'OFF', :OFF
+    ].to_set.freeze
+
     # Returns a new chained Query that has a new condition.  The new condition
     # represents the WHERE comparison being applied here.  The underlying store
     # implementation translates this condition statement into an appropriate
@@ -50,7 +61,16 @@ module WCC::Contentful::Store
     # @expected The expected value to compare the field's value against.
     # @context A context object optionally containing `context[:locale]`
     def apply_operator(operator, field, expected, context = nil)
+      operator ||= expected.is_a?(Array) ? :in : :eq
       raise ArgumentError, "Operator #{operator} not supported" unless respond_to?(operator)
+      raise ArgumentError, 'value cannot be nil (try using exists: false)' if expected.nil?
+
+      case operator
+      when :in, :nin, :all
+        expected = Array(expected)
+      when :exists
+        expected = !FALSE_VALUES.include?(expected)
+      end
 
       field = field.to_s if field.is_a? Symbol
       path = field.is_a?(Array) ? field : field.split('.')
@@ -151,7 +171,7 @@ module WCC::Contentful::Store
           elsif op?(k)
             { path: path, op: k.to_sym, expected: v }
           else
-            { path: path + [k], op: :eq, expected: v }
+            { path: path + [k], op: nil, expected: v }
           end
         end
       end

data/lib/wcc/contentful/store/rspec_examples/basic_store.rb

@@ -528,68 +528,6 @@ RSpec.shared_examples 'basic store' do
       expect(found.dig('sys', 'id')).to eq('idTwo')
       expect(found.dig('fields', 'system', 'en-US')).to eq('Two')
     end
-
-    [
-      [Integer, proc { rand(-4_611_686_018_427_387_903..4_611_686_018_427_387_903) }],
-      [Float, proc { rand }]
-    ].each do |(type, generator)|
-      context "by #{type} equality" do
-        it 'can apply filter object' do
-          data =
-            1.upto(10).map do |i|
-              {
-                'sys' => { 'id' => "k#{i}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
-                'fields' => { type.to_s => { 'en-US' => generator.call } }
-              }
-            end
-
-          desired_value = generator.call
-          desired = {
-            'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
-            'fields' => { type.to_s => { 'en-US' => desired_value } }
-          }
-
-          data << desired
-          data.shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
-
-          # act
-          found = subject.find_by(content_type: 'test1', filter: { type.to_s => desired_value })
-
-          # assert
-          expect(found).to_not be_nil
-          expect(found).to eq(desired)
-        end
-
-        it 'filter object can find value in array' do
-          data =
-            1.upto(10).map do |i|
-              {
-                'sys' => {
-                  'id' => "k#{i}",
-                  'contentType' => { 'sys' => { 'id' => 'test1' } }
-                },
-                'fields' => { 'name' => { 'en-US' => [generator.call, generator.call] } }
-              }
-            end
-
-          desired_value = generator.call
-          desired = {
-            'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
-            'fields' => { type.to_s => { 'en-US' => [generator.call, desired_value].shuffle } }
-          }
-
-          data << desired
-          data.shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
-
-          # act
-          found = subject.find_by(content_type: 'test1', filter: { type.to_s => { eq: desired_value } })
-
-          # assert
-          expect(found).to_not be_nil
-          expect(found).to eq(desired)
-        end
-      end
-    end
   end
 
   describe '#find_all' do
@@ -634,29 +572,6 @@ RSpec.shared_examples 'basic store' do
         %w[k1 k5 k9]
       )
     end
-
-    it 'filter query eq can find value in array' do
-      content_types = %w[test1 test2 test3 test4]
-      data =
-        1.upto(10).map do |i|
-          {
-            'sys' => {
-              'id' => "k#{i}",
-              'contentType' => { 'sys' => { 'id' => content_types[i % content_types.length] } }
-            },
-            'fields' => { 'name' => { 'en-US' => ["test#{i}", "test_2_#{i}"] } }
-          }
-        end
-      data.each { |d| subject.set(d.dig('sys', 'id'), d) }
-
-      # act
-      found = subject.find_all(content_type: 'test2')
-        .apply('name' => { eq: 'test_2_5' })
-
-      # assert
-      expect(found.count).to eq(1)
-      expect(found.first.dig('sys', 'id')).to eq('k5')
-    end
   end
 
   def make_link_to(id, link_type = 'Entry')

data/lib/wcc/contentful/store/rspec_examples/operators/eq.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :eq operator' do
+  [
+    [String, proc { "test#{rand(1..10_000)}" }],
+    [Integer, proc { rand(-4_611_686_018_427_387_903..4_611_686_018_427_387_903) }],
+    [Float, proc { rand }]
+  ].each do |(type, generator)|
+    context "with #{type} value" do
+      let(:desired_value) {
+        generator.call
+      }
+
+      let(:data) {
+        1.upto(3).map do |i|
+          {
+            'sys' => { 'id' => "k#{i}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+            'fields' => { type.to_s => { 'en-US' => generator.call } }
+          }
+        end
+      }
+
+      let(:desired) {
+        {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => desired_value } }
+        }
+      }
+
+      it 'find_by can apply filter object' do
+        [*data, desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => desired_value })
+
+        # assert
+        expect(found).to_not be_nil
+        expect(found).to eq(desired)
+      end
+
+      it 'find_by can find value in array' do
+        data =
+          1.upto(3).map do |i|
+            {
+              'sys' => {
+                'id' => "k#{i}",
+                'contentType' => { 'sys' => { 'id' => 'test1' } }
+              },
+              'fields' => { 'name' => { 'en-US' => [generator.call, generator.call] } }
+            }
+          end
+
+        desired_value = generator.call
+        desired = {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => [generator.call, desired_value].shuffle } }
+        }
+
+        data << desired
+        data.shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => { eq: desired_value } })
+
+        # assert
+        expect(found).to_not be_nil
+        expect(found).to eq(desired)
+      end
+
+      it 'find_all can apply operator' do
+        desired =
+          4.upto(5).map do |i|
+            {
+              'sys' => { 'id' => "k#{i}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+              'fields' => { type.to_s => { 'en-US' => desired_value } }
+            }
+          end
+
+        [*data, *desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_all(content_type: 'test1')
+          .eq(type.to_s, desired_value)
+
+        # assert
+        expect(found.count).to eq(2)
+        sorted = found.to_a.sort_by { |item| item.dig('sys', 'id') }
+        expect(sorted).to eq(desired)
+      end
+    end
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators/in.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :in operator' do
+  it 'find_all with array on string field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.shuffle.take(2)
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .in('name', to_find.map { |i| "test#{i}" })
+
+    expect(found.count).to eq(2)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      to_find.map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_all with array on array field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => ["test#{i}", "test_2_#{i}"] } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find1, to_find2 = ids.shuffle
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .in('name', ["test#{to_find1}", "test_2_#{to_find2}"])
+
+    expect(found.count).to eq(2)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      ["k#{to_find1}", "k#{to_find2}"].sort
+    )
+  end
+
+  it 'find_all defaults to :in when given an array' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.shuffle.take(3)
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .apply('name' => to_find.map { |i| "test#{i}" })
+
+    expect(found.count).to eq(3)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      to_find.map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_by with array on string field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.sample
+
+    # act
+    found = subject.find_by(
+      content_type: 'test',
+      filter: { name: { in: ['asdf', "test#{to_find}"] } }
+    )
+
+    expect(found.dig('sys', 'id')).to eq("k#{to_find}")
+  end
+
+  it 'find_by defaults to :in when given an array' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.sample
+
+    # act
+    found = subject.find_by(
+      content_type: 'test',
+      filter: { name: ['asdf', "test#{to_find}"] }
+    )
+
+    expect(found.dig('sys', 'id')).to eq("k#{to_find}")
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators/ne.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :ne operator' do
+  [
+    [String, proc { "test#{rand(1..100_000)}" }],
+    [Integer, proc { rand(-4_611_686_018_427_387_903..4_611_686_018_427_387_903) }],
+    [Float, proc { rand }]
+  ].each do |(type, generator)|
+    context "with #{type} value" do
+      let(:specified_value) {
+        generator.call
+      }
+
+      let(:desired) {
+        # desired entry doesn't have the specified_value
+        {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => 1.upto(rand(2..5)).map { generator.call } } }
+        }
+      }
+
+      let(:data) {
+        1.upto(3).map do |i|
+          random_values = 1.upto(rand(2..5)).map { generator.call }
+
+          # remaining data does include the specified_value
+          {
+            'sys' => {
+              'id' => "k#{i}",
+              'contentType' => { 'sys' => { 'id' => 'test1' } }
+            },
+            'fields' => { type.to_s => { 'en-US' => [*random_values, specified_value].shuffle } }
+          }
+        end
+      }
+
+      it 'find_by can apply filter object' do
+        specified_value = generator.call
+        data = {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => specified_value } }
+        }
+
+        subject.set(data.dig('sys', 'id'), data)
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => { ne: specified_value } })
+
+        # assert
+        expect(found).to be_nil
+      end
+
+      it 'find_by can find value in array' do
+        [*data, desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => { ne: specified_value } })
+
+        # assert
+        expect(found).to_not be_nil
+        expect(found).to eq(desired)
+      end
+
+      it 'find_all can apply operator' do
+        [*data, desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_all(content_type: 'test1')
+          .ne(type.to_s, specified_value)
+
+        # assert
+        expect(found.count).to eq(1)
+        expect(found.first).to eq(desired)
+      end
+    end
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators/nin.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :nin operator' do
+  it 'find_all with array on string field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_exclude = ids.shuffle.take(2)
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .nin('name', to_exclude.map { |i| "test#{i}" })
+
+    expect(found.count).to eq(8)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      (ids - to_exclude).map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_all with array on array field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => ["test#{i}", "test_2_#{i}"] } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_exclude1, to_exclude2 = ids.shuffle
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .nin('name', ["test#{to_exclude1}", "test_2_#{to_exclude2}"])
+
+    expect(found.count).to eq(8)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      (ids - [to_exclude1, to_exclude2]).map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_by with array on string field' do
+    ids = 1.upto(2).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_exclude, to_expect = ids.shuffle
+
+    # act
+    found = subject.find_by(
+      content_type: 'test',
+      filter: { name: { nin: ['asdf', "test#{to_exclude}"] } }
+    )
+
+    expect(found.dig('sys', 'id')).to eq("k#{to_expect}")
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative './operators/eq'
+require_relative './operators/ne'
+require_relative './operators/in'
+require_relative './operators/nin'
+
+(WCC::Contentful::Store::Query::Interface::OPERATORS -
+  %i[eq ne in nin]).each do |op|
+    RSpec.shared_examples "supports :#{op} operator" do
+      it 'TODO'
+    end
+  end
+
+RSpec.shared_examples 'operators' do |feature_set|
+  supported_operators =
+    if feature_set.nil?
+      WCC::Contentful::Store::Query::Interface::OPERATORS
+        .each_with_object({}) { |k, h| h[k] = 'pending' }
+    elsif feature_set.is_a?(Array)
+      WCC::Contentful::Store::Query::Interface::OPERATORS
+        .each_with_object({}) { |k, h| h[k] = feature_set.include?(k.to_sym) }
+    elsif feature_s.is_a?(Hash)
+      feature_set
+    else
+      raise ArgumentError, 'Please provide a hash or array of operators to test'
+    end
+
+  supported_operators.each do |op, value|
+    next if value
+
+    it "does not support :#{op}" do
+      expect {
+        subject.find_all(content_type: 'test')
+          .apply('name' => { op => 'test' })
+          .to_a
+      }.to raise_error do |ex|
+        expect(ex.to_s).to match(/not supported/)
+      end
+    end
+  end
+
+  supported_operators.each do |op, value|
+    next unless value
+
+    it_behaves_like "supports :#{op} operator" do
+      before { pending(":#{op} operator to be implemented") } if value == 'pending'
+    end
+  end
+end

data/lib/wcc/contentful/store/rspec_examples.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative './rspec_examples/basic_store'
+require_relative './rspec_examples/operators'
 require_relative './rspec_examples/nested_queries'
 require_relative './rspec_examples/include_param'
 
@@ -41,6 +42,7 @@ RSpec.shared_examples 'contentful store' do |feature_set|
   }.merge(feature_set&.symbolize_keys || {})
 
   include_examples 'basic store'
+  include_examples 'operators', feature_set[:operators]
   include_examples 'supports nested queries', feature_set[:nested_queries]
   include_examples 'supports include param', feature_set[:include_param]
 end

data/lib/wcc/contentful/version.rb

@@ -2,6 +2,6 @@
 
 module WCC
   module Contentful
-    VERSION = '1.1.0'
+    VERSION = '1.2.0'
   end
 end

data/lib/wcc/contentful.rb

@@ -3,7 +3,7 @@
 require 'wcc/contentful/version'
 
 require 'active_support'
-require 'active_support/core_ext/object'
+require 'active_support/all'
 
 require 'wcc/contentful/active_record_shim'
 require 'wcc/contentful/configuration'

data/wcc-contentful.gemspec

@@ -54,7 +54,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'generator_spec', '~> 0.9.4'
   # spec.add_development_dependency 'rails', '~> 5.0'
   # spec.add_development_dependency 'rspec-rails', '~> 3.7'
-  spec.add_development_dependency 'sqlite3', '~> 1.3.6'
+  spec.add_development_dependency 'sqlite3', '~> 1.4'
   spec.add_development_dependency 'timecop', '~> 0.9.1'
 
   # optional dependencies