fabrique 0.3.1 → 1.0.0

data/lib/fabrique/plugin_registry.rb

@@ -1,56 +0,0 @@
-module Fabrique
-
-  class PluginRegistry
-
-    def initialize(name)
-      @name = name
-      @registrations = []
-    end
-
-    def register(id, type, constructor)
-      if existing = find_registration(id)
-        raise ArgumentError, "could not register #{type} as #{id} in #{@name}: #{existing.type} already registered as #{id}"
-      end
-      @registrations << Registration.new(id, type, constructor)
-      true
-    end
-
-    def acquire(id, properties = nil)
-      if registration = find_registration(id)
-        registration.call_constructor(properties)
-      else
-        raise ArgumentError, "#{id} not registered in #{@name}"
-      end
-    end
-
-    private
-
-      def find_registration(id)
-        @registrations.detect { |r| r.id == id }
-      end
-
-      def unregister(id)
-        @registrations.delete(find_registration(id))
-      end
-
-      class Registration
-
-        attr_reader :id, :type, :constructor
-
-        def initialize(id, type, constructor)
-          @id, @type, @constructor = id, type, constructor
-        end
-
-        def call_constructor(properties = nil)
-          # TODO Push conditional into construction helpers
-          if properties.nil?
-            @constructor.call(@type)
-          else
-            @constructor.call(@type, properties)
-          end
-        end
-
-      end
-  end
-
-end

data/spec/fabrique/argument_adaptor/keyword_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-require "fabrique/test"
-
-describe Fabrique::ArgumentAdaptor::Keyword do
-
-  let(:properties) { {size: "small", color: "red", shape: "dot"} }
-
-  describe "#adapt(*properties)" do
-
-    context "when called without properties" do
-
-      it "returns an empty array" do
-        expect(subject.adapt).to eql []
-      end
-
-    end
-
-    context "when called with empty properties" do
-
-      it "returns an empty hash in an empty array" do
-        expect(subject.adapt({})).to eql [{}]
-      end
-
-    end
-
-    context "when called with properties" do
-
-      it "returns a hash containing the properties" do
-        expect(subject.adapt(properties)).to eql [properties]
-      end
-
-    end
-
-    it "supports properties hash constructors" do
-      object = Fabrique::Test::Fixtures::Constructors::ClassWithPropertiesHashConstructor.new(*subject.adapt(properties))
-      expect(object.size).to eql properties[:size]
-      expect(object.color).to eql properties[:color]
-      expect(object.shape).to eql properties[:shape]
-    end
-
-    it "supports keyword argument constructors" do
-      object = Fabrique::Test::Fixtures::Constructors::ClassWithKeywordArgumentConstructor.new(*subject.adapt(properties))
-      expect(object.size).to eql properties[:size]
-      expect(object.color).to eql properties[:color]
-      expect(object.shape).to eql properties[:shape]
-    end
-
-  end
-
-end

data/spec/fabrique/argument_adaptor/positional_spec.rb

@@ -1,166 +0,0 @@
-require "spec_helper"
-
-describe Fabrique::ArgumentAdaptor::Positional do
-
-  describe "::new(*argument_specifieres)" do
-
-    it "takes symbols as required argument names" do
-      expect { described_class.new(:arg_name1, :arg_name2, :arg_name3) }.to_not raise_error
-    end
-
-    it "takes one-element arrays as optional argument names with no default value" do
-      expect { described_class.new(:arg_name1, :arg_name2, [:arg_name3]) }.to_not raise_error
-    end
-
-    it "takes two-element arrays as optional argument names with a default value" do
-      expect { described_class.new(:arg_name1, [:arg_name2], [:arg_name3, "default arg3"]) }.to_not raise_error
-    end
-
-    it "allows no argument names (useful for a default constructor)" do
-      expect { described_class.new }.to_not raise_error
-    end
-
-    context "when passed arguments that are not symbols or optional argument specifier arrays" do
-
-      it "raises an ArgumentError" do
-        expect { described_class.new(:arg_name1, "arg_name2") }.to raise_error(ArgumentError, /invalid argument specifier/)
-        expect { described_class.new(:arg_name1, []) }.to raise_error(ArgumentError, /invalid argument specifier/)
-        expect { described_class.new(:arg_name1, ["arg_name2"]) }.to raise_error(ArgumentError, /invalid argument specifier/)
-        expect { described_class.new(:arg_name1, [:arg_name2, "value", "nonsense"]) }.to raise_error(ArgumentError, /invalid argument specifier/)
-      end
-
-    end
-
-  end
-
-  describe "#adapt(*properties)" do
-
-    context "when initialized with no required argument specifiers" do
-      context "when called without properties" do
-        it "returns an empty array" do
-          expect(subject.adapt).to eql []
-        end
-      end
-
-      context "when called with empty properties" do
-        it "returns an empty array" do
-          expect(subject.adapt({})).to eql []
-        end
-      end
-
-      context "when called with properties" do
-        it "returns an empty array" do
-          expect(subject.adapt(size: "small", color: "red", shape: "dot")).to eql []
-        end
-      end
-    end
-
-    context "when initialized with only required argument names" do
-      subject { described_class.new(:size, :color, :shape) }
-
-      context "when called with a property for each argument name" do
-        it "returns an array of the property value of each argument name in the order specified to new()" do
-          expect(subject.adapt(shape: "dot", size: "small", color: "red")).to eql ["small", "red", "dot"]
-        end
-      end
-
-      context "when called with at least one property missing for an argument name" do
-        it "raises an ArgumentError" do
-          expect { subject.adapt(size: "small", color: "red") }.to raise_error(ArgumentError, /required argument \w+ missing from properties/)
-        end
-      end
-
-      context "when called with extraneous properties" do
-        it "ignores them, returning an array of the property value of each argument name in the order specified to new()" do
-          expect(subject.adapt(size: "small", color: "red", shape: "dot", status: "on")).to eql ["small", "red", "dot"]
-        end
-      end
-    end
-
-    context "when initialized with only optional argument names with default values" do
-      subject { described_class.new([:size, "default size"], [:color, "default color"], [:shape, "default shape"]) }
-
-      context "when called with a property for each argument name" do
-        it "returns an array of the property value of each argument name in the order specified to new()" do
-          expect(subject.adapt(shape: "dot", size: "small", color: "red")).to eql ["small", "red", "dot"]
-        end
-      end
-
-      context "when called with at least one property missing for an argument name" do
-        it "returns an array of the provided property values and default values, in the order specified to new()" do
-          expect(subject.adapt(size: "small", color: "red")).to eql ["small", "red", "default shape"]
-        end
-      end
-
-      context "when called with extraneous properties" do
-        it "ignores them" do
-          expect(subject.adapt(size: "small", color: "red", status: "on")).to eql ["small", "red", "default shape"]
-        end
-      end
-
-    end
-
-    context "when initialized with optional argument names with no default values, followed by required argument names" do
-      subject { described_class.new([:size], [:color], :shape) }
-
-      context "when called with a property for each argument name" do
-        it "returns an array of the property value of each argument name in the order specified to new()" do
-          expect(subject.adapt(shape: "dot", size: "small", color: "red")).to eql ["small", "red", "dot"]
-        end
-      end
-
-      context "when called with at least one property missing for an optional argument" do
-        it "raises an ArgumentError (because the caller would be surprised by Ruby filling optional arguments from left to right)" do
-          expect {subject.adapt(color: "red", shape: "dot") }.to raise_error(ArgumentError, /optional argument size \(with no default\) missing from properties/)
-        end
-      end
-
-      context "when called with at least one property missing for a required argument" do
-        it "raises an ArgumentError" do
-          expect { subject.adapt(size: "small", color: "red") }.to raise_error(ArgumentError, /required argument \w+ missing from properties/)
-        end
-      end
-    end
-
-    context "when initialized with optional argument names with nil as the default value, followed by required argument names" do
-      subject { described_class.new([:size, nil], [:color, nil], :shape) }
-
-      context "when called with a property for each argument name" do
-        it "returns an array of the property value of each argument name in the order specified to new()" do
-          expect(subject.adapt(shape: "dot", size: "small", color: "red")).to eql ["small", "red", "dot"]
-        end
-      end
-
-      context "when called with at least one property missing for an optional argument" do
-        it "returns an array of the provided property values and default values, in the order specified to new()" do
-          expect(subject.adapt(color: "red", shape: "dot")).to eql [nil, "red", "dot"]
-        end
-      end
-
-      context "when called with at least one property missing for a required argument" do
-        it "raises an ArgumentError" do
-          expect { subject.adapt(size: "small", color: "red") }.to raise_error(ArgumentError, /required argument \w+ missing from properties/)
-        end
-      end
-    end
-
-    it "supports default constructors" do
-      klass = Fabrique::Test::Fixtures::Constructors::ClassWithDefaultConstructor
-      object = klass.new(*subject.adapt())
-      expect(object.size).to eql klass::DEFAULT_SIZE
-      expect(object.color).to eql klass::DEFAULT_COLOR
-      expect(object.shape).to eql klass::DEFAULT_SHAPE
-    end
-
-    it "supports positional argument constructors" do
-      klass = Fabrique::Test::Fixtures::Constructors::ClassWithPositionalArgumentConstructor
-      subject = described_class.new(:size, :color, :shape)
-      object = klass.new(*subject.adapt(size: "small", color: "red", shape: "dot"))
-      expect(object.size).to eql "small"
-      expect(object.color).to eql "red"
-      expect(object.shape).to eql "dot"
-    end
-
-  end
-
-end

data/spec/fabrique/construction/as_is_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe Fabrique::Construction::AsIs do
-
-  describe "call(type, properties = nil)" do
-
-    it "applies identity to the type" do
-      constructed = subject.call(type = Object.new)
-      expect(constructed.object_id).to eql type.object_id
-    end
-
-    it "accepts optional properties to support construction interface" do
-      constructed = subject.call(type = Object.new, {})
-      expect(constructed.object_id).to eql type.object_id
-    end
-
-    it "raises an ArgumentError if properties is specified and not empty" do
-      expect { subject.call(Object.new, {some: "properties"}) }.to raise_error(ArgumentError, /unexpected properties/)
-    end
-
-  end
-
-end

data/spec/fabrique/construction/builder_method_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "fabrique/test"
-
-describe Fabrique::Construction::BuilderMethod do
-
-  describe "call(type, properties = nil)" do
-
-    context "when initialized with a builder method name and builder runner block" do
-
-      subject do
-        described_class.new(:build) do |builder, properties|
-          builder.size = properties[:size]
-          builder.color = properties[:color]
-          builder.shape = properties[:shape]
-        end
-      end
-
-      it "calls the builder method on the type and yields the builder and the specified properties to the builder runner block" do
-        o = subject.call(Fabrique::Test::Fixtures::Constructors::ClassWithBuilderMethod, size: "huge", color: "black", shape: "hole")
-        expect(o.size).to eql "huge"
-        expect(o.color).to eql "black"
-        expect(o.shape).to eql "hole"
-      end
-
-    end
-
-  end
-
-end

data/spec/fabrique/construction/default_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Fabrique::Construction::Default do
-
-  describe "call(type, properties = nil)" do
-
-    it "calls type.new() without arguments" do
-      constructed = subject.call(type = Object)
-      expect(constructed.class).to eql type
-    end
-
-    it "accepts optional properties to support construction interface" do
-      constructed = subject.call(type = Object, {})
-      expect(constructed.class).to eql type
-    end
-
-  end
-
-end

data/spec/fabrique/construction/positional_argument_spec.rb

@@ -1,61 +0,0 @@
-require "spec_helper"
-
-class PositionalArgumentFixture
-  attr_reader :color, :shape, :size
-
-  DEFAULT_ATTRS = {color: "red", shape: "dot", size: "small"} unless defined?(DEFAULT_ATTRS)
-
-  def initialize(color = DEFAULT_ATTRS[:color], shape = DEFAULT_ATTRS[:shape], size = DEFAULT_ATTRS[:size])
-    @color, @shape, @size = color, shape, size
-  end
-
-  def attrs
-    {color: @color, shape: @shape, size: @size}
-  end
-
-end
-
-describe Fabrique::Construction::PositionalArgument do
-
-  let(:type) { PositionalArgumentFixture }
-
-  describe "call(type, properties = nil)" do
-
-    it "applies positional argument construction to the type, in the order they were provided to new()" do
-      subject = described_class.new(:color, :shape, :size)
-      constructed = subject.call(type, {size: "tiny", color: "purple", shape: "dot"})
-      expect(constructed.attrs).to eql({color: "purple", shape: "dot", size: "tiny"})
-    end
-
-    it "calls type.new() if no arguments were specified to new()" do
-      subject = described_class.new()
-      type = spy('type')
-      subject.call(type, {size: "tiny", color: "purple", shape: "dot"})
-      expect(type).to have_received(:new).with(no_args)
-    end
-
-    context "when one or more optional arguments were specified to new()" do
-
-      subject = described_class.new(:color, [:shape, :size])
-
-      it "passes optional arguments provided in properties" do
-        type = spy('type')
-        subject.call(type, {color: "purple", shape: "dot", size: "tiny"})
-        expect(type).to have_received(:new).with("purple", "dot", "tiny")
-      end
-
-      it "discards optional arguments if they are not present in the properties" do
-        type = spy('type')
-        subject.call(type, {size: "tiny", color: "purple"})
-        expect(type).to have_received(:new).with("purple", "tiny")
-      end
-
-      it "raises an ArgumentError if required arguments are not present in the properties" do
-        expect { subject.call(Object, shape: "dot", size: "tiny") }.to raise_error(ArgumentError, /required argument color missing/)
-      end
-
-    end
-
-  end
-
-end

data/spec/fabrique/construction/properties_hash_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-class PropertiesHashFixture
-  attr_reader :color, :shape, :size
-
-  DEFAULT_ATTRS = {color: "red", shape: "dot", size: "small"} unless defined?(DEFAULT_ATTRS)
-
-  def initialize(properties = DEFAULT_ATTRS)
-    @color, @shape, @size = properties[:color], properties[:shape], properties[:size]
-  end
-
-  def attrs
-    {color: @color, shape: @shape, size: @size}
-  end
-
-end
-
-describe Fabrique::Construction::PropertiesHash do
-
-  describe "call(type, properties = nil)" do
-
-    let(:type) { PropertiesHashFixture }
-
-    it "calls type.new() if properties is not provided" do
-      o = subject.call(type)
-      expect(o.attrs).to eql type::DEFAULT_ATTRS
-    end
-
-    it "calls type.new(properties) if properties is provided" do
-      o = subject.call(type, properties = {color: "green", shape: "patch", size: "large"})
-      expect(o.attrs).to eql properties
-    end
-
-  end
-
-end

data/spec/fabrique/constructor/identity_spec.rb

@@ -1,4 +0,0 @@
-require "spec_helper"
-
-describe Fabrique::Constructor::Identity do
-end

data/spec/fabrique/plugin_registry_spec.rb

@@ -1,78 +0,0 @@
-require "spec_helper"
-
-describe Fabrique::PluginRegistry do
-
-  subject { described_class.new("Test Plugin Factory") }
-  let(:constructor) { spy("constructor") }
-
-  describe "#register(id, type, constructor)" do
-
-    it "applies the strategy pattern to construction" do
-      subject.register(:my_plugin, type = Class.new, constructor)
-      subject.acquire(:my_plugin, {some: "properties"})
-      expect(constructor).to have_received(:call).with(type, {some: "properties"})
-    end
-
-    it "returns true on success (to avoid leaking registration internals)" do
-      expect(subject.register(:my_plugin, Class.new, constructor)).to be true
-    end
-
-    context "when the unique identity has already been registered" do
-
-      let(:existing_type) { Object.new }
-      before(:each) { subject.register(:existing, existing_type, constructor) }
-
-      it "raises an ArgumentError" do
-        expect {
-          subject.register(:existing, Object.new, double("constructor").as_null_object)
-        }.to raise_error(ArgumentError, /#{existing_type} already registered/)
-      end
-
-      it "leaves the original registration intact" do
-        begin
-          subject.register(:existing, Object.new, double("constructor").as_null_object)
-        rescue
-        end
-        subject.acquire(:existing)
-        expect(constructor).to have_received(:call).with(existing_type)
-      end
-
-    end
-
-  end
-
-  describe "#acquire(id, properties = {})" do
-
-    let(:type) { Object }
-    before(:each) { subject.register(:my_plugin, type, constructor) }
-
-    it "applies the registered constructor to the registered type with the given properties" do
-      subject.acquire(:my_plugin, properties = {some: "properties"})
-      expect(constructor).to have_received(:call).with(type, properties)
-    end
-
-    it "applies the registered constructor to the registered type only if no properties are given" do
-      subject.acquire(:my_plugin)
-      expect(constructor).to have_received(:call).with(type)
-    end
-
-    it "returns the constructor call's return value" do
-      allow(constructor).to receive(:call).and_return(plugin = type.new)
-      expect(subject.acquire(:my_plugin)).to be plugin
-    end
-
-    context "when the unique identity has not yet been registered" do
-
-      before(:each) { subject.send(:unregister, :my_plugin) }
-
-      it "raises an ArgumentError" do
-        expect {
-          subject.acquire(:my_plugin)
-        }.to raise_error(ArgumentError, /not registered/)
-      end
-
-    end
-
-  end
-
-end