payload 0.1.0 → 0.2.0

data/lib/payload/definition_list.rb

@@ -1,5 +1,6 @@
+require 'payload/definition'
 require 'payload/exported_definition'
-require 'payload/undefined_dependency_error'
+require 'payload/undefined_definition'
 
 module Payload
   # Immutable list of definitions.
@@ -12,14 +13,18 @@ module Payload
       @definitions = definitions
     end
 
-    def add(name, definition)
-      self.class.new(definitions.merge(name => definition))
+    def add(name, resolver)
+      value = find(name).set(Definition.new(resolver))
+      self.class.new(definitions.merge(name => value))
     end
 
     def find(name)
-      definitions.fetch(name) do
-        raise(UndefinedDependencyError, "No definition for dependency: #{name}")
-      end
+      definitions.fetch(name) { UndefinedDefinition.new(name) }
+    end
+
+    def decorate(name, block)
+      decorated = find(name).decorate(block)
+      self.class.new(@definitions.merge(name => decorated))
     end
 
     def export(names)

data/lib/payload/dependency_already_defined_error.rb

@@ -0,0 +1,5 @@
+module Payload
+  # Raised when attempting to define a dependency which is already defined.
+  class DependencyAlreadyDefinedError < StandardError
+  end
+end

data/lib/payload/exported_definition.rb

@@ -1,5 +1,5 @@
 module Payload
-  # Decorates a base definition such as {ServiceDefinition} to provide access to
+  # Decorates a base definition such as {ServiceResolver} to provide access to
   # private dependencies in the {Container} from which the definition was
   # exported.
   #
@@ -13,7 +13,17 @@ module Payload
     end
 
     def resolve(container)
-      @definition.resolve(container.import(@private_definitions))
+      definition.resolve(container.import(private_definitions))
     end
+
+    def ==(other)
+      other.is_a?(ExportedDefinition) &&
+        definition == other.definition &&
+        private_definitions == other.private_definitions
+    end
+
+    protected
+
+    attr_reader :definition, :private_definitions
   end
 end

data/lib/payload/factory.rb

@@ -6,7 +6,7 @@ module Payload
   #
   # @see Container#factory Container#factory for defining and using factories.
   class Factory
-    # Used internally by {FactoryDefinition}.
+    # Used internally by {FactoryResolver}.
     #
     # @api private
     def initialize(container, block, decorators)

data/lib/payload/factory_resolver.rb

@@ -0,0 +1,18 @@
+require 'payload/factory'
+
+module Payload
+  # Encapsulates logic for resolving factory definitions.
+  #
+  # Used internally by {Container}. Use {Container#factory}.
+  #
+  # @api private
+  class FactoryResolver
+    def initialize(block)
+      @block = block
+    end
+
+    def resolve(container, decorators)
+      Factory.new(container, @block, decorators)
+    end
+  end
+end

data/lib/payload/service_resolver.rb

@@ -0,0 +1,17 @@
+module Payload
+  # Encapsulates logic for resolving service definitions.
+  #
+  # Used internally by {Container}. Use {Container#service}.
+  #
+  # @api private
+  class ServiceResolver
+    def initialize(block)
+      @block = block
+    end
+
+    def resolve(container, decorators)
+      base = @block.call(container)
+      decorators.decorate(base, container)
+    end
+  end
+end

data/lib/payload/undefined_definition.rb

@@ -0,0 +1,37 @@
+require 'payload/decorator_chain'
+require 'payload/undefined_dependency_error'
+
+module Payload
+  # Returns from {DefinitionList} when attempting to find an undefined
+  # definition.
+  #
+  # @api private
+  class UndefinedDefinition
+    def initialize(name, decorators = DecoratorChain.new)
+      @name = name
+      @decorators = decorators
+    end
+
+    def ==(other)
+      other.is_a?(UndefinedDefinition) && name == other.name
+    end
+
+    def resolve(container)
+      raise UndefinedDependencyError, "No definition for dependency: #{name}"
+    end
+
+    def decorate(block)
+      self.class.new(@name, @decorators.add(block))
+    end
+
+    def set(replacement)
+      @decorators.inject(replacement) do |definition, decorator|
+        definition.decorate(decorator)
+      end
+    end
+
+    protected
+
+    attr_reader :name
+  end
+end

data/lib/payload/version.rb

@@ -1,3 +1,3 @@
 module Payload
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/payload/container_spec.rb

@@ -68,10 +68,18 @@ describe Payload::Container do
       expect(original[:example]).to eq('expected component')
     end
 
+    it 'decorates a dependency which is defined later' do
+      container = build_container.
+        decorate(:example) { |component, _| "decorated #{component}" }.
+        service(:example) { |_| 'expected component' }
+
+      expect(container[:example]).to eq('decorated expected component')
+    end
+
     it 'raises an exception for an unknown dependency' do
       container = build_container
 
-      expect { container.decorate(:anything) }
+      expect { container.decorate(:undefined)[:undefined] }
         .to raise_error(Payload::UndefinedDependencyError)
     end
   end
@@ -122,9 +130,9 @@ describe Payload::Container do
   describe '#import' do
     it 'returns a new container with the given definitions' do
       first_export =
-        Payload::ServiceDefinition.new(lambda { |config| 'one' })
+        Payload::ServiceResolver.new(lambda { |config| 'one' })
       second_export =
-        Payload::ServiceDefinition.new(lambda { |config| 'two' })
+        Payload::ServiceResolver.new(lambda { |config| 'two' })
       definitions = Payload::DefinitionList.
         new.
         add(:one, first_export).

data/spec/payload/decorator_chain_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 require 'payload/decorator_chain'
 
 describe Payload::DecoratorChain do
+  it 'is enumerable' do
+    expect(Payload::DecoratorChain.new).to be_a(Enumerable)
+  end
+
   describe '#decorate' do
     it 'applies a series of decorators to a component' do
       chain = Payload::DecoratorChain
@@ -26,4 +30,34 @@ describe Payload::DecoratorChain do
       expect(result).to eq('Decorated original')
     end
   end
+
+  describe '#each' do
+    it 'yields each decorator' do
+      first = double('first')
+      second = double('second')
+      chain = Payload::DecoratorChain.new.add(first).add(second)
+      result = []
+
+      chain.each { |yielded| result << yielded }
+
+      expect(result).to eq([first, second])
+    end
+  end
+
+  describe '#==' do
+    it 'is equal with the same decorators' do
+      expect(Payload::DecoratorChain.new.add(:one).add(:two)).
+        to eq(Payload::DecoratorChain.new.add(:one).add(:two))
+    end
+
+    it 'is unequal with different decorators' do
+      expect(Payload::DecoratorChain.new.add(:one).add(:two)).
+        not_to eq(Payload::DecoratorChain.new.add(:one).add(:three))
+    end
+
+    it 'is unequal with another type' do
+      expect(Payload::DecoratorChain.new.add(:one).add(:two)).
+        not_to eq(:other)
+    end
+  end
 end

data/spec/payload/definition_list_spec.rb

@@ -4,22 +4,74 @@ require 'payload/definition_list'
 describe Payload::DefinitionList do
   describe '#add' do
     it 'adds a dependency to be found later' do
-      definition = double('definition')
+      resolver = double('resolver')
+      definition = Payload::Definition.new(resolver)
       definition_list = Payload::DefinitionList.new
 
-      defined = definition_list.add(:example, definition)
+      defined = definition_list.add(:example, resolver)
 
       expect(defined.find(:example)).to eq(definition)
     end
 
+    it 'does not replace an existing definition' do
+      definition_list = Payload::DefinitionList.new
+
+      defined = definition_list.add(:example, :original)
+
+      expect { defined.add(:example, :replacement) }.
+        to raise_error(Payload::DependencyAlreadyDefinedError)
+    end
+
+    it 'does not mutate the list' do
+      resolver = double('resolver')
+      definition_list = Payload::DefinitionList.new
+
+      definition_list.add(:example, resolver)
+
+      expect(definition_list.find(:example)).
+        to eq(Payload::UndefinedDefinition.new(:example))
+    end
+  end
+
+  describe '#decorate' do
+    it 'replaces a dependency with a decorated version' do
+      resolver = double('resolver')
+      decorator = double('decorator')
+      decorated = Payload::Definition.new(resolver).decorate(decorator)
+      definition_list = Payload::DefinitionList.new
+
+      defined = definition_list.
+        add(:example, resolver).
+        decorate(:example, decorator)
+
+      expect(defined.find(:example)).to eq(decorated)
+    end
+
+    it 'decorates an undefined dependency' do
+      resolver = double('resolver')
+      decorator = double('decorator')
+      decorated = Payload::Definition.new(resolver).decorate(decorator)
+      definition_list = Payload::DefinitionList.new
+
+      defined = definition_list.
+        decorate(:example, decorator).
+        add(:example, resolver)
+
+      expect(defined.find(:example)).to eq(decorated)
+    end
+
     it 'does not mutate the list' do
-      definition = double('definition')
+      resolver = double('resolver')
+      decorator = double('decorator')
+      definition = Payload::Definition.new(resolver)
       definition_list = Payload::DefinitionList.new
 
-      definition_list.add(:example, definition)
+      defined = definition_list.
+        add(:example, resolver)
+
+      defined.decorate(:example, decorator)
 
-      expect { definition_list.find(:example) }.
-        to raise_error(Payload::UndefinedDependencyError)
+      expect(defined.find(:example)).to eq(definition)
     end
   end
 
@@ -30,23 +82,21 @@ describe Payload::DefinitionList do
         add(:one, 'first').
         add(:two, 'second').
         add(:three, 'third')
-      first_exported = double('exported_first')
-      allow(Payload::ExportedDefinition).
-        to receive(:new).
-        with('first', definition_list).
-        and_return(first_exported)
-      second_exported = double('exported_second')
-      allow(Payload::ExportedDefinition).
-        to receive(:new).
-        with('second', definition_list).
-        and_return(second_exported)
 
       exported = definition_list.export([:one, :two])
 
-      expect(exported.find(:one)).to eq(first_exported)
-      expect(exported.find(:two)).to eq(second_exported)
-      expect { exported.find(:three) }.
-        to raise_error(Payload::UndefinedDependencyError)
+      first = Payload::ExportedDefinition.new(
+        Payload::Definition.new('first'),
+        definition_list
+      )
+      second = Payload::ExportedDefinition.new(
+        Payload::Definition.new('second'),
+        definition_list
+      )
+      third = Payload::UndefinedDefinition.new(:three)
+      expect(exported.find(:one)).to eq(first)
+      expect(exported.find(:two)).to eq(second)
+      expect(exported.find(:three)).to eq(third)
     end
   end
 
@@ -56,23 +106,24 @@ describe Payload::DefinitionList do
       right = Payload::DefinitionList.new.add(:two, 'second')
       merged = left.import(right)
 
-      expect(merged.find(:one)).to eq('first')
-      expect(merged.find(:two)).to eq('second')
+      expect(merged.find(:one)).to eq(Payload::Definition.new('first'))
+      expect(merged.find(:two)).to eq(Payload::Definition.new('second'))
     end
   end
 
   describe '#find' do
-    it 'raises for an unknown definition' do
+    it 'returns an unknown definition' do
       definition_list = Payload::DefinitionList.new
 
-      expect { definition_list.find(:example) }.
-        to raise_error(Payload::UndefinedDependencyError)
+      expect(definition_list.find(:example)).
+        to eq(Payload::UndefinedDefinition.new(:example))
     end
 
     it 'returns an existing definition' do
-      definition = double('definition')
+      resolver = double('resolver')
+      definition = Payload::Definition.new(resolver)
       definition_list =
-        Payload::DefinitionList.new.add(:example, definition)
+        Payload::DefinitionList.new.add(:example, resolver)
 
       expect(definition_list.find(:example)).to eq(definition)
     end

data/spec/payload/definition_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'payload/definition'
+
+describe Payload::Definition do
+  describe '#resolve' do
+    it 'provides the container and decorators to its resolver' do
+      resolved = double('resolved')
+      resolver = double('resolver')
+      container = double('container')
+      decorators = double('decorators')
+      resolver.stub(:resolve).and_return(resolved)
+      definition = Payload::Definition.new(resolver, decorators)
+
+      result = definition.resolve(container)
+
+      expect(result).to eq(resolved)
+      expect(resolver).to have_received(:resolve).with(container, decorators)
+    end
+  end
+
+  describe '#decorate' do
+    it 'returns a new decorated service' do
+      decorator = double('first_decorator')
+      resolver = double('resolver')
+      resolver.stub(:resolve)
+      container = double('container')
+      decorated = double('decorated')
+      decorators = double('decorators')
+      decorators.stub(:add).and_return(decorated)
+      Payload::DecoratorChain.stub(:new).and_return(decorators)
+      definition = Payload::Definition.new(resolver)
+
+      definition.
+        decorate(decorator).
+        resolve(container)
+
+      expect(decorators).to have_received(:add).with(decorator)
+      expect(resolver).to have_received(:resolve).with(container, decorated)
+    end
+  end
+
+  describe '#set' do
+    it 'raises an already defined error' do
+      service = Payload::Definition.new(double('resolver'))
+
+      expect { service.set(double('replacement')) }.
+        to raise_error(Payload::DependencyAlreadyDefinedError)
+    end
+  end
+
+  describe '#==' do
+    it 'is true with the same resolver and decorators' do
+      expect(Payload::Definition.new(:resolver).decorate(:decorator)).
+        to eq(Payload::Definition.new(:resolver).decorate(:decorator))
+    end
+
+    it 'is false with a different resolver' do
+      expect(Payload::Definition.new(:resolver).decorate(:decorator)).
+        not_to eq(Payload::Definition.new(:other_resolver).decorate(:decorator))
+    end
+
+    it 'is false with different decorators' do
+      expect(Payload::Definition.new(:resolver).decorate(:decorator)).
+        not_to eq(Payload::Definition.new(:resolver).decorate(:other_decorator))
+    end
+
+    it 'is false with a non-definition' do
+      expect(Payload::Definition.new(:resolver).decorate(:decorator)).
+        not_to eq(:other)
+    end
+  end
+end