cuprum-collections 0.1.0 → 0.3.0.rc.0

data/lib/cuprum/collections/repository.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require 'cuprum/collections'
+
+module Cuprum::Collections
+  # A repository represents a group of collections.
+  #
+  # Conceptually, a repository represents one or more underlying data stores. An
+  # application might have one repository for each data store, e.g. one
+  # repository for relational data, a second repository for document-based data,
+  # and so on. The application may instead aggregate all of its collections into
+  # a single repository, relying on the shared interface of all Collection
+  # implementations.
+  class Repository
+    extend Forwardable
+
+    # Error raised when trying to add an existing collection to the repository.
+    class DuplicateCollectionError < StandardError; end
+
+    # Error raised when trying to add an invalid collection to the repository.
+    class InvalidCollectionError < StandardError; end
+
+    # Error raised when trying to access a collection that is not defined.
+    class UndefinedCollectionError < StandardError; end
+
+    def initialize
+      @collections = {}
+    end
+
+    # @!method keys
+    #   Returns the names of the collections in the repository.
+    #
+    #   @return [Array<String>] the collection names.
+
+    def_delegators :@collections, :keys
+
+    # Finds and returns the collection with the given name.
+    #
+    # @param qualified_name [String, Symbol] The qualified name of the
+    #   collection to return.
+    #
+    # @return [Object] the requested collection.
+    #
+    # @raise [Cuprum::Collection::Repository::UndefinedCOllectionError] if the
+    #   requested collection is not in the repository.
+    def [](qualified_name)
+      @collections.fetch(qualified_name.to_s) do
+        raise UndefinedCollectionError,
+          "repository does not define collection #{qualified_name.inspect}"
+      end
+    end
+
+    # Adds the collection to the repository.
+    #
+    # The collection must implement the #collection_name property. Repository
+    # subclasses may enforce additional requirements.
+    #
+    # @param collection [#collection_name] The collection to add to the
+    #   repository.
+    # @param force [true, false] If true, override an existing collection with
+    #   the same name.
+    #
+    # @return [Cuprum::Rails::Repository] the repository.
+    #
+    # @raise [DuplicateCollectionError] if a collection with the same name
+    #   already exists in the repository.
+    def add(collection, force: false)
+      validate_collection!(collection)
+
+      if !force && key?(collection.qualified_name.to_s)
+        raise DuplicateCollectionError,
+          "collection #{collection.qualified_name} already exists"
+      end
+
+      @collections[collection.qualified_name.to_s] = collection
+
+      self
+    end
+    alias << add
+
+    # Checks if a collection with the given name exists in the repository.
+    #
+    # @param qualified_name [String, Symbol] The name to check for.
+    #
+    # @return [true, false] true if the key exists, otherwise false.
+    def key?(qualified_name)
+      @collections.key?(qualified_name.to_s)
+    end
+
+    private
+
+    def valid_collection?(collection)
+      collection.respond_to?(:collection_name)
+    end
+
+    def validate_collection!(collection)
+      return if valid_collection?(collection)
+
+      raise InvalidCollectionError,
+        "#{collection.inspect} is not a valid collection"
+    end
+  end
+end

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

@@ -58,7 +58,7 @@ module Cuprum::Collections::RSpec
         let(:attributes) do
           {
             title:    'Gideon the Ninth',
-            author:   'Tammsyn Muir',
+            author:   'Tamsyn Muir',
             series:   'The Locked Tomb',
             category: 'Horror'
           }
@@ -124,7 +124,7 @@ module Cuprum::Collections::RSpec
           let(:attributes) do
             {
               title:    'Gideon the Ninth',
-              author:   'Tammsyn Muir',
+              author:   'Tamsyn Muir',
               series:   'The Locked Tomb',
               category: 'Horror'
             }

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

@@ -50,7 +50,7 @@ module Cuprum::Collections::RSpec
         let(:attributes) do
           {
             title:    'Gideon the Ninth',
-            author:   'Tammsyn Muir',
+            author:   'Tamsyn Muir',
             series:   'The Locked Tomb',
             category: 'Horror'
           }

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

@@ -1,153 +1,190 @@
 # frozen_string_literal: true
 
+require 'rspec/sleeping_king_studios/contract'
+
 require 'cuprum/collections/rspec'
 
 module Cuprum::Collections::RSpec
   # Contract validating the behavior of a Collection.
-  COLLECTION_CONTRACT = lambda do
-    shared_examples 'should define the command' do |command_name, command_class|
-      tools      = SleepingKingStudios::Tools::Toolbelt.instance
-      class_name = tools.str.camelize(command_name)
-
-      describe "::#{class_name}" do
-        let(:constructor_options) { {} }
-        let(:command) do
-          collection.const_get(class_name).new(**constructor_options)
-        end
+  module CollectionContract
+    extend RSpec::SleepingKingStudios::Contract
+
+    # @!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_examples 'should define the command' \
+      do |command_name, command_class|
+        tools      = SleepingKingStudios::Tools::Toolbelt.instance
+        class_name = tools.str.camelize(command_name)
+
+        describe "::#{class_name}" do
+          let(:constructor_options) { {} }
+          let(:command) do
+            collection.const_get(class_name).new(**constructor_options)
+          end
 
-        it { expect(collection).to define_constant(class_name) }
+          it { expect(collection).to define_constant(class_name) }
 
-        it { expect(collection.const_get(class_name)).to be_a Class }
+          it { expect(collection.const_get(class_name)).to be_a Class }
 
-        it { expect(collection.const_get(class_name)).to be < command_class }
-
-        command_options.each do |option_name|
-          it "should set the ##{option_name}" do
-            expect(command.send(option_name))
-              .to be == collection.send(option_name)
-          end
-        end
-
-        describe 'with options' do
-          let(:constructor_options) do
-            {
-              data:        [],
-              member_name: 'tome'
-            }
-          end
+          it { expect(collection.const_get(class_name)).to be < command_class }
 
           command_options.each do |option_name|
             it "should set the ##{option_name}" do
-              expect(command.send(option_name)).to(
-                be == constructor_options.fetch(option_name) do
-                  collection.send(option_name)
-                end
-              )
+              expect(command.send(option_name))
+                .to be == collection.send(option_name)
             end
           end
-        end
-      end
 
-      describe "##{command_name}" do
-        let(:constructor_options) { {} }
-        let(:command) do
-          collection.send(command_name, **constructor_options)
-        end
+          describe 'with options' do
+            let(:constructor_options) do
+              {
+                data:        [],
+                member_name: 'tome'
+              }
+            end
 
-        it 'should define the command' do
-          expect(collection)
-            .to respond_to(command_name)
-            .with(0).arguments
-            .and_any_keywords
+            command_options.each do |option_name|
+              it "should set the ##{option_name}" do
+                expect(command.send(option_name)).to(
+                  be == constructor_options.fetch(option_name) do
+                    collection.send(option_name)
+                  end
+                )
+              end
+            end
+          end
         end
 
-        it { expect(command).to be_a collection.const_get(class_name) }
-
-        command_options.each do |option_name|
-          it "should set the ##{option_name}" do
-            expect(command.send(option_name))
-              .to be == collection.send(option_name)
+        describe "##{command_name}" do
+          let(:constructor_options) { {} }
+          let(:command) do
+            collection.send(command_name, **constructor_options)
           end
-        end
 
-        describe 'with options' do
-          let(:constructor_options) do
-            {
-              data:        [],
-              member_name: 'tome'
-            }
+          it 'should define the command' do
+            expect(collection)
+              .to respond_to(command_name)
+              .with(0).arguments
+              .and_any_keywords
           end
 
+          it { expect(command).to be_a collection.const_get(class_name) }
+
           command_options.each do |option_name|
             it "should set the ##{option_name}" do
-              expect(command.send(option_name)).to(
-                be == constructor_options.fetch(option_name) do
-                  collection.send(option_name)
-                end
-              )
+              expect(command.send(option_name))
+                .to be == collection.send(option_name)
+            end
+          end
+
+          describe 'with options' do
+            let(:constructor_options) do
+              {
+                data:        [],
+                member_name: 'tome'
+              }
+            end
+
+            command_options.each do |option_name|
+              it "should set the ##{option_name}" do
+                expect(command.send(option_name)).to(
+                  be == constructor_options.fetch(option_name) do
+                    collection.send(option_name)
+                  end
+                )
+              end
             end
           end
         end
       end
-    end
 
-    include_examples 'should define the command',
-      :assign_one,
-      commands_namespace::AssignOne
+      include_examples 'should define the command',
+        :assign_one,
+        commands_namespace::AssignOne
+
+      include_examples 'should define the command',
+        :build_one,
+        commands_namespace::BuildOne
 
-    include_examples 'should define the command',
-      :build_one,
-      commands_namespace::BuildOne
+      include_examples 'should define the command',
+        :destroy_one,
+        commands_namespace::DestroyOne
 
-    include_examples 'should define the command',
-      :destroy_one,
-      commands_namespace::DestroyOne
+      include_examples 'should define the command',
+        :find_many,
+        commands_namespace::FindMany
 
-    include_examples 'should define the command',
-      :find_many,
-      commands_namespace::FindMany
+      include_examples 'should define the command',
+        :find_matching,
+        commands_namespace::FindMatching
 
-    include_examples 'should define the command',
-      :find_matching,
-      commands_namespace::FindMatching
+      include_examples 'should define the command',
+        :find_one,
+        commands_namespace::FindOne
 
-    include_examples 'should define the command',
-      :find_one,
-      commands_namespace::FindOne
+      include_examples 'should define the command',
+        :insert_one,
+        commands_namespace::InsertOne
 
-    include_examples 'should define the command',
-      :insert_one,
-      commands_namespace::InsertOne
+      include_examples 'should define the command',
+        :update_one,
+        commands_namespace::UpdateOne
 
-    include_examples 'should define the command',
-      :update_one,
-      commands_namespace::UpdateOne
+      include_examples 'should define the command',
+        :validate_one,
+        commands_namespace::ValidateOne
 
-    include_examples 'should define the command',
-      :validate_one,
-      commands_namespace::ValidateOne
+      describe '#collection_name' do
+        include_examples 'should define reader',
+          :collection_name,
+          -> { an_instance_of(String) }
+      end
 
-    describe '#query' do
-      let(:default_order) { defined?(super()) ? super() : {} }
-      let(:query)         { collection.query }
+      describe '#count' do
+        it { expect(collection).to respond_to(:count).with(0).arguments }
 
-      it { expect(collection).to respond_to(:query).with(0).arguments }
+        it { expect(collection).to have_aliased_method(:count).as(:size) }
 
-      it { expect(collection.query).to be_a query_class }
+        it { expect(collection.count).to be 0 }
 
-      it 'should set the query options' do
-        query_options.each do |option, value|
-          expect(collection.query.send option).to be == value
+        wrap_context 'when the collection has many items' do
+          it { expect(collection.count).to be items.count }
         end
       end
 
-      it { expect(query.criteria).to be == [] }
+      describe '#qualified_name' do
+        include_examples 'should define reader',
+          :qualified_name,
+          -> { an_instance_of(String) }
+      end
 
-      it { expect(query.limit).to be nil }
+      describe '#query' do
+        let(:default_order) { defined?(super()) ? super() : {} }
+        let(:query)         { collection.query }
 
-      it { expect(query.offset).to be nil }
+        it { expect(collection).to respond_to(:query).with(0).arguments }
 
-      it { expect(query.order).to be == default_order }
+        it { expect(collection.query).to be_a query_class }
+
+        it 'should set the query options' do
+          query_options.each do |option, value|
+            expect(collection.query.send option).to be == value
+          end
+        end
+
+        it { expect(query.criteria).to be == [] }
+
+        it { expect(query.limit).to be nil }
+
+        it { expect(query.offset).to be nil }
+
+        it { expect(query.order).to be == default_order }
+      end
     end
   end
 end

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

@@ -28,9 +28,10 @@ module Cuprum::Collections::RSpec
         let(:primary_key) { invalid_primary_key_value }
         let(:expected_error) do
           Cuprum::Collections::Errors::NotFound.new(
-            collection_name:    command.collection_name,
-            primary_key_name:   primary_key_name,
-            primary_key_values: primary_key
+            attribute_name:  primary_key_name,
+            attribute_value: primary_key,
+            collection_name: collection_name,
+            primary_key:     true
           )
         end
 
@@ -59,9 +60,10 @@ module Cuprum::Collections::RSpec
           let(:primary_key) { invalid_primary_key_value }
           let(:expected_error) do
             Cuprum::Collections::Errors::NotFound.new(
-              collection_name:    command.collection_name,
-              primary_key_name:   primary_key_name,
-              primary_key_values: primary_key
+              attribute_name:  primary_key_name,
+              attribute_value: primary_key,
+              collection_name: collection_name,
+              primary_key:     true
             )
           end