fabrique 0.0.0 → 0.0.1

data/lib/fabrique/test/fixtures/repository.rb

@@ -0,0 +1,139 @@
+module Fabrique
+
+  module Test
+
+    module Fixtures
+
+      module Repository
+
+        class Customer
+
+          attr_reader :id, :name, :date_of_birth
+
+          def initialize(id: nil, name: nil, date_of_birth: nil)
+            @id, @name, @date_of_birth = id, name, date_of_birth
+          end
+
+        end
+
+        class CustomerRepository
+
+          # Exposed for testing
+          attr_reader :store, :data_mapper
+
+          def initialize(store, data_mapper)
+            @store, @data_mapper = store, data_mapper
+          end
+
+          def persist(entity)
+            id = @store.save(:customer, @data_mapper.to_dto(entity))
+            if !id.nil?
+              entity.id = id
+            end
+          end
+
+          def locate(entity_id)
+            @data_mapper.from_dto(@store.find(:customer, entity_id))
+          end
+
+        end
+
+        class ProductRepository
+
+          # Exposed for testing
+          attr_reader :store, :data_mapper
+
+          def initialize(store: nil, data_mapper: nil)
+            @store, @data_mapper = store, data_mapper
+          end
+
+          def persist(entity)
+            id = @store.save(:customer, @data_mapper.to_dto(entity))
+            if !id.nil?
+              entity.id = id
+            end
+          end
+
+          def search(filter)
+            @data_mapper.from_dto(@store.search(:customer, filter))
+          end
+
+        end
+
+        class MysqlConnection
+
+          def initialize(*args)
+            # ...
+          end
+
+          def method_missing(method_sym, *arguments)
+            42
+          end
+
+        end
+
+        class MysqlStore
+
+          def initialize(host: 'localhost', port: 3306, username: nil, password: nil)
+            @connection = MysqlConnection.new(host, port, username, password)
+          end
+
+          def find(table, id)
+            @connection.find(table, "WHERE customer_id = ?", [id])
+          end
+
+          def search(table, filter)
+            clauses, bindings = [], []
+            filter.each do |k, v|
+              clauses << k
+              bindings << v
+            end
+            @connection.select(table, clauses.join(" AND "), bindings)
+          end
+
+          def save(table, record)
+            @connection.update_or_insert(table, record)
+          end
+
+        end
+
+        require "date"
+        class CustomerDataMapper
+
+          def to_dto(entity)
+            {
+              id: entity.id,
+              name: entity.name,
+              dob: entity.date_of_birth.iso8601
+            }
+          end
+
+          def from_dto(dto)
+            Customer.new(id: dto[:id], name: dto[:name], date_of_birth: Date.parse(dto[:dob]))
+          end
+
+        end
+
+        class ProductDataMapper
+
+          def to_dto(entity)
+            {
+              id: entity.id,
+              name: entity.name,
+              price: entity.price,
+            }
+          end
+
+          def from_dto(dto)
+            Product.new(id: dto[:id], name: dto[:name], price: dto[:price])
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/test.rb

@@ -0,0 +1,8 @@
+Dir[File.join(File.dirname(__FILE__), "test", "**", "*.rb")].each { |f| require_relative f }
+
+module Fabrique
+
+  module Test
+  end
+
+end

data/lib/fabrique/version.rb

@@ -1,3 +1,3 @@
 module Fabrique
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/lib/fabrique/yaml_bean_factory.rb

@@ -0,0 +1,42 @@
+require "yaml"
+require_relative "bean_definition_registry"
+require_relative "bean_definition"
+require_relative "bean_factory"
+require_relative "bean_reference"
+
+module Fabrique
+
+  YAML.add_domain_type("starjuice.net,2015-03-13", "beans") do |type, value|
+    BeanDefinitionRegistry.new(value)
+  end
+
+  YAML.add_domain_type("starjuice.net,2015-03-13", "bean") do |type, value|
+    BeanDefinition.new(value)
+  end
+
+  YAML.add_domain_type("starjuice.net,2015-03-13", "bean/ref") do |type, value|
+    BeanReference.new(value)
+  end
+
+  class YamlBeanFactory < BeanFactory
+
+    def initialize(pathname)
+      data = YAML.load_file(pathname)
+      if data.respond_to?(:keys) and data["beans"]
+        beans = data["beans"]
+      else
+        raise "YAML contains no top-level beans node"
+      end
+
+      if beans.is_a?(BeanDefinitionRegistry)
+        super(beans)
+      elsif beans.is_a?(Array)
+        super(BeanDefinitionRegistry.new(beans))
+      else
+        raise "YAML top-level beans node must be an Array or a #{BeanDefinitionRegistry}"
+      end
+    end
+
+  end
+
+end

data/lib/fabrique.rb

@@ -1,5 +1,7 @@
-require "fabrique/version"
+Dir[File.join(File.dirname(__FILE__), "fabrique", "*.rb")].each { |f| require_relative f }
+Dir[File.join(File.dirname(__FILE__), "fabrique", "construction", "*.rb")].each { |f| require_relative f }
+Dir[File.join(File.dirname(__FILE__), "fabrique", "constructor", "*.rb")].each { |f| require_relative f }
+Dir[File.join(File.dirname(__FILE__), "fabrique", "argument_adaptor", "*.rb")].each { |f| require_relative f }
 
 module Fabrique
-  # Your code goes here...
 end

data/spec/fabrique/argument_adaptor/keyword_spec.rb

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,36 @@
+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

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

data/spec/fabrique/plugin_registry_spec.rb

@@ -0,0 +1,78 @@
+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