fabrique 0.0.0 → 0.0.1

data/features/bean_factory.feature

@@ -0,0 +1,295 @@
+@bean_factory
+Feature: Bean Factory
+
+  As a developer
+  I want injectable dependencies to be a configuration concern
+  So that I can configure different dependencies in different environments.
+
+  Scenario: Simple object with default constructor
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans: !beans
+      - !bean
+        id: simple_object
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithDefaultConstructor
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then the bean has "size" set to "default size"
+    And the bean has "color" set to "default color"
+    And the bean has "shape" set to "default shape"
+
+  Scenario: Simple object with positional argument constructor
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithPositionalArgumentConstructor
+        constructor_args:
+            - small
+            - red
+            - dot
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then the bean has "size" set to "small"
+    And the bean has "color" set to "red"
+    And the bean has "shape" set to "dot"
+
+  Scenario: Simple object with keyword argument constructor
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithKeywordArgumentConstructor
+        constructor_args:
+          size: large
+          color: black
+          shape: hole
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then the bean has "size" set to "large"
+    And the bean has "color" set to "black"
+    And the bean has "shape" set to "hole"
+
+
+  Scenario: Simple object with hash properties constructor
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithPropertiesHashConstructor
+        constructor_args:
+          size: tiny
+          color: purple
+          shape: elephant
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then the bean has "size" set to "tiny"
+    And the bean has "color" set to "purple"
+    And the bean has "shape" set to "elephant"
+
+  Scenario: Module by identity
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: my_module
+        class: Fabrique::Test::Fixtures::Modules::ModuleWithStaticMethods
+        factory_method: itself
+      """
+    When I request a bean factory for the application context
+    And I request the "my_module" bean from the bean factory
+    Then the bean has "size" set to "module size"
+    And the bean has "color" set to "module color"
+    And the bean has "shape" set to "module shape"
+
+  Scenario: Bean reference
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: customer_repository
+        class: Fabrique::Test::Fixtures::Repository::CustomerRepository
+        constructor_args:
+          - !bean/ref store
+          - !bean/ref customer_data_mapper
+      - id: product_repository
+        class: Fabrique::Test::Fixtures::Repository::ProductRepository
+        constructor_args:
+          store: !bean/ref store
+          data_mapper: !bean/ref product_data_mapper
+      - id: store
+        class: Fabrique::Test::Fixtures::Repository::MysqlStore
+        constructor_args:
+          host: localhost
+          port: 3306
+      - id: customer_data_mapper
+        class: Fabrique::Test::Fixtures::Repository::CustomerDataMapper
+        scope: prototype
+      - id: product_data_mapper
+        class: Fabrique::Test::Fixtures::Repository::ProductDataMapper
+        scope: prototype
+      """
+    When I request a bean factory for the application context
+    Then the "customer_repository" and "product_repository" beans share the same "store"
+    And the "customer_repository" and "product_repository" beans each have their own "data_mapper"
+
+  Scenario: Cyclic bean property reference
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: left
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithProperties
+        properties:
+          shape: !bean/ref right
+      - id: right
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithProperties
+        properties:
+          shape: !bean/ref left
+      """
+    Then I get a cyclic bean dependency error when I request a bean factory for the application context
+
+  Scenario: Cyclic bean constructor arg reference
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: left
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithPositionalArgumentConstructor
+        constructor_args:
+          - !bean/ref right
+          - red
+          - dot
+      - id: right
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithPositionalArgumentConstructor
+        constructor_args:
+          - !bean/ref left
+          - purple
+          - elephant
+      """
+    Then I get a cyclic bean dependency error when I request a bean factory for the application context
+
+  Scenario: Cyclic bean property reference with non-cyclic constructor arg reference
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: left
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithKeywordArgumentConstructor
+        constructor_args:
+          shape: !bean/ref middle
+      - id: middle
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithKeywordArgumentConstructor
+        constructor_args:
+          shape: !bean/ref right
+      - id: right
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithProperties
+        properties:
+          shape: !bean/ref left
+      """
+    Then I get a cyclic bean dependency error when I request a bean factory for the application context
+
+  Scenario: Nested bean references
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: disco_cube
+        class: Fabrique::Test::Fixtures::OpenGL::Object
+        constructor_args:
+          - glittering
+          - :mesh: !bean/ref cube_mesh
+            :scale: 10
+      - id: cube_mesh
+        class: Fabrique::Test::Fixtures::OpenGL::Mesh
+        constructor_args:
+          - [[0, 0, 0],[1, 0, 0],[1, 0, 1],[0, 0, 1],[0, 1, 0],[1, 1, 0],[1, 1, 1],[0, 1, 1]]
+      """
+    When I request a bean factory for the application context
+    And I request the "disco_cube" bean from the bean factory
+    Then the "disco_cube" bean has "mesh" set to the "cube_mesh" bean
+    And the "disco_cube" bean has "scale" that is the Integer 10
+
+  Scenario: Singleton bean (default)
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        scope: singleton
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithDefaultConstructor
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then I get the same object when I request the "simple_object" bean again
+
+  Scenario: Prototype bean
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        scope: prototype
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithDefaultConstructor
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then I get a different object when I request the "simple_object" bean again
+
+  Scenario: Setter injection
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithProperties
+        properties:
+          size: large
+          color: blue
+          shape: square
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then the bean has "size" set to "large"
+    And the bean has "color" set to "blue"
+    And the bean has "shape" set to "square"
+
+  Scenario: Constructor argument type
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithPositionalArgumentConstructor
+        constructor_args:
+          - infinite
+          - invisible
+          - 42
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then the bean has "size" set to "infinite"
+    And the bean has "color" set to "invisible"
+    And the bean has "shape" that is the Integer "42"
+
+  Scenario: Property argument type
+
+    Given I have a YAML application context definition:
+      """
+      ---
+      beans:
+      - id: simple_object
+        class: Fabrique::Test::Fixtures::Constructors::ClassWithProperties
+        properties:
+          size: infinite
+          color: invisible
+          shape: 42
+      """
+    When I request a bean factory for the application context
+    And I request the "simple_object" bean from the bean factory
+    Then the bean has "size" set to "infinite"
+    And the bean has "color" set to "invisible"
+    And the bean has "shape" that is the Integer "42"
+

data/features/plugin_registry.feature

@@ -0,0 +1,79 @@
+@plugin_registry
+Feature: Plugin registry
+
+  As a developer
+  I want to register the identity and construction method of different plugins
+  So that I can decouple their dependants from their means of creation
+
+  Plugins are classes, modules, objects or lambdas that may come from other developers, and so
+  may have disparate construction methods. A plugin registry allows these differences to be
+  abstracted, and for them to be created by a known and invariant identity. The identities of
+  plugins must be defined by the developer of the dependant.
+
+  This does not address the concern of ensuring that multiple plugins offer the same interface.
+  That concern is dealt with by a contract conformance strategy (e.g. interface through
+  delegation).
+
+  Most developers will not use a plugin registry directly. Instead, they will use a factory
+  that implements a conformance strategy. This has the additional benefit of allowing the
+  developers of plugins to define and register the identities of their plugins.
+
+  Scenario: Multiple plugins
+
+    Given I have a plugin registry
+    And I have two classes with default constructors
+    When I register each class into the registry with a unique identity and a default construction method
+    Then I can acquire instances of each class from the registry by its unique identity
+
+  Scenario Outline: As-is plugin
+
+    Given I have a plugin registry
+    And I have <article> <entity>, i.e. <code>
+    When I register the <entity> into the registry with a unique identity and an as-is construction method
+    Then I get the same <entity> every time I acquire the same identity
+
+    Examples:
+      | article | entity | code       |
+      | an      | object | Object.new |
+      | a       | class  | Class      |
+      | a       | module | Module     |
+      | a       | lambda | -> {}      |
+
+  Scenario: Classical plugin with default constructor
+
+    Given I have a plugin registry
+    And I have a class with a default constructor
+    When I register the class into the registry with a unique identity and a default construction method
+    Then I can acquire instances of the class from the registry by its unique identity
+
+  Scenario: Classical plugin with properties hash constructor
+
+    Given I have a plugin registry
+    And I have a class with a properties hash constructor
+    When I register the class into the registry with a unique identity and a properties hash construction method
+    Then I can acquire an instance of the class from the registry by its unique identity, specifying properties with a hash argument
+
+  Scenario: Classical plugin with positional argument constructor
+
+    Given I have a plugin registry
+    And I have a class with a positional argument constructor
+    When I register the class into the registry with a unique identity and a positional argument construction method
+    Then I can acquire an instance of the class from the registry by its unique identity, specifying properties with a hash argument
+    And the instance has the specified properties
+
+  Scenario: Classical plugin with keyword argument constructor
+
+    Given I have a plugin registry
+    And I have a class with a keyword argument constructor
+    When I register the class into the registry with a unique identity and a keyword argument construction method
+    Then I can acquire an instance of the class from the registry by its unique identity, specifying properties with a hash argument
+    And the instance has the specified properties
+
+  Scenario: Builder pattern plugin
+
+    Given I have a plugin registry
+    And I have a class with a builder method
+    When I register the class into the registry with a unique identity and builder construction method
+    Then I can acquire an instance of the class from the registry by its unique identity, specifying properties with a hash argument
+    And the instance has the specified properties
+

data/features/step_definitions/bean_factory_steps.rb

@@ -0,0 +1,73 @@
+require "yaml"
+
+After do
+  if defined?(@tmpfile) and File.exists?(@tmpfile)
+    File.unlink(@tmpfile)
+  end
+end
+
+Given(/^I have a YAML application context definition:$/) do |string|
+  Tempfile.open('fabrique') do |f|
+    @tmpfile = f.path
+    f.write(string)
+  end
+end
+
+When(/^I request a bean factory for the application context$/) do
+  @bean_factory = Fabrique::YamlBeanFactory.new(@tmpfile)
+end
+
+When(/^I request the "(.*?)" bean from the bean factory$/) do |bean_name|
+  @bean = @bean_factory.get_bean(bean_name)
+end
+
+Then(/^the bean has "(.*?)" set to "(.*?)"$/) do |attr, value|
+  expect(@bean.send(attr)).to eql value
+end
+
+Then(/^the bean has "(.*?)" that is the Integer "(.*?)"$/) do |attr, int_value|
+  expect(@bean.send(attr)).to eql int_value.to_i
+end
+
+Then(/^the "(.*?)" bean has "(.*?)" that is the Integer (\d+)$/) do |bean_name, attr, int_value|
+  bean = @bean_factory.get_bean(bean_name)
+  expect(bean.send(attr)).to eql int_value.to_i
+end
+
+Then(/^the "(.*?)" bean has "(.*?)" set to the "(.*?)" bean$/) do |parent, attr, child|
+  parent = @bean_factory.get_bean(parent)
+  child = @bean_factory.get_bean(child)
+  expect(parent.send(attr)).to eql child
+end
+
+Then(/^the "(.*?)" bean has "(.*?)" set to "(.*?)"$/) do |bean_name, attr, value|
+  bean = @bean_factory.get_bean(bean_name)
+  expect(bean.send(attr)).to eql(value)
+end
+
+Then(/^I get the same object when I request the "(.*?)" bean again$/) do |bean_name|
+  new_reference = @bean_factory.get_bean(bean_name)
+  expect(new_reference.object_id).to eql @bean.object_id
+end
+
+Then(/^I get a different object when I request the "(.*?)" bean again$/) do |bean_name|
+  new_reference = @bean_factory.get_bean(bean_name)
+  expect(new_reference.object_id).to_not eql @bean.object_id
+end
+
+Then(/^I get a cyclic bean dependency error when I request a bean factory for the application context$/) do
+  expect { Fabrique::YamlBeanFactory.new(@tmpfile) }.to raise_error(Fabrique::CyclicBeanDependencyError, /cyclic bean dependency error/)
+end
+
+Then(/^the "(.*?)" and "(.*?)" beans share the same "(.*?)"$/) do |bean1_name, bean2_name, shared_property|
+  bean1 = @bean_factory.get_bean(bean1_name)
+  bean2 = @bean_factory.get_bean(bean2_name)
+  expect(bean1.send(shared_property).object_id).to eql bean2.send(shared_property).object_id
+end
+
+Then(/^the "(.*?)" and "(.*?)" beans each have their own "(.*?)"$/) do |bean1_name, bean2_name, own_property|
+  bean1 = @bean_factory.get_bean(bean1_name)
+  bean2 = @bean_factory.get_bean(bean2_name)
+  expect(bean1.send(own_property).object_id).to_not eql bean2.send(own_property).object_id
+end
+

data/features/step_definitions/plugin_registry_steps.rb

@@ -0,0 +1,207 @@
+require "rspec"
+require "fabrique/test"
+
+class PluginRegistryTestRunner
+  include RSpec::Matchers
+  include Fabrique::Test::Fixtures::Constructors
+
+  def initialize(subject_constructor)
+    @subject_constructor = subject_constructor
+  end
+
+  def have_plugin_registry
+    @registry = @subject_constructor.call
+  end
+
+  def have_class_with_default_constructor
+    @class = ClassWithDefaultConstructor
+  end
+
+  def have_two_classes_with_default_constructors
+    @class1 = ClassWithDefaultConstructor
+    @class2 = OtherClassWithDefaultConstructor
+  end
+
+  def have_object(object)
+    @object = object
+  end
+
+  def have_class_with_positional_argument_constructor
+    @class = ClassWithPositionalArgumentConstructor
+  end
+
+  def have_class_with_properties_hash_constructor
+    @class = ClassWithPropertiesHashConstructor
+  end
+
+  def have_class_with_keyword_argument_constructor
+    @class = ClassWithKeywordArgumentConstructor
+  end
+
+  def have_class_with_builder_method
+    @class = ClassWithBuilderMethod
+  end
+
+  def register_class_with_as_is_constructor
+    @identity = :my_plugin
+    @registry.register(@identity, @class, Fabrique::Construction::Default.new)
+  end
+
+  def register_classes_with_default_constructors
+    @identity1 = :plugin1
+    @identity2 = :plugin2
+    @registry.register(@identity1, @class1, Fabrique::Construction::Default.new)
+    @registry.register(@identity2, @class2, Fabrique::Construction::Default.new)
+  end
+
+  def register_object_with_as_is_constructor
+    @identity = :my_plugin
+    @registry.register(@identity, @object, Fabrique::Construction::AsIs.new)
+  end
+
+  def register_class_with_properties_hash_constructor
+    @identity = :my_plugin
+    @registry.register(@identity, @class, Fabrique::Construction::PropertiesHash.new)
+  end
+
+  def register_class_with_positional_argument_constructor
+    @identity = :my_plugin
+    @registry.register(@identity, @class, Fabrique::Construction::PositionalArgument.new(:size, :color, :shape))
+  end
+
+  def register_class_with_keyword_argument_constructor
+    @identity = :my_plugin
+    @registry.register(@identity, @class, Fabrique::Construction::KeywordArgument.new)
+  end
+
+  def register_class_with_builder_method
+    @identity = :my_plugin
+    @registry.register(@identity, @class, Fabrique::Construction::BuilderMethod.new(:build) { |builder, properties|
+      builder.size = properties[:size]
+      builder.color = properties[:color]
+      builder.shape = properties[:shape]
+    })
+  end
+
+  def can_acquire_instances_of_class
+    instance1 = @registry.acquire(@identity)
+    instance2 = @registry.acquire(@identity)
+    expect(instance1.class).to eql @class
+    expect(instance2.class).to eql @class
+    expect(instance1.object_id).to_not eql instance2.object_id
+  end
+
+  def can_acquire_instances_of_classes
+    instance1 = @registry.acquire(@identity1)
+    instance2 = @registry.acquire(@identity2)
+    expect(instance1.class).to eql @class1
+    expect(instance2.class).to eql @class2
+  end
+
+  def can_acquire_same_object_id_every_time
+    instance1 = @registry.acquire(@identity)
+    instance2 = @registry.acquire(@identity)
+    expect(instance1.object_id).to eql @object.object_id
+    expect(instance2.object_id).to eql @object.object_id
+  end
+
+  def can_acquire_instance_of_class_with_properties
+    @instance = @registry.acquire(@identity, size: "large", color: "pink", shape: "cube")
+  end
+
+  def can_verify_instance_properties
+    expect(@instance.color).to eql "pink"
+    expect(@instance.shape).to eql "cube"
+    expect(@instance.size).to eql "large"
+  end
+
+end
+
+require "fabrique"
+
+Before do |scenario|
+  if scenario.source_tags.any? { |tag| tag.name == "@plugin_registry" }
+    @test = PluginRegistryTestRunner.new( -> {Fabrique::PluginRegistry.new("Test plugin registry")})
+  end
+end
+
+Given(/^I have a plugin registry$/) do
+  @test.have_plugin_registry
+end
+
+Given(/^I have a class with a default constructor$/) do
+  @test.have_class_with_default_constructor
+end
+
+Given(/^I have two classes with default constructors$/) do
+  @test.have_two_classes_with_default_constructors
+end
+
+Given(/^I have an? \w+, i\.e\. (.+)$/) do |code|
+  @test.have_object(eval code)
+end
+
+Given(/^I have a class with a positional argument constructor$/) do
+  @test.have_class_with_positional_argument_constructor
+end
+
+Given(/^I have a class with a properties hash constructor$/) do
+  @test.have_class_with_properties_hash_constructor
+end
+
+Given(/^I have a class with a keyword argument constructor$/) do
+  @test.have_class_with_keyword_argument_constructor
+end
+
+Given(/^I have a class with a builder method$/) do
+  @test.have_class_with_builder_method
+end
+
+When(/^I register the class into the registry with a unique identity and a default construction method$/) do
+  @test.register_class_with_as_is_constructor
+end
+
+When(/^I register each class into the registry with a unique identity and a default construction method$/) do
+  @test.register_classes_with_default_constructors
+end
+
+When(/^I register the \w+ into the registry with a unique identity and an as\-is construction method$/) do
+  @test.register_object_with_as_is_constructor
+end
+
+When(/^I register the class into the registry with a unique identity and a properties hash construction method$/) do
+  @test.register_class_with_properties_hash_constructor
+end
+
+When(/^I register the class into the registry with a unique identity and a positional argument construction method$/) do
+  @test.register_class_with_positional_argument_constructor
+end
+
+When(/^I register the class into the registry with a unique identity and a keyword argument construction method$/) do
+  @test.register_class_with_keyword_argument_constructor
+end
+
+When(/^I register the class into the registry with a unique identity and builder construction method$/) do
+  @test.register_class_with_builder_method
+end
+
+Then(/^I can acquire instances of the class from the registry by its unique identity$/) do
+  @test.can_acquire_instances_of_class
+end
+
+Then(/^I can acquire instances of each class from the registry by its unique identity$/) do
+  @test.can_acquire_instances_of_classes
+end
+
+Then(/^I get the same \w+ every time I acquire the same identity$/) do
+  @test.can_acquire_same_object_id_every_time
+end
+
+Then(/^I can acquire an instance of the class from the registry by its unique identity, specifying properties with a hash argument$/) do
+  @test.can_acquire_instance_of_class_with_properties
+end
+
+Then(/^the instance has the specified properties$/) do
+  @test.can_verify_instance_properties
+end
+

data/features/support/byebug.rb

@@ -0,0 +1,4 @@
+begin
+  require "byebug"
+rescue LoadError
+end

data/lib/fabrique/argument_adaptor/keyword.rb

@@ -0,0 +1,19 @@
+module Fabrique
+
+  module ArgumentAdaptor
+
+    class Keyword
+
+      def adapt(properties = nil)
+        if properties.nil?
+          []
+        else
+          [properties]
+        end
+      end
+
+    end
+
+  end
+
+end