Implement Scopes::Composition::Disjunction.

lib/cuprum/collections/basic/scopes/disjunction_scope.rb

@@ -2,12 +2,14 @@
 
 require 'cuprum/collections/basic/scopes'
 require 'cuprum/collections/basic/scopes/base'
+require 'cuprum/collections/scopes/composition/disjunction'
 require 'cuprum/collections/scopes/container'
 
 module Cuprum::Collections::Basic::Scopes
   # Scope for filtering data matching any of the given scopes.
   class DisjunctionScope < Cuprum::Collections::Basic::Scopes::Base
     include Cuprum::Collections::Scopes::Container
+    include Cuprum::Collections::Scopes::Composition::Disjunction
 
     # Returns true if the provided item matches any of the configured scopes.
     def match?(item:)

lib/cuprum/collections/rspec/contracts/scopes/composition_contracts.rb

@@ -6,6 +6,7 @@
 require 'cuprum/collections/scopes/builder'
 require 'cuprum/collections/scopes/conjunction_scope'
 require 'cuprum/collections/scopes/criteria_scope'
+require 'cuprum/collections/scopes/disjunction_scope'
 require 'cuprum/collections/scopes/negation_scope'
 
 module Cuprum::Collections::RSpec::Contracts::Scopes
@@ -334,6 +335,16 @@ module ShouldComposeScopesForConjunctionContract
             it { expect(inner.type).to be :criteria }
 
             it { expect(inner.criteria).to be == expected }
+
+            wrap_context 'when the scope has many child scopes' do
+              it { expect(outer.scopes.size).to be scopes.size + 1 }
+
+              it { expect(inner).to be_a Cuprum::Collections::Scopes::Base }
+
+              it { expect(inner.type).to be :criteria }
+
+              it { expect(inner.criteria).to be == expected }
+            end
           end
 
           describe 'with a non-conjunction scope' do
@@ -560,5 +571,139 @@ module ShouldComposeScopesForCriteriaContract
         end
       end
     end
+
+    # Contract validating scope composition for disjunction scopes.
+    module ShouldComposeScopesForDisjunctionContract
+      extend  RSpec::SleepingKingStudios::Contract
+      include Cuprum::Collections::RSpec::Contracts::Scopes::CompositionContracts # rubocop:disable Layout/LineLength
+
+      # @!method apply(example_group)
+      #   Adds the contract to the example group.
+      #
+      #   @param example_group [RSpec::Core::ExampleGroup] the example group to
+      #     which the contract is applied.
+      contract do
+        shared_context 'when the scope has many child scopes' do
+          let(:scopes) do
+            [
+              build_scope({ 'author' => 'J.R.R. Tolkien' }),
+              build_scope({ 'series' => 'The Lord of the Rings' }),
+              build_scope do
+                { 'published_at' => less_than('1955-01-01') }
+              end
+            ]
+          end
+        end
+
+        include_contract 'should compose scopes', except: %i[or]
+
+        describe '#or' do
+          shared_examples 'should combine the scopes with logical OR' do
+            it { expect(outer).to be_a Cuprum::Collections::Scopes::Base }
+
+            it { expect(outer.type).to be :disjunction }
+
+            it { expect(outer.scopes.size).to be scopes.size + 1 }
+
+            it { expect(inner).to be_a Cuprum::Collections::Scopes::Base }
+
+            it { expect(inner.type).to be :criteria }
+
+            it { expect(inner.criteria).to be == expected }
+          end
+
+          let(:expected) do
+            operators = Cuprum::Collections::Queries::Operators
+
+            [
+              [
+                'title',
+                operators::EQUAL,
+                'A Wizard of Earthsea'
+              ]
+            ]
+          end
+
+          describe 'with a block' do
+            let(:block) { -> { { 'title' => 'A Wizard of Earthsea' } } }
+            let(:outer) { subject.or(&block) }
+            let(:inner) { outer.scopes.last }
+
+            include_examples 'should combine the scopes with logical OR'
+
+            wrap_context 'when the scope has many child scopes' do
+              include_examples 'should combine the scopes with logical OR'
+
+              it { expect(outer.scopes[0...scopes.size]).to be == scopes }
+            end
+          end
+
+          describe 'with a hash' do
+            let(:value) { { 'title' => 'A Wizard of Earthsea' } }
+            let(:outer) { subject.or(value) }
+            let(:inner) { outer.scopes.last }
+
+            include_examples 'should combine the scopes with logical OR'
+
+            wrap_context 'when the scope has many child scopes' do
+              include_examples 'should combine the scopes with logical OR'
+
+              it { expect(outer.scopes[0...scopes.size]).to be == scopes }
+            end
+          end
+
+          describe 'with a disjunction scope' do
+            let(:original) do
+              wrapped =
+                Cuprum::Collections::Scopes::CriteriaScope
+                  .new(criteria: expected)
+
+              Cuprum::Collections::Scopes::DisjunctionScope
+                .new(scopes: [wrapped])
+            end
+            let(:outer) { subject.or(original) }
+            let(:inner) { outer.scopes.last }
+
+            it { expect(outer).to be_a Cuprum::Collections::Scopes::Base }
+
+            it { expect(outer.type).to be :disjunction }
+
+            it { expect(outer.scopes.size).to be scopes.size + 1 }
+
+            it { expect(inner).to be_a Cuprum::Collections::Scopes::Base }
+
+            it { expect(inner.type).to be :criteria }
+
+            it { expect(inner.criteria).to be == expected }
+
+            wrap_context 'when the scope has many child scopes' do
+              it { expect(outer.scopes.size).to be scopes.size + 1 }
+
+              it { expect(inner).to be_a Cuprum::Collections::Scopes::Base }
+
+              it { expect(inner.type).to be :criteria }
+
+              it { expect(inner.criteria).to be == expected }
+            end
+          end
+
+          describe 'with a non-disjunction scope' do
+            let(:original) do
+              Cuprum::Collections::Scopes::CriteriaScope.new(criteria: expected)
+            end
+            let(:outer) { subject.or(original) }
+            let(:inner) { outer.scopes.last }
+
+            include_examples 'should combine the scopes with logical OR'
+
+            wrap_context 'when the scope has many child scopes' do
+              include_examples 'should combine the scopes with logical OR'
+
+              it { expect(outer.scopes[0...scopes.size]).to be == scopes }
+            end
+          end
+        end
+      end
+    end
   end
 end

lib/cuprum/collections/rspec/contracts/scopes/logical_contracts.rb

@@ -53,6 +53,8 @@ module ShouldBeADisjunctionScopeContract
       contract do |abstract: false|
         include_contract 'should be a container scope'
 
+        include_contract 'should compose scopes for disjunction'
+
         describe '#call' do
           next if abstract
 

lib/cuprum/collections/scopes/composition.rb

@@ -7,6 +7,7 @@ module Cuprum::Collections::Scopes
   module Composition
     autoload :Conjunction, 'cuprum/collections/scopes/composition/conjunction'
     autoload :Criteria,    'cuprum/collections/scopes/composition/criteria'
+    autoload :Disjunction, 'cuprum/collections/scopes/composition/disjunction'
 
     # @override and(hash = nil, &block)
     #   Parses the hash or block and combines using a logical AND.

lib/cuprum/collections/scopes/composition/disjunction.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/scopes/composition'
+
+module Cuprum::Collections::Scopes::Composition
+  # Defines composition behavior for disjunction scopes.
+  module Disjunction
+    # (see Cuprum::Collections::Scopes::Composition#or)
+    def or(*args, &block)
+      scopes =
+        if args.first.is_a?(Cuprum::Collections::Scopes::Base) &&
+           args.first.type == :disjunction
+          args.first.scopes.map do |scope|
+            builder.transform_scope(scope: scope)
+          end
+        else
+          [builder.build(*args, &block)]
+        end
+
+      with_scopes([*self.scopes, *scopes])
+    end
+  end
+end

lib/cuprum/collections/scopes/disjunction_scope.rb

@@ -2,12 +2,14 @@
 
 require 'cuprum/collections/scopes'
 require 'cuprum/collections/scopes/base'
+require 'cuprum/collections/scopes/composition/disjunction'
 require 'cuprum/collections/scopes/container'
 
 module Cuprum::Collections::Scopes
   # Generic scope class for defining collection-independent logical OR scopes.
   class DisjunctionScope < Cuprum::Collections::Scopes::Base
     include Cuprum::Collections::Scopes::Container
+    include Cuprum::Collections::Scopes::Composition::Disjunction
 
     # (see Cuprum::Collections::Scopes::Base#type)
     def type

spec/cuprum/collections/scopes/composition/disjunction_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/rspec/contracts/scopes/composition_contracts'
+require 'cuprum/collections/scopes/base'
+require 'cuprum/collections/scopes/composition/disjunction'
+require 'cuprum/collections/scopes/container'
+require 'cuprum/collections/scopes/criteria_scope'
+
+RSpec.describe Cuprum::Collections::Scopes::Composition::Disjunction do
+  include Cuprum::Collections::RSpec::Contracts::Scopes::CompositionContracts
+
+  subject(:scope) { described_class.new(scopes: scopes) }
+
+  let(:described_class) { Spec::ExampleScope }
+  let(:scopes)          { [] }
+
+  example_class 'Spec::ExampleScope', Cuprum::Collections::Scopes::Base \
+  do |klass|
+    klass.include Cuprum::Collections::Scopes::Container
+    klass.include Cuprum::Collections::Scopes::Composition::Disjunction # rubocop:disable RSpec/DescribedClass
+
+    klass.define_method(:type) { :disjunction }
+  end
+
+  def build_scope(filters = nil, &block)
+    scope_class = Cuprum::Collections::Basic::Scopes::CriteriaScope
+
+    if block_given?
+      scope_class.build(&block)
+    else
+      scope_class.build(filters)
+    end
+  end
+
+  include_contract 'should compose scopes for disjunction'
+end

spec/cuprum/collections/scopes/disjunction_scope_spec.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'cuprum/collections/scopes/disjunction_scope'
 require 'cuprum/collections/rspec/contracts/scopes/logical_contracts'
+require 'cuprum/collections/scopes/criteria_scope'
+require 'cuprum/collections/scopes/disjunction_scope'
 
 RSpec.describe Cuprum::Collections::Scopes::DisjunctionScope do
   include Cuprum::Collections::RSpec::Contracts::Scopes::LogicalContracts
@@ -10,5 +11,15 @@
 
   let(:scopes) { [] }
 
+  def build_scope(filters = nil, &block)
+    scope_class = Cuprum::Collections::Basic::Scopes::CriteriaScope
+
+    if block_given?
+      scope_class.build(&block)
+    else
+      scope_class.build(filters)
+    end
+  end
+
   include_contract 'should be a disjunction scope', abstract: true
 end