wirer 0.4.7

data/lib/wirer/factory/wrapped.rb

@@ -0,0 +1,94 @@
+module Wirer
+  # Allows an existing Factory to be wrapped with extra options for a specific context.
+  #
+  # See Factory#wrapped_with for a convenient way to construct one of these -- although you won't
+  # normally need to construct these yourself, rather a Container will wrap factories for you
+  # where you add them to the container together with specific options.
+  #
+  # Allows you to:
+  #
+  # * Specify additional :features that the wrapped factory provides in this context
+  #   (eg to indicate that you provide a specific named version of a more general interface,
+  #    a :special_logger rather than just a Logger)
+  #
+  # * Fix particular initial arguments that get passed to the factory when used in this wrapped context
+  #   (eg if you have a factory that takes arguments, but you want to supply those args upfront,
+  #    and get a factory that just constructs a particular singleton instance; 'currying')
+  #
+  # * Add extra requirements to the existing dependencies for this factory. Eg if you have a dependency on
+  #   some general interface (eg Logger) and you want to pin it down to a specific named version that you've
+  #   made available (like :special_context_logger). Or maybe you want to make an optional dependency into
+  #   a non-optional one.
+  #
+  # * Give a constructor block which allows you customise the way the wrapped factory's new_from_dependencies
+  #   method works. It gets passed the wrapped factory, the constructor dependencies and args, and should return
+  #   the constructed instance. This is for when specifying :initial_args isn't enough and you need
+  #   some custom way of supplying your pre-canned arguments when constructing the thing.
+  class Factory::Wrapped
+    include Factory::Interface
+
+    attr_reader :provides_features, :provides_class, :constructor_dependencies,
+                :wrapped_factory, :initial_args
+
+    OPTION_NAMES = [:args, :features, :dependencies].freeze
+
+    def initialize(factory, options={}, &wrapped_constructor_block)
+      @wrapped_factory = factory
+
+      @provides_class = factory.provides_class
+
+      @provides_features = factory.provides_features
+      extra = options[:features] and @provides_features |= extra
+
+      @constructor_dependencies = factory.constructor_dependencies.dup
+
+      setter_dependencies = factory.setter_dependencies(nil).dup
+      extra = options[:dependencies] and extra.each do |dep_name, extra_dep_args|
+        extra_dep_options = Dependency.normalise_arg_or_args_list(extra_dep_args)
+        if (dep = @constructor_dependencies[dep_name])
+          @constructor_dependencies[dep_name] = dep.with_options(extra_dep_options)
+        elsif (dep = setter_dependencies[dep_name])
+          setter_dependencies[dep_name] = dep.with_options(extra_dep_options)
+          # we only actually save this overridden set of setter_dependencies
+          # if at least one override is specified; otherwise we leave it delegating
+          # at runtime to the wrapped factory's setter_dependencies method,
+          # since this allows it to stay instance-sensitive. see #setter_dependencies.
+          @extended_static_setter_dependencies ||= setter_dependencies
+        else
+          raise Error, "No constructor_dependency or static setter_dependency #{arg_name.inspect} found to extend on the wrapped factory"
+        end
+      end
+
+      if options[:args]
+        @initial_args = options[:args]
+      elsif wrapped_constructor_block
+        @wrapped_constructor_block = wrapped_constructor_block
+      end
+    end
+
+    def setter_dependencies(instance=nil)
+      @extended_static_setter_dependencies || @wrapped_factory.setter_dependencies(instance)
+    end
+
+    def new_from_dependencies(dependencies, *other_args, &block_arg)
+      if @wrapped_constructor_block
+        @wrapped_constructor_block.call(dependencies, *other_args, &block_arg)
+      else
+        case @initial_args
+        when NilClass # forgeddit
+        when Array then other_args.unshift(*@initial_args)
+        else other_args.unshift(@initial_args)
+        end
+        @wrapped_factory.new_from_dependencies(dependencies, *other_args, &block_arg)
+      end
+    end
+
+    def inject_dependency(*args)
+      @wrapped_factory.inject_dependency(*args)
+    end
+
+    def post_initialize(*args)
+      @wrapped_factory.post_initialize(*args)
+    end
+  end
+end

data/lib/wirer/service.rb

@@ -0,0 +1,51 @@
+module Wirer
+  # This is a small convenience superclass which you can (but needn't if you'd rather not)
+  # inherit from when making wireable classes.
+  #
+  # It comes pre-extended with Wirer::Factory::ClassDSL, and it defines initialize for
+  # you to save each constructor dependency in an appropriately-named instance variable.
+  # (note that the 'dependency' class method will also have declared an attr_reader
+  #  with this name too, so you'll be able to get at it that way also.)
+  #
+  # Its 'new' method also type-checks the arguments to ensure that it has indeed
+  # been supplied with all the right dependencies that it was expecting.
+  # Since we have the metadata lying around for what is required, may as well take
+  # advantage of it. This is most handy if you're constructing instances manually
+  # rather than via a Wirer::Container -- eg in unit tests.
+  #
+  # It also sets a straightforward convention for arguments to the constructor:
+  # dependencies and other arguments are given in a single Hash argument.
+  class Service
+    extend Factory::ClassDSL
+
+    class << self
+      # new_from_dependencies, which the container uses, will skip any
+      # type-checking as the container is designed to supply the right dependencies.
+      alias :new_from_dependencies :new
+
+      def new(dependencies, *)
+        constructor_dependencies.each do |name, dependency|
+          dependency.check_argument(name, dependencies[name], true)
+        end
+        super
+      end
+
+      # this one will check that the relevant dependency arguments are passed,
+      # but won't check their types - useful if you want to pass in mocks for
+      # testing.
+      def new_skipping_type_checks(dependencies, *p, &b)
+        constructor_dependencies.each do |name, dependency|
+          dependency.check_argument(name, dependencies[name], false)
+        end
+        new_from_dependencies(dependencies, *p, &b)
+      end
+    end
+
+    def initialize(dependencies={})
+      raise ArgumentError, "expected a Hash of dependencies" unless dependencies.is_a?(Hash)
+      self.class.constructor_dependencies.each do |name, dependency|
+        instance_variable_set(:"@#{name}", dependencies[name])
+      end
+    end
+  end
+end

data/lib/wirer/version.rb

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

data/lib/wirer.rb

@@ -0,0 +1,20 @@
+module Wirer
+end
+
+require 'wirer/factory/interface'
+require 'wirer/factory/from_args'
+require 'wirer/factory/wrapped'
+require 'wirer/factory/from_instance'
+require 'wirer/factory/class_mixins'
+require 'wirer/factory/curried_dependencies'
+require 'wirer/service'
+require 'wirer/dependency'
+require 'wirer/container'
+require 'wirer/errors'
+
+module Kernel
+  private
+  def Wirer(&block)
+    Wirer::Container.new(&block)
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: wirer
+version: !ruby/object:Gem::Version 
+  hash: 1
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 7
+  version: 0.4.7
+platform: ruby
+authors: 
+- Matthew Willson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-12 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 9
+        - 12
+        version: 0.9.12
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id004
+description: 
+email: 
+- matthew@playlouder.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/wirer.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/factory/curried_dependencies.rb
+- lib/wirer/factory/wrapped.rb
+- lib/wirer/factory/interface.rb
+- lib/wirer/factory/class_mixins.rb
+- lib/wirer/factory/from_args.rb
+- README.rb
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A lightweight dependency injection framework to help wire up objects in Ruby
+test_files: []
+