wirer 0.4.7

data/README.rb

@@ -0,0 +1,398 @@
+# Wirer
+#
+# A lightweight dependency injection framework to help wire up objects in Ruby.
+#
+# Some usage examples for now:
+
+container = Wirer do |c|
+
+  # SHOWING THE CONTAINER HOW TO CONSTRUCT AN EXISTING CLASS:
+
+  # This is registered as providing class Logger.
+  # It will be constructed via Logger.new('/option_for_logger.txt')
+  c.add Logger, '/option_for_logger.txt'
+
+  # This is registered as providing class Logger, and also providing feature :special_logger
+  # which can then be used to request it in particular situations
+  c.add :special_logger, Logger, '/special_log.txt'
+
+  # You can supply a custom block for constructing the dependency if you want;
+  # specifying the class upfront means it still knows what class is provided by the block
+  c.add(:other_special_logger, Logger) do
+    Logger.new(foo, bar, baz)
+  end
+
+  # You don't actually have to specify the class that's provided; it will just
+  # provide_class Object by default. In this case you really need to specify
+  # a feature name for it, or else you'll have no way to refer to it:
+  c.add(:mystery_meat) do
+    rand(2) == 0 ? Mystery.new : Meat.new
+  end
+
+  # add_new_factory is the more explicit but verbose way to do this.
+  # note in this case you need to specify a :method_name separately if you want a method defined on
+  # the container for it.
+  c.add_new_factory(:class => Foo, :features => [:foo, :bar], :method_name => :foo) {Foo.new(...)}
+  c.add_new_factory(:class => Logger, :features => [:logger], :method_name => :logger, :args => ['/arg_for_logger.txt'])
+
+
+
+
+  # SPECIFYING DEPENDENCIES (which will then automatically get constructed and passed into your constructor)
+
+
+  # This will be constructed via LogSpewer.new(:logger => logger)
+  c.add LogSpewer, :logger => Logger
+
+  # however since two Loggers are available, we might want to specify
+  # a particular one, by making it depend on the feature :special_logger
+  # provided by only one of them.
+  c.add :special_log_spewer, LogSpewer, :logger => :special_logger
+
+  # You can specify a combination of class/module and feature name requirements for a
+  # dependency:
+  c.add :fussy_log_spewer, LogSpewer, :logger => [SpecialLogger, :providing, :these, :features]
+
+
+
+  # USING DEFAULTS and PREFERRED FEATURES TO CHOOSE FROM MANY AVAILABLE DEPENDENCIES
+
+  # If there are many Loggers available, and you have a dependency on a Logger, how does it
+  # decide which one to give you?
+  #
+  # Answer: It will never make an arbitrary choice for you. If there are multiple matching
+  # factories and it has no way to differentiate between them, it will raise an error complaining
+  # about it and let you fix the issue.
+  #
+  # You can either refine the dependency to a *particular* logger, as in the example above
+  # where we asked for a :special_logger.
+  #
+  # But it would also be nice if you could nominate one logger as the default to use in the
+  # case of multiple loggers, without having to specifically request it in each case:
+
+  c.add Logger, :default => true
+
+  # which is shorthand for:
+  c.add Logger, :features => [:default]
+
+
+  # this will then be chosen over any other options when resolving a dependency.
+  # (if more than one 'default' is available, it will still complain).
+
+  # Defaults are actually implemented under the hood using 'preferred features'.
+  # These are extra feature names in addition to the required features for a dependency,
+  # which you'd kinda like if possible but if not then no worries.
+  # eg:
+
+  c.add ColourfulLogSpewer, :logger => {:class => Logger, :prefer => :colour_capable_logger}
+
+  # If there are multiple matches for the logger dependency here, it will prefer one which
+  # provides the :colour_capable_logger feature.
+  # (if there are multiple :colour_capable_loggers, it will still complain).
+
+  # By default, dependencies come with a preferred feature of :default, as though they
+  # were constructed via:
+  c.add LogSpewer, :logger => {:class => Logger, :prefer => :default}
+
+  # You can even have multiple preferred_features, in which case it'll try to pick the
+  # dependency providing the greatest number of them. However if you need more advanced
+  # logic to choose the particular dependency you want
+
+
+
+
+  # MULTIPLE AND OPTIONAL DEPENDENCIES
+
+  # intended to be useful for extension points in plugin systems - you can have for example a
+  # multiple dependency on 'anything interested in listening to me' or 'anything interested
+  # in plugging in to this extension point'.
+
+  # You can specify cardinality options on dependencies via a longer argument form:
+  # by default one and only one dependency is required, but you can make it
+  # :multiple to get an array of all matching dependencies.
+  # This will be constructed as NoisyLogSpewer.new(:loggers => [logger1, logger2, ...])
+  c.add :i_spew_to_all_logs, NoisyLogSpewer, :loggers => {:class => Logger, :multiple => true}
+
+  # if you don't mind getting a nil if there dependency isn't available, you can make it :optional
+  c.add :i_spew_to_a_log_if_present, HesitantLogSpewer, :logger => {:class => Logger, :optional => true}
+
+  # or maybe you want as many are as available but don't mind if that number is zero:
+  # if you don't mind getting a nil if there dependency isn't available, you can make it :optional
+  c.add :i_spew_to_what_i_can_get, HesitantLogSpewer, :loggers => {:class => Logger, :multiple => true, :optional => true}
+
+
+
+  # a particularly complicated dependency example:
+  c.add :complicated, LogSpewer, :loggers => {:class => Logger, :features => [:foo, :bar], :multiple => true, :optional => true}
+
+
+  # CUSTOM ARGS OR CONSTRUCTOR BLOCK
+
+  # By default, dependencies are passed to the class's new method as a hash argument.
+  # you can customize this with a block though:
+  c.add(:foo, Foo, :logger => Logger) do |dependencies|
+    Foo.new(dependencies[:logger])
+  end
+
+  # And you can specify initial :args which will be passed before the dependencies hash.
+  # in this case it'll be constructed as
+  #   Foo.new('initial arg', :logger => logger)
+  c.add(:foo, Foo, 'initial arg', :logger => Logger)
+
+
+
+  # If you need to specify any other keyword arguments for the factory, :dependencies need to be supplied separately, eg:
+  c.add(:foo, Foo, :dependencies => {:logger => Logger}, :args => ['initial arg'], :features => [:extra, :feature, :names])
+
+
+
+
+  # SETTER DEPENDENCIES AND TWO-PHASE INITIALIZATION
+
+  # Sometimes you need depdendencies to be supplied after the object has been constructed.
+  # Eg if you need to break a cyclic dependency.
+  # These kinds of dependencies can be specified as :setter_dependencies.
+  # An example:
+
+  c.add(Foo, :setter_dependencies => {:bar => Bar})
+  c.add(Bar, :setter_dependencies => {:bar => Foo})
+
+  # this situation will be wired up like so:
+  #
+  #   foo = Foo.new
+  #   bar = Bar.new
+  #   foo.send(:bar=, bar)
+  #   bar.send(:foo=, foo)
+  #   foo.send(:post_initialize) if foo.respond_to?(:post_initialize)
+  #   bar.send(:post_initialize) if bar.respond_to?(:post_initialize)
+  #
+  # Note you can get a post_initialize callback once your entire dependency graph
+  # is wired up and ready for action.
+  #
+  # Note that the setters and post_initialize hook used for this purpose
+  # can be private, if you want to limit them only to use by the container
+  # during two-phase initialization.
+
+
+  # If you need precise control over two-phase initialization, you can add your own
+  # Factory provided it implements Wirer::Factory::Interface.
+  #
+  # The factory implementation can, if it wants, override the default mechanism for
+  # injecting dependencies into instances created from it, and the default mechanism
+  # for post_initializing them.
+  #
+  # It can also make the setter_dependencies requested conditional on the particular
+  # instance constructed, which may be useful if they vary depending on arguments to
+  # the constructor.
+  add_factory_instance(my_custom_factory, :method_name => :my_custom_factory)
+
+
+
+  # ADDING AN EXISTING GLOBAL OBJECT
+
+  # Useful if you're using some (doubtless third-party ;-) library which has
+  # hardcoded global state or singletons in a global scope, but you want to add them
+  # to your container anyway so they at least appear as modular components for use by
+  # other stuff.
+
+  # this will work provided the global thing is not itself a class or module:
+  c.add :naughty_global_state, SomeLibraryWithA::GLOBAL_THINGUMY
+
+  # or this is more explicit:
+  c.add_instance SomeLibraryWithA::GLOBAL_THINGUMY, :method_name => :naughty_global_state
+
+  # the object will be added as providing the class of which it is an instance,
+  # together with any extra feature name or names that you specify.
+  # here multiple feature names are specified
+  c.add :instance => SomeLibraryWithA::GLOBAL_THINGUMY, :features => [:foo, :bar]
+
+
+
+
+  # NON-SINGLETON FACTORIES
+
+  # So far every factory we added to our container has been a singleton in the scope of the container.
+  # This is the default and means that the container will only ever construct one instance of it, and
+  # will cache that instance.
+  #
+  # You can turn this off it you want though, via eg:
+  c.add :foo, Foo, :singleton => false
+
+  # The container will then construct a new instance whenever a Foo is required.
+  #
+  # Factories which are added as singletons can also support arguments, eg:
+  #  container.foo(args, for, factory)
+  #
+  # These will then be passed on as additional arguments to the constructor
+  # block where you supply one, eg:
+  c.add(:foo, Foo, :singleton => false, :dependencies => {:logger => Logger}) do |dependencies, *other_args|
+    Foo.new(other_args, dependencies[:logger])
+  end
+
+  # Where you only supply a class, by default they'll be passed as additional
+  # arguments to the new method before the dependencies hash.
+  # If the last argument is a hash, dependencies will be merged into it. eg:
+  #
+  c.add(:foo, Foo, :singleton => false, :dependencies => {:logger => Logger})
+  # here,
+  #   c.foo(:other => arg)
+  # will lead to
+  #   Foo.new(:other => arg, :logger => logger)
+  # and
+  #  c.foo(arg1, arg2, :arg3 => 'foo')
+  # to
+  #  Foo.new(arg1, arg2, :arg3 => 'foo', :logger => logger)
+  #
+  # If you don't like this, just make sure to supply a constructor block.
+
+
+
+  # Note that the singleton-ness or otherwise, is not a property of the factory itself, rather
+  # it's specific to the context of that factory within a particular container.
+
+  # Note that when using non-singleton factories, all bets are off when it comes to wiring up
+  # object graphs which have cycles in them - since it can't keep constructing new instances
+  # all the way down.
+  #
+  # Similarly, if the same dependency occurs twice in your dependency graph,
+  # where a non-singleton factory is used for it, you'll obviously get multiple distinct instances
+  # rather than references to one shared instance.
+  #
+  # I considered providing more fine-grained control over this (eg making things a singleton in the
+  # scope of one particular 'construction session', but able to construct new instance for each
+  # such construction session) but this is out of scope for now.
+end
+
+# GETTING STUFF OUT OF A CONTAINER
+
+# Pretty crucial eh!
+
+# Things added via 'add' with a symbol method name as the first argument, are made available via
+# corresponding methods on the container:
+container.special_logger
+container.mystery_meat
+# You can also specify this via an explicit :method_name parameter (and in fact you need to
+# specify it this if you use the slightly-lower-level add_factory / add_new_factory / add_instance
+# calls)
+
+# You can also ask the container to find any kind of dependency, via
+# passing dependency specification arguments to []:
+container[Logger]
+container[:special_logger]
+container[Logger, :multiple => true]
+container[SomeClass, :and, :some, :features]
+container[SomeModule]
+container[SomeModule, :optional => true]
+# unless you specify :optional => true, it'll whinge if the dependency can't be fulfilled.
+
+
+
+# DSL FOR EXPRESSING DEPENDENCIES FOR A PARTICULAR CLASS
+#
+# This is really handy if you're writing classes which are designed to be
+# components that are ready to be wired up by a Wirer::Container.
+#
+# Using the DSL makes your class instance itself expose Wirer::Factory::Interface,
+# meaning it can be added to a container without having to manually state
+# its dependencies or provided features. The container will 'just know'.
+#
+# (although as we shall see, you can refine the dependencies when adding it to a
+# container, to override the defaults within that particular context if you need to;
+# you can also specify extra provided features within the container context)
+
+class Foo
+  wireable # extends with the DSL methods (Wirer::Factory::ClassDSL)
+
+  # Declare some dependencies.
+  dependency :logger, Logger
+  dependency :arg_name, DesiredClass, :other, :desired, :feature, :names, :optional => true
+  dependency :arg_name, :class => DesiredClass, :features => [:desired, :feature, :names], :optional => true
+
+  # to avoid cyclic load-order dependencies between classes using this DSL, you can specify a class or module
+  # name as a string to be resolved later. In this case you need to use the explicit :class => foo args style.
+  dependency :something, :class => "Some::Thing"
+
+  # you can declare extra features which the class factory provides:
+  provides_feature :foo, :bar, :baz
+
+  # and setter dependencies
+  setter_dependency :foo, Foo
+  # (by default this will also define a private attr_writer :foo for you, which is
+  #  what it will use by default to inject the dependency)
+
+  # you can also override the factory methods which the class has been extended with.
+  # the most common case would be where you want to customize how instances are
+  # constructed from the named dependencies (and any other args), via eg:
+  def self.new_from_dependencies(dependencies, *other_args)
+    new(dependencies[:foo], dependencies[:bar], *other_args)
+  end
+
+  # you could also add extra instance-specific setter dependencies, eg via:
+  def self.setter_dependencies(instance)
+    result = super
+    result[:extra] = Wirer::Dependency.new(...) if instance.something?
+    result
+  end
+
+  # Or to customize the way that setter dependencies are injected:
+  def self.inject_dependency(instance, arg_name, dependency)
+    instance.instance_variable_set(:"@#{arg_name}", dependency)
+  end
+end
+
+class Bar < Foo
+  # when using Wirer::Factory::ClassDSL, subclasses inherit their superclass's dependencies
+  # and features, but you can add new ones:
+  dependency :another_thing, Wotsit
+  provides_feature :extra
+
+  # or override existing dependencies
+  dependency :logger, :special_logger
+
+  # or if you don't want this inheritance between the class factory instances of subclasses,
+  # you can just extend with Wirer::Factory::ClassMixin instead of using the DSL, or you
+  # can override constructor_dependencies / setter_dependencies / provides_features class
+  # methods, or both.
+end
+
+# Adding these classes into a container is then quite simple:
+Wirer do |c|
+
+  # It will see that Foo.is_a?(Wirer::Factory::Interface) and add it directly as a factory
+  # taking into account its dependencies etc
+
+  c.add Foo
+
+  # You can *refine* the dependencies of an existing factory when adding it, eg:
+
+  c.add Foo, :logger => :special_logger
+
+  # its original dependency was just on a Logger, but now it's on a Logger which also
+  # provides_feature :special_logger.
+  #
+  # This allows you to customize which particular instance of a given dependency this
+  # class gets constructed with. It will be added using a Wirer::Factory::Wrapped around
+  # the original factory.
+
+  # You can also specify extra features when adding a factory, which then give you a handle
+  # by which to refer to it when you want it passed to some other thing. Eg to provide the
+  # special logger above:
+  c.add :special_logger, Logger
+
+  # or both at once: adding an existing factory with some extra features and some refined
+  # dependencies within this container's context.
+  c.add Foo, :features => [:special_foo], :dependencies => {:logger => :special_logger}
+
+  # (if you want to specify other arguments for Factory::Wrapped, the dependency refining
+  # arguments need to go in their own :dependencies arg)
+
+  # then could then eg
+  c.add Bar, :foo => :special_foo
+
+  # If you have an existing factory which takes arguments, you can wrap it with specific
+  # (initial) arguments, allowing it to be added as a singleton, eg:
+  c.add Foo, 'args', 'for', 'foo', :logger => Logger
+
+  # or to be more explicit:
+  c.add Foo, :args => ['args', 'for', 'foo'], :dependencies => {:logger => Logger}
+end

data/lib/wirer/container.rb

@@ -0,0 +1,283 @@
+require 'thread'
+
+module Wirer
+  # A container is a collection of factories, together with logic for constructing
+  # instances from these factories in a way that satisfies their dependencies.
+  #
+  # By default, a Factory acts as a singleton in the context of a Container which
+  # it's added to, meaning that only one instance of that factory will be created by
+  # the Container. This instance is created lazily and cached within the container.
+  #
+  # Alternatively if don't want this, specify :singleton => false when adding it.
+  class Container
+    attr_reader :factories
+
+    def initialize
+      @singleton_factories_instances = {}
+      @factories = []
+      @factories_by_method_name = {}
+      @construction_mutex = Mutex.new
+      yield self if block_given?
+    end
+
+    # add Logger
+    #
+    # add :special_logger, Logger, '/special_logger.txt'
+    # add :special_logger, Logger, :args => ['/special_logger.txt']
+    # add(:special_logger, Logger) {|deps| Logger.new('/special_logger.txt')}
+    #
+    # add Thing, :logger => :special_logger
+    # add Thing, :logger => :special_logger
+
+    ADD_OPTION_NAMES = (Factory::Wrapped::OPTION_NAMES | Factory::FromArgs::OPTION_NAMES | [:method_name, :singleton]).freeze
+
+    # Provides a bunch of different convenient argument styles for adding things
+    # to the container.
+    #
+    # add is effectively syntactic sugar around add_factory, add_instance and add_new_factory;
+    # if you prefer a more explicit approach feel free to use these directly.
+    #
+    # (or if you like it *really* explcit, see add_factory_instance)
+    def add(*add_args, &add_block_arg)
+      add_options = if add_args.last.is_a?(Hash) then add_args.pop else {} end
+
+      (add_options[:features] ||= []) << :default if add_options.delete(:default)
+
+      unless add_options.empty? || ADD_OPTION_NAMES.any? {|o| add_options.include?(o)}
+        add_options = {:dependencies => add_options}
+      end
+
+      if add_args.first.is_a?(Symbol)
+        extra_named_feature = add_args.shift
+        add_options[:method_name] ||= extra_named_feature
+        (add_options[:features] ||= []) << extra_named_feature
+      end
+
+      main_arg = add_args.shift
+      case main_arg
+      when Factory::Interface
+        add_options[:args] = add_args unless add_args.empty?
+        add_factory(main_arg, add_options, &add_block_arg)
+      when ::Module
+        add_options[:class] = main_arg
+        add_options[:args] = add_args unless add_args.empty?
+        add_new_factory(add_options, &add_block_arg)
+      when NilClass
+        add_new_factory(add_options, &add_block_arg)
+      else
+        add_instance(main_arg, add_options)
+      end
+    end
+
+    # Adds an existing factory.
+    #
+    # If options for Factory::Wrapped are specified, will wrap the factory with these
+    # extra options / overrides prior to adding it.
+    def add_factory(factory, options={}, &wrapped_constructor_block)
+      add_options = {
+        :method_name => options.delete(:method_name),
+        :singleton   => options.delete(:singleton)
+      }
+      unless options.empty? && !wrapped_constructor_block
+        factory = factory.wrapped_with(options, &wrapped_constructor_block)
+      end
+      add_factory_instance(factory, add_options)
+    end
+
+    # Adds a new Factory::FromArgs constructed from the given args.
+    def add_new_factory(options={}, &constructor_block)
+      factory = Factory::FromArgs.new(options, &constructor_block)
+      add_factory_instance(factory, options)
+    end
+
+    # Adds an instance wrapped via Factory::FromInstance
+    def add_instance(instance, options={})
+      features = options[:features]
+      factory = case features
+      when nil   then Factory::FromInstance.new(instance)
+      when Array then Factory::FromInstance.new(instance, *features)
+      else            Factory::FromInstance.new(instance, features)
+      end
+      add_factory_instance(factory, options)
+    end
+
+    # Adds a factory object, without any wrapping.
+    # only options are :method_name, and :singleton (default true)
+    def add_factory_instance(factory, options={})
+      method_name = options[:method_name]
+      singleton = (options[:singleton] != false)
+
+      raise TypeError, "expected Wirer::Factory::Interface, got #{factory.class}" unless factory.is_a?(Factory::Interface)
+      @factories << factory
+      @singleton_factories_instances[factory] = nil if singleton
+      if method_name
+        @factories_by_method_name[method_name] = factory
+        if respond_to?(method_name, true)
+          warn("Can't add constructor method because #{method_name.inspect} already defined on container")
+        else
+          instance_eval <<-EOS, __FILE__, __LINE__
+            def #{method_name}(*args, &block_arg)
+              construct_factory_by_method_name(#{method_name.inspect}, *args, &block_arg)
+            end
+          EOS
+        end
+      end
+    end
+
+    def factory(name)
+      @factories_by_method_name[name]
+    end
+
+    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)
+        end
+      rescue
+        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))
+      end
+    end
+
+    # Injects (ie monkey-patches) constructor methods into a given object,
+    # which delegate to the corresponding constructor methods defined on the
+    # container.
+    #
+    # This is primarily for use as a convenience by the top-level code which is
+    # driving an application, to inject application services from a container
+    # into the context of (say) an integration test or a driver script.
+    #
+    # If you're considering using this to supply dependencies to objects
+    # *within* your application: instead you would usually want to add that object to
+    # the container with dependencies specified, and let the container construct
+    # it with the right dependencies. Google for discussion about 'service locator'
+    # pattern vs 'dependency injection' / 'IoC container' pattern for more on this.
+    def inject_methods_into(instance, *names)
+      _self = self
+      names.each do |name|
+        class << instance; self; end.send(:define_method, name) do |*args|
+          _self.construct_factory_by_method_name(name, *args)
+        end
+      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