cuprum-collections 0.5.1 → 0.6.0.rc.0

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

@@ -13,6 +13,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
   # Contracts for validating the behavior of scope composition.
   module CompositionContracts
     # Contract validating the fluent interface for scope composition.
+    #
+    # @deprecated 0.6.0
     module ShouldComposeScopesContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -372,6 +374,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating scope composition for conjunction scopes.
+    #
+    # @deprecated 0.6.0
     module ShouldComposeScopesForConjunctionContract
       extend  RSpec::SleepingKingStudios::Contract
       include Cuprum::Collections::RSpec::Contracts::Scopes::CompositionContracts # rubocop:disable Layout/LineLength
@@ -593,6 +597,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating scope composition for criteria scopes.
+    #
+    # @deprecated 0.6.0
     module ShouldComposeScopesForCriteriaContract
       extend  RSpec::SleepingKingStudios::Contract
       include Cuprum::Collections::RSpec::Contracts::Scopes::CompositionContracts # rubocop:disable Layout/LineLength
@@ -1319,6 +1325,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating scope composition for disjunction scopes.
+    #
+    # @deprecated 0.6.0
     module ShouldComposeScopesForDisjunctionContract
       extend  RSpec::SleepingKingStudios::Contract
       include Cuprum::Collections::RSpec::Contracts::Scopes::CompositionContracts # rubocop:disable Layout/LineLength

data/lib/cuprum/collections/rspec/contracts/scopes/criteria_contracts.rb

@@ -11,6 +11,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     include Cuprum::Collections::RSpec::Contracts::Scopes::CompositionContracts
 
     # Contract validating the behavior of a Criteria scope implementation.
+    #
+    # @deprecated 0.6.0
     module ShouldBeACriteriaScopeContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -31,6 +33,16 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
         constructor:         true,
         ignore_uninvertible: false
       |
+        message =
+          'Use deferred examples "should implement the CriteriaScope methods"'
+        SleepingKingStudios::Tools::Toolbelt
+          .instance
+          .core_tools
+          .deprecate(
+            'ShouldBeACriteriaScopeContract',
+            message:
+          )
+
         shared_context 'when initialized with inverted: true' do
           let(:constructor_options) { super().merge(inverted: true) }
         end
@@ -837,6 +849,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating the scope filters data based on the criteria.
+    #
+    # @deprecated 0.6.0
     module ShouldFilterDataByCriteriaContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -1196,6 +1210,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating the parsing of criteria.
+    #
+    # @deprecated 0.6.0
     module ShouldParseCriteriaContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -1246,6 +1262,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating the parsing of criteria from a Hash.
+    #
+    # @deprecated 0.6.0
     module ShouldParseCriteriaFromABlockContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -1741,372 +1759,6 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
             expect(parse_criteria(&block)).to be == expected
           end
         end
-
-        # @deprecated v0.5.0 Implicit receivers are deprecated.
-        describe 'with a block with legacy implicit receiver' do
-          shared_examples 'should print a deprecation warning for' \
-          do |operator_name|
-            let(:deprecation_warning) do
-              '#parse with implicit receiver'
-            end
-            let(:deprecation_message) do
-              'Pass a block with one parameter to #parse: { |scope| { scope' \
-                ".#{operator_name}: value } }"
-            end
-
-            it 'should print a deprecation warning' do
-              parse_criteria(&block)
-
-              expect(tools.core_tools)
-                .to have_received(:deprecate)
-                .with(deprecation_warning, message: deprecation_message)
-            end
-          end
-
-          def tools
-            SleepingKingStudios::Tools::Toolbelt.instance
-          end
-
-          before(:example) do
-            allow(tools.core_tools).to receive(:deprecate)
-          end
-
-          describe 'with a Hash with an "eq" operator' do
-            let(:block) do
-              -> { { 'title' => eq('A Wizard of Earthsea') } }
-            end
-            let(:expected) do
-              [['title', operators::EQUAL, 'A Wizard of Earthsea']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'eq'
-          end
-
-          describe 'with a Hash with an "equal" operator' do
-            let(:block) do
-              -> { { 'title' => equal('A Wizard of Earthsea') } }
-            end
-            let(:expected) do
-              [['title', operators::EQUAL, 'A Wizard of Earthsea']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'equal'
-          end
-
-          describe 'with a Hash with an "equals" operator' do
-            let(:block) do
-              -> { { 'title' => equals('A Wizard of Earthsea') } }
-            end
-            let(:expected) do
-              [['title', operators::EQUAL, 'A Wizard of Earthsea']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'equals'
-          end
-
-          describe 'with a Hash with a "greater_than" operator' do
-            let(:block) do
-              -> { { 'published_at' => greater_than('1970-01-01') } }
-            end
-            let(:expected) do
-              [['published_at', operators::GREATER_THAN, '1970-01-01']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for',
-              'greater_than'
-          end
-
-          describe 'with a Hash with a "greater_than_or_equal_to" operator' do
-            let(:block) do
-              lambda do
-                { 'published_at' => greater_than_or_equal_to('1970-01-01') }
-              end
-            end
-            let(:expected) do
-              [
-                [
-                  'published_at',
-                  operators::GREATER_THAN_OR_EQUAL_TO,
-                  '1970-01-01'
-                ]
-              ]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for',
-              'greater_than_or_equal_to'
-          end
-
-          describe 'with a Hash with a "gt" operator' do
-            let(:block) do
-              -> { { 'published_at' => gt('1970-01-01') } }
-            end
-            let(:expected) do
-              [['published_at', operators::GREATER_THAN, '1970-01-01']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'gt'
-          end
-
-          describe 'with a Hash with a "gte" operator' do
-            let(:block) do
-              -> { { 'published_at' => gte('1970-01-01') } }
-            end
-            let(:expected) do
-              [
-                [
-                  'published_at',
-                  operators::GREATER_THAN_OR_EQUAL_TO,
-                  '1970-01-01'
-                ]
-              ]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'gte'
-          end
-
-          describe 'with a Hash with a "less_than" operator' do
-            let(:block) do
-              -> { { 'published_at' => less_than('1970-01-01') } }
-            end
-            let(:expected) do
-              [['published_at', operators::LESS_THAN, '1970-01-01']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for',
-              'less_than'
-          end
-
-          describe 'with a Hash with a "less_than_or_equal_to" operator' do
-            let(:block) do
-              -> { { 'published_at' => less_than_or_equal_to('1970-01-01') } }
-            end
-            let(:expected) do
-              [['published_at', operators::LESS_THAN_OR_EQUAL_TO, '1970-01-01']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for',
-              'less_than_or_equal_to'
-          end
-
-          describe 'with a Hash with a "lt" operator' do
-            let(:block) do
-              -> { { 'published_at' => lt('1970-01-01') } }
-            end
-            let(:expected) do
-              [['published_at', operators::LESS_THAN, '1970-01-01']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'lt'
-          end
-
-          describe 'with a Hash with a "lte" operator' do
-            let(:block) do
-              -> { { 'published_at' => lte('1970-01-01') } }
-            end
-            let(:expected) do
-              [['published_at', operators::LESS_THAN_OR_EQUAL_TO, '1970-01-01']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'lte'
-          end
-
-          describe 'with a Hash with a "ne" operator' do
-            let(:block) do
-              -> { { 'series' => ne('Earthsea') } }
-            end
-            let(:expected) do
-              [['series', operators::NOT_EQUAL, 'Earthsea']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'ne'
-          end
-
-          describe 'with a Hash with a "not_equal" operator' do
-            let(:block) do
-              -> { { 'series' => not_equal('Earthsea') } }
-            end
-            let(:expected) do
-              [['series', operators::NOT_EQUAL, 'Earthsea']]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for',
-              'not_equal'
-          end
-
-          describe 'with a Hash with a "not_one_of" operator and an Array' do
-            let(:block) do
-              lambda do
-                {
-                  'series' => not_one_of(
-                    ['Earthsea', 'The Lord of the Rings']
-                  )
-                }
-              end
-            end
-            let(:expected) do
-              [
-                [
-                  'series',
-                  operators::NOT_ONE_OF,
-                  ['Earthsea', 'The Lord of the Rings']
-                ]
-              ]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for',
-              'not_one_of'
-          end
-
-          describe 'with a Hash with a "not_one_of" operator and values' do
-            let(:block) do
-              lambda do
-                { 'series' => not_one_of('Earthsea', 'The Lord of the Rings') }
-              end
-            end
-            let(:expected) do
-              [
-                [
-                  'series',
-                  operators::NOT_ONE_OF,
-                  ['Earthsea', 'The Lord of the Rings']
-                ]
-              ]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for',
-              'not_one_of'
-          end
-
-          describe 'with a Hash with a "one_of" operator and an Array' do
-            let(:block) do
-              lambda do
-                { 'series' => one_of(['Earthsea', 'The Lord of the Rings']) }
-              end
-            end
-            let(:expected) do
-              [
-                [
-                  'series',
-                  operators::ONE_OF,
-                  ['Earthsea', 'The Lord of the Rings']
-                ]
-              ]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'one_of'
-          end
-
-          describe 'with a Hash with a "one_of" operator and values' do
-            let(:block) do
-              lambda do
-                { 'series' => one_of('Earthsea', 'The Lord of the Rings') }
-              end
-            end
-            let(:expected) do
-              [
-                [
-                  'series',
-                  operators::ONE_OF,
-                  ['Earthsea', 'The Lord of the Rings']
-                ]
-              ]
-            end
-
-            it 'should parse the criteria' do
-              expect(parse_criteria(&block)).to be == expected
-            end
-
-            include_examples 'should print a deprecation warning for', 'one_of'
-          end
-
-          describe 'with a Hash with an unknown operator' do
-            let(:error_class) do
-              Cuprum::Collections::Queries::UnknownOperatorException
-            end
-            let(:error_message) do
-              'unknown operator "random"'
-            end
-            let(:block) do
-              -> { { 'genre' => random('Science Fiction', 'Fantasy') } }
-            end
-
-            it 'should raise an exception' do
-              expect { parse_criteria(&block) }
-                .to raise_error error_class, error_message
-            end
-
-            it 'should preserve the original exception', :aggregate_failures do
-              parse_criteria(&block)
-            rescue error_class => exception
-              expect(exception.cause).to be_a NameError
-              expect(exception.name).to be == :random
-            end
-          end
-        end
       end
     end
 

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

@@ -12,6 +12,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     include Cuprum::Collections::RSpec::Contracts::Scopes::CompositionContracts
 
     # Contract validating the behavior of a logical AND scope implementation.
+    #
+    # @deprecated 0.6.0
     module ShouldBeAConjunctionScopeContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -23,6 +25,17 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
       #   @param abstract [Boolean] if true, the scope is abstract and does not
       #     define a #call implementation. Defaults to false.
       contract do |abstract: false|
+        message =
+          'Use deferred examples "should implement the ConjunctionScope ' \
+          'methods"'
+        SleepingKingStudios::Tools::Toolbelt
+          .instance
+          .core_tools
+          .deprecate(
+            'ShouldBeAConjunctionScopeContract',
+            message:
+          )
+
         include_contract 'should be a container scope', invertible: true
 
         include_contract 'should compose scopes for conjunction'
@@ -69,6 +82,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating the behavior of a logical OR scope implementation.
+    #
+    # @deprecated 0.6.0
     module ShouldBeADisjunctionScopeContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -80,6 +95,17 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
       #   @param abstract [Boolean] if true, the scope is abstract and does not
       #     define a #call implementation. Defaults to false.
       contract do |abstract: false|
+        message =
+          'Use deferred examples "should implement the DisjunctionScope ' \
+          'methods"'
+        SleepingKingStudios::Tools::Toolbelt
+          .instance
+          .core_tools
+          .deprecate(
+            'ShouldBeADisjunctionScopeContract',
+            message:
+          )
+
         include_contract 'should be a container scope', invertible: true
 
         include_contract 'should compose scopes for disjunction'
@@ -126,6 +152,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating the behavior of a Conjunction scope implementation.
+    #
+    # @deprecated 0.6.0
     module ShouldFilterDataByLogicalAndContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -211,6 +239,8 @@ module Cuprum::Collections::RSpec::Contracts::Scopes
     end
 
     # Contract validating the behavior of a Disjunction scope implementation.
+    #
+    # @deprecated 0.6.0
     module ShouldFilterDataByLogicalOrContract
       extend RSpec::SleepingKingStudios::Contract
 

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

@@ -4,6 +4,8 @@ require 'cuprum/collections/rspec/contracts'
 
 module Cuprum::Collections::RSpec::Contracts
   # Namespace for RSpec contracts validating the behavior of scopes.
+  #
+  # @deprecated 0.6.0
   module Scopes
     autoload :CriteriaContracts,
       'cuprum/collections/rspec/contracts/scopes/criteria_contracts'

data/lib/cuprum/collections/rspec/contracts.rb

@@ -5,20 +5,12 @@ require 'cuprum/collections/rspec'
 module Cuprum::Collections::RSpec
   # Namespace for RSpec contract objects.
   module Contracts
-    autoload :AssociationContracts,
-      'cuprum/collections/rspec/contracts/association_contracts'
-    autoload :Basic,
-      'cuprum/collections/rspec/contracts/basic'
-    autoload :CollectionContracts,
-      'cuprum/collections/rspec/contracts/collection_contracts'
-    autoload :CommandContracts,
-      'cuprum/collections/rspec/contracts/command_contracts'
     autoload :QueryContracts,
       'cuprum/collections/rspec/contracts/query_contracts'
-    autoload :RelationContracts,
-      'cuprum/collections/rspec/contracts/relation_contracts'
     autoload :RepositoryContracts,
       'cuprum/collections/rspec/contracts/repository_contracts'
+    autoload :ScopeContracts,
+      'cuprum/collections/rspec/contracts/scope_contracts'
     autoload :Scopes,
       'cuprum/collections/rspec/contracts/scopes'
   end