wirer 0.4.7 → 0.5.0

data/lib/wirer/construction_session.rb

@@ -0,0 +1,123 @@
+require 'thread'
+module Wirer
+  class ConstructionSession
+    attr_reader :container
+
+    def initialize(container)
+      @construction_mutex = Mutex.new
+      @container = container
+    end
+
+    # N.B. all calls to the private construct_ methods below must be wrapped with
+    # this at the top-level entry point.
+    # It wraps with a mutex, to avoid race conditions with concurrent
+    # attempts to construct a singleton factory, and also ensures that everything
+    # constructed in this session gets post_initialized at the end.
+    def construction_session
+      @construction_mutex.synchronize do
+        begin
+          @phase_1_in_progress = []
+          @queued_for_phase_2 = []
+          @queued_for_post_initialize = []
+
+          result = yield
+
+          until @queued_for_phase_2.empty?
+            factory_instance = @queued_for_phase_2.pop
+            construct_and_inject_setter_dependencies(*factory_instance)
+            @queued_for_post_initialize.push(factory_instance)
+          end
+
+          result
+        ensure
+          post_initialize(@queued_for_post_initialize)
+          remove_instance_variable(:@phase_1_in_progress)
+          remove_instance_variable(:@queued_for_post_initialize)
+        end
+      end
+    end
+
+    def construct_dependencies(dependencies)
+      result = {}
+      dependencies.each do |arg_name, dependency|
+        result[arg_name] = construct_dependency(dependency)
+      end
+      result
+    end
+
+    def construct_dependency(dependency)
+      dependency.match_factories(@container.factories) do |factory|
+        if dependency.factory?
+          if @container.singleton_factories_instances.has_key?(factory)
+            raise Error, "Problem with :factory => true dependency: #{factory} was added to the container as a singleton, so only a singleton instance can be supplied, not a wrapped factory"
+          end
+          curry_factory_with_constructed_dependencies(factory)
+        else
+          construct_factory_without_args(factory)
+        end
+      end
+    end
+
+    def construct_factory(factory, *args, &block_arg)
+      if args.empty? && !block_arg
+        construct_factory_without_args(factory)
+      else
+        construct_factory_with_args(factory, *args, &block_arg)
+      end
+    end
+
+    def construct_factory_without_args(factory)
+      instance = @container.singleton_factories_instances[factory] and return instance
+
+      if @phase_1_in_progress.include?(factory)
+        cycle = @phase_1_in_progress[@phase_1_in_progress.index(factory)..-1] + [factory]
+        raise CyclicDependencyError, "Cyclic constructor dependencies. Break the cycle by changing some into setter dependencies:\n#{cycle.map(&:inspect).join("\n")}"
+      end
+      @phase_1_in_progress.push(factory)
+      result = construct_with_constructor_dependencies(factory)
+      @phase_1_in_progress.pop
+
+      if @container.singleton_factories_instances.has_key?(factory)
+        @container.singleton_factories_instances[factory] = result
+      end
+
+      @queued_for_phase_2.push([factory, result])
+      result
+    end
+
+    def construct_factory_with_args(factory, *args, &block_arg)
+      result = construct_with_constructor_dependencies(factory, *args, &block_arg)
+      @queued_for_phase_2.push([factory, result])
+      result
+    end
+
+    def construct_with_constructor_dependencies(factory, *args, &block_arg)
+      deps = construct_dependencies(factory.constructor_dependencies)
+      begin
+        factory.new_from_dependencies(deps, *args, &block_arg)
+      rescue Wirer::Error
+        raise
+      rescue => e
+        wrapped = DependencyConstructionError.new("Unable to construct factory: #{factory.inspect}", e)
+        raise wrapped
+      end
+    end
+
+    def curry_factory_with_constructed_dependencies(factory)
+      deps = construct_dependencies(factory.constructor_dependencies)
+      factory.curry_with_dependencies(deps, self)
+    end
+
+    def construct_and_inject_setter_dependencies(factory, instance)
+      setter_deps = construct_dependencies(factory.setter_dependencies(instance))
+      setter_deps.each do |dep_name, dep|
+        factory.inject_dependency(instance, dep_name, dep)
+      end
+    end
+
+    def post_initialize(factories_instances)
+      factories_instances.each {|factory, instance| factory.post_initialize(instance)}
+    end
+
+  end
+end

data/lib/wirer/container.rb

@@ -11,12 +11,14 @@ module Wirer
   # Alternatively if don't want this, specify :singleton => false when adding it.
   class Container
     attr_reader :factories
+    attr_reader :factories_by_method_name
+    attr_reader :singleton_factories_instances
 
     def initialize
       @singleton_factories_instances = {}
       @factories = []
       @factories_by_method_name = {}
-      @construction_mutex = Mutex.new
+      @construction_session = ConstructionSession.new(self)
       yield self if block_given?
     end
 
@@ -131,17 +133,18 @@ module Wirer
     def construct_factory_by_method_name(method_name, *args, &block_arg)
       factory = @factories_by_method_name[method_name]
       begin
-        construction_session do
-          construct_factory(factory, *args, &block_arg)
+        @construction_session.construction_session do
+          @construction_session.construct_factory(factory, *args, &block_arg)
         end
-      rescue
+      rescue => exception
+        exception.backtrace
         raise DependencyConstructionError.new("Unable to construct factory with name #{method_name}", $!)
       end
     end
 
     def [](*dep_args)
-      construction_session do
-        construct_dependency(Dependency.new_from_args(*dep_args))
+      @construction_session.construction_session do
+        @construction_session.construct_dependency(Dependency.new_from_args(*dep_args))
       end
     end
 
@@ -167,117 +170,5 @@ module Wirer
       end
     end
 
-  private
-
-    # N.B. all calls to the private construct_ methods below must be wrapped with
-    # this at the top-level entry point.
-    # It wraps with a mutex, to avoid race conditions with concurrent
-    # attempts to construct a singleton factory, and also ensures that everything
-    # constructed in this session gets post_initialized at the end.
-    def construction_session
-      @construction_mutex.synchronize do
-        begin
-          @phase_1_in_progress = []
-          @queued_for_phase_2 = []
-          @queued_for_post_initialize = []
-
-          result = yield
-
-          until @queued_for_phase_2.empty?
-            factory_instance = @queued_for_phase_2.pop
-            construct_and_inject_setter_dependencies(*factory_instance)
-            @queued_for_post_initialize.push(factory_instance)
-          end
-
-          result
-        ensure
-          post_initialize(@queued_for_post_initialize)
-          remove_instance_variable(:@phase_1_in_progress)
-          remove_instance_variable(:@queued_for_post_initialize)
-        end
-      end
-    end
-
-    def construct_dependencies(dependencies)
-      result = {}
-      dependencies.each do |arg_name, dependency|
-        result[arg_name] = construct_dependency(dependency)
-      end
-      result
-    end
-
-    def construct_dependency(dependency)
-      dependency.match_factories(@factories) do |factory|
-        if dependency.factory?
-          if @singleton_factories_instances.has_key?(factory)
-            raise Error, "Problem with :factory => true dependency: #{factory} was added to the container as a singleton, so only a singleton instance can be supplied, not a wrapped factory"
-          end
-          curry_factory_with_constructed_dependencies(factory)
-        else
-          construct_factory_without_args(factory)
-        end
-      end
-    end
-
-    def construct_factory(factory, *args, &block_arg)
-      if args.empty? && !block_arg
-        construct_factory_without_args(factory)
-      else
-        construct_factory_with_args(factory, *args, &block_arg)
-      end
-    end
-
-    def construct_factory_without_args(factory)
-      instance = @singleton_factories_instances[factory] and return instance
-
-      if @phase_1_in_progress.include?(factory)
-        cycle = @phase_1_in_progress[@phase_1_in_progress.index(factory)..-1] + [factory]
-        raise CyclicDependencyError, "Cyclic constructor dependencies. Break the cycle by changing some into setter dependencies:\n#{cycle.map(&:inspect).join("\n")}"
-      end
-      @phase_1_in_progress.push(factory)
-      result = construct_with_constructor_dependencies(factory)
-      @phase_1_in_progress.pop
-
-      if @singleton_factories_instances.has_key?(factory)
-        @singleton_factories_instances[factory] = result
-      end
-
-      @queued_for_phase_2.push([factory, result])
-      result
-    end
-
-    def construct_factory_with_args(factory, *args, &block_arg)
-      result = construct_with_constructor_dependencies(factory, *args, &block_arg)
-      @queued_for_phase_2.push([factory, result])
-      result
-    end
-
-    def construct_with_constructor_dependencies(factory, *args, &block_arg)
-      deps = construct_dependencies(factory.constructor_dependencies)
-      begin
-        factory.new_from_dependencies(deps, *args, &block_arg)
-      rescue Wirer::Error
-        raise
-      rescue => e
-        wrapped = DependencyConstructionError.new("Unable to construct factory: #{factory.inspect}", e)
-        raise wrapped
-      end
-    end
-
-    def curry_factory_with_constructed_dependencies(factory)
-      deps = construct_dependencies(factory.constructor_dependencies)
-      factory.curry_with_dependencies(deps)
-    end
-
-    def construct_and_inject_setter_dependencies(factory, instance)
-      setter_deps = construct_dependencies(factory.setter_dependencies(instance))
-      setter_deps.each do |dep_name, dep|
-        factory.inject_dependency(instance, dep_name, dep)
-      end
-    end
-
-    def post_initialize(factories_instances)
-      factories_instances.each {|factory, instance| factory.post_initialize(instance)}
-    end
   end
 end

data/lib/wirer/factory/curried_dependencies.rb

@@ -12,15 +12,20 @@ module Wirer
   # the container will then give you a curried factory from which you can construct
   # your own instances, rather than supplying a single pre-constructed instance.
   #
-  # Note: at present only constructor dependencies can be curried in this way.
+  # Setter dependencies are curried in a very unoptimised way.
   class Factory::CurriedDependencies
-    def initialize(factory, dependencies)
+    def initialize(construction_session, factory, dependencies)
       @factory = factory
       @dependencies = dependencies
+      @construction_session = construction_session
     end
 
     def new(*args, &block_arg)
-      @factory.new_from_dependencies(@dependencies, *args, &block_arg)
+      setter_dependencies = @factory.setter_dependencies(nil).dup || {}
+
+      @construction_session.construction_session do
+        @construction_session.construct_factory(@factory, *args, &block_arg)
+      end
     end
 
     alias :call :new

data/lib/wirer/factory/interface.rb

@@ -94,8 +94,8 @@ module Wirer
     # Supplies a wrapper around the factory with a set of pre-supplied dependencies.
     # The wrapper can then be used to construct instances.
     # See Factory::CurriedDependencies
-    def curry_with_dependencies(dependencies)
-      Factory::CurriedDependencies.new(self, dependencies)
+    def curry_with_dependencies(dependencies, construction_session)
+      Factory::CurriedDependencies.new(construction_session, self, dependencies)
     end
 
     def inject_dependency(instance, attr_name, dependency)

data/lib/wirer/version.rb

@@ -1,3 +1,3 @@
 module Wirer
-  VERSION = '0.4.7'
+  VERSION = '0.5.0'
 end

data/lib/wirer.rb

@@ -9,6 +9,7 @@ require 'wirer/factory/class_mixins'
 require 'wirer/factory/curried_dependencies'
 require 'wirer/service'
 require 'wirer/dependency'
+require 'wirer/construction_session'
 require 'wirer/container'
 require 'wirer/errors'
 

metadata

@@ -1,21 +1,22 @@
 --- !ruby/object:Gem::Specification 
 name: wirer
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
-  - 7
-  version: 0.4.7
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Matthew Willson
+- Tom Chipchase
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-11-12 00:00:00 Z
+date: 2012-07-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -82,6 +83,7 @@ dependencies:
 description: 
 email: 
 - matthew@playlouder.com
+- tom.chipchase@gmail.com
 executables: []
 
 extensions: []
@@ -90,17 +92,18 @@ extra_rdoc_files: []
 
 files: 
 - lib/wirer.rb
+- lib/wirer/construction_session.rb
 - lib/wirer/version.rb
-- lib/wirer/container.rb
-- lib/wirer/dependency.rb
-- lib/wirer/errors.rb
 - lib/wirer/service.rb
-- lib/wirer/factory/from_instance.rb
+- lib/wirer/errors.rb
+- lib/wirer/container.rb
+- lib/wirer/factory/class_mixins.rb
 - lib/wirer/factory/curried_dependencies.rb
 - lib/wirer/factory/wrapped.rb
+- lib/wirer/factory/from_instance.rb
 - lib/wirer/factory/interface.rb
-- lib/wirer/factory/class_mixins.rb
 - lib/wirer/factory/from_args.rb
+- lib/wirer/dependency.rb
 - README.rb
 homepage: 
 licenses: []
@@ -131,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A lightweight dependency injection framework to help wire up objects in Ruby