diy 1.1 → 1.1.1

data/History.txt

@@ -1,3 +1,6 @@
+== 1.1.1 / 2008-05-21
+  * Fixed bug that did not allow a method to be properly injected into an object
+
 == 1.1 / 2008-05-20
   * Added 'method' directive for building a bounded method from an object defined in diy
 

data/Manifest.txt

@@ -36,11 +36,14 @@ test/files/donkey/foo.rb
 test/files/donkey/foo/bar/qux.rb
 test/files/fud/objects.yml
 test/files/fud/toy.rb
+test/files/functions/attached_things_builder.rb
 test/files/functions/invalid_method.yml
+test/files/functions/method_extractor.rb
 test/files/functions/nonsingleton_objects.yml
 test/files/functions/objects.yml
 test/files/functions/thing.rb
 test/files/functions/thing_builder.rb
+test/files/functions/things_builder.rb
 test/files/gnu/objects.yml
 test/files/gnu/thinger.rb
 test/files/goat/base.rb

data/README.txt

@@ -1,7 +1,7 @@
 == DIY
 
-* http://rubyforge.org/projects/atomicobjectrb/
 * http://atomicobjectrb.rubyforge.org/diy
+* http://rubyforge.org/projects/atomicobjectrb/
 
 == DESCRIPTION:
 
@@ -182,9 +182,26 @@ a per-object override (handled in the context YAML):
   engine:
     auto_require: false
 
+=== Factories
+
+It is possible to create factories automatically with DIY:
+
+  ---
+  car_dealer:
+    compose: car_factory
+
+  car_factory:
+    builds: car
+
+Then you can use the factory to easily build objects:
+
+  context = DIY::Context.from_file('context.yml')
+  context[:car_factory].create  => <Car:0x81eb0> 
+
 === Method Directive
-  This introduces the concept of first class methods. An object can now be constructed with a method bound to
-  a particular object in the diy context.
+
+This introduces the concept of first class methods. An object can now be constructed with a method object 
+bound to a particular object in the diy context.
   
   ---
   trinket_builder:

data/Rakefile

@@ -1,6 +1,9 @@
 require 'rubygems'
 require 'hoe'
-require './lib/diy.rb'
+
+
+$: << "lib"
+require 'diy.rb'
 
 task :default => [ :test ]
 
@@ -9,7 +12,7 @@ Hoe.new('diy', DIY::VERSION) do |p|
   p.author = 'Atomic Object'
   p.email = 'dev@atomicobject.com'
   p.summary = 'Constructor-based dependency injection container using YAML input.'
-  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.description = p.paragraphs_of('README.txt', 3).join("\n\n")
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
   p.test_globs = 'test/*_test.rb'

data/lib/diy.rb

@@ -1,9 +1,10 @@
+require 'diy/factory.rb'
 require 'yaml'
 require 'set'
 
 module DIY #:nodoc:#
-  VERSION = '1.1'
-	class Context
+  VERSION = '1.1.1'
+  class Context
 
     class << self
       # Enable / disable automatic requiring of libraries. Default: true
@@ -13,118 +14,140 @@ module DIY #:nodoc:#
 
     # Accepts a Hash defining the object context (usually loaded from objects.yml), and an additional
     # Hash containing objects to inject into the context.
-		def initialize(context_hash, extra_inputs={})
-			raise "Nil context hash" unless context_hash
-			raise "Need a hash" unless context_hash.kind_of?(Hash)
-			[ "[]", "keys" ].each do |mname|
-				unless extra_inputs.respond_to?(mname) 
-					raise "Extra inputs must respond to hash-like [] operator and methods #keys and #each" 
-				end
-			end
-
-			# store extra inputs
-			if extra_inputs.kind_of?(Hash)
-				@extra_inputs= {}
-				extra_inputs.each { |k,v| @extra_inputs[k.to_s] = v } # smooth out the names
-			else
-				@extra_inputs = extra_inputs
-			end
+    def initialize(context_hash, extra_inputs={})
+      raise "Nil context hash" unless context_hash
+      raise "Need a hash" unless context_hash.kind_of?(Hash)
+      [ "[]", "keys" ].each do |mname|
+        unless extra_inputs.respond_to?(mname) 
+          raise "Extra inputs must respond to hash-like [] operator and methods #keys and #each" 
+        end
+      end
+
+      # store extra inputs
+      if extra_inputs.kind_of?(Hash)
+        @extra_inputs= {}
+        extra_inputs.each { |k,v| @extra_inputs[k.to_s] = v } # smooth out the names
+      else
+        @extra_inputs = extra_inputs
+      end
 
       collect_object_and_subcontext_defs context_hash
 
-			# init the cache
-			@cache = {}
-			@cache['this_context'] = self
-		end
+      # init the cache
+      @cache = {}
+      @cache['this_context'] = self
+    end
    
 
     # Convenience: create a new DIY::Context by loading from a String (or open file handle.)
-		def self.from_yaml(io_or_string, extra_inputs={})
-			raise "nil input to YAML" unless io_or_string
-			Context.new(YAML.load(io_or_string), extra_inputs)
-		end
+    def self.from_yaml(io_or_string, extra_inputs={})
+      raise "nil input to YAML" unless io_or_string
+      Context.new(YAML.load(io_or_string), extra_inputs)
+    end
 
     # Convenience: create a new DIY::Context by loading from the named file.
-		def self.from_file(fname, extra_inputs={})
-			raise "nil file name" unless fname
-			self.from_yaml(File.read(fname), extra_inputs)
-		end
+    def self.from_file(fname, extra_inputs={})
+      raise "nil file name" unless fname
+      self.from_yaml(File.read(fname), extra_inputs)
+    end
 
     # Return a reference to the object named.  If necessary, the object will 
     # be instantiated on first use.  If the object is non-singleton, a new
     # object will be produced each time.
-		def get_object(obj_name)
-			key = obj_name.to_s
-			obj = @cache[key]
-			unless obj
-				if extra_inputs_has(key)
-					obj = @extra_inputs[key]
-				end
-			end
-			unless obj
-			  case @defs[key]
-		    when MethodDef
-		      @cache[key] = construct_method(key)
-		    else
-		      obj = construct_object(key)
-  				@cache[key] = obj if @defs[key].singleton?
-		    end
-			end
-			obj
-		end
-		alias :[] :get_object
+    def get_object(obj_name)
+      key = obj_name.to_s
+      obj = @cache[key]
+      unless obj
+        if extra_inputs_has(key)
+          obj = @extra_inputs[key]
+        else
+          case @defs[key]
+          when MethodDef
+            obj = construct_method(key)
+          when FactoryDef
+            obj = construct_factory(key)
+            @cache[key] = obj
+          else
+            obj = construct_object(key)
+            @cache[key] = obj if @defs[key].singleton?
+          end
+        end
+      end
+      obj
+    end
+    alias :[] :get_object
 
     # Inject a named object into the Context.  This must be done before the Context has instantiated the 
     # object in question.
-		def set_object(obj_name,obj)
-			key = obj_name.to_s
-			raise "object '#{key}' already exists in context" if @cache.keys.include?(key)
-			@cache[key] = obj
-		end
-		alias :[]= :set_object
+    def set_object(obj_name,obj)
+      key = obj_name.to_s
+      raise "object '#{key}' already exists in context" if @cache.keys.include?(key)
+      @cache[key] = obj
+    end
+    alias :[]= :set_object
 
     # Provide a listing of object names
-		def keys
-			(@defs.keys.to_set + @extra_inputs.keys.to_set).to_a
-		end
+    def keys
+      (@defs.keys.to_set + @extra_inputs.keys.to_set).to_a
+    end
 
-		# Instantiate and yield the named subcontext
-		def within(sub_context_name)
-			# Find the subcontext definitaion:
-			context_def = @sub_context_defs[sub_context_name.to_s]
-			raise "No sub-context named #{sub_context_name}" unless context_def
-			# Instantiate a new context using self as parent:
-			context = Context.new( context_def, self )
+    # Instantiate and yield the named subcontext
+    def within(sub_context_name)
+      # Find the subcontext definitaion:
+      context_def = @sub_context_defs[sub_context_name.to_s]
+      raise "No sub-context named #{sub_context_name}" unless context_def
+      # Instantiate a new context using self as parent:
+      context = Context.new( context_def, self )
 
-			yield context
-		end
+      yield context
+    end
 
     # Returns true if the context contains an object with the given name
-		def contains_object(obj_name)
-			key = obj_name.to_s
-			@defs.keys.member?(key) or extra_inputs_has(key)
-		end
+    def contains_object(obj_name)
+      key = obj_name.to_s
+      @defs.keys.member?(key) or extra_inputs_has(key)
+    end
 
     # Every top level object in the Context is instantiated.  This is especially useful for 
     # systems that have "floating observers"... objects that are never directly accessed, who
     # would thus never be instantiated by coincedence.  This does not build any subcontexts 
     # that may exist.
-		def build_everything
-			@defs.keys.each { |k| self[k] }
-		end
-		alias :build_all :build_everything
-		alias :preinstantiate_singletons :build_everything
+    def build_everything
+      @defs.keys.each { |k| self[k] }
+    end
+    alias :build_all :build_everything
+    alias :preinstantiate_singletons :build_everything
 
-		private
+    private
 
     def collect_object_and_subcontext_defs(context_hash)
-			@defs = {}
-			@sub_context_defs = {}
+      @defs = {}
+      @sub_context_defs = {}
       get_defs_from context_hash
     end
 
     def get_defs_from(hash, namespace=nil)
       hash.each do |name,info|
+        # we modify the info hash below so it's important to have a new
+        # instance to play with
+        info = info.dup if info
+        
+        # see if we are building a factory
+        if info and info.has_key?('builds')
+          unless info.has_key?('auto_require')
+            info['auto_require'] = self.class.auto_require
+          end
+
+          if namespace
+            info['builds'] = namespace.build_classname(info['builds'])
+          end
+          @defs[name] = FactoryDef.new({:name => name,
+                                       :target => info['builds'],
+                                       :library => info['library'],
+                                       :auto_require => info['auto_require']})
+          next
+        end
+
         name = name.to_s
         case name
         when /^\+/ 
@@ -135,11 +158,12 @@ module DIY #:nodoc:#
           # namespace: use a module(s) prefix for the classname of contained object defs
           # NOTE: namespacing is NOT scope... it's just a convenient way to setup class names for a group of objects.
           get_defs_from info, parse_namespace(name)
-        when /^method/
+        when /^method\s/
           key_name = name.gsub(/^method\s/, "")
           @defs[key_name] = MethodDef.new(:name => key_name, 
                                       :object => info['object'], 
-                                      :method => info['method'])
+                                      :method => info['method'],
+                                      :attach => info['attach'])
         else 
           # Normal object def
           info ||= {}
@@ -163,69 +187,83 @@ module DIY #:nodoc:#
       end
     end
 
-    
     def construct_method(key)
       method_definition = @defs[key]
       object = get_object(method_definition.object)
-      return object.method(method_definition.method)
+      method = object.method(method_definition.method)
+      
+      unless method_definition.attach.nil?
+        instance_var_name = "@__diy_#{method_definition.object}"
+        
+        method_definition.attach.each do |object_key|
+          get_object(object_key).instance_eval do
+            instance_variable_set(instance_var_name, object)
+            eval %|def #{key}(*args)
+              #{instance_var_name}.#{method_definition.method}(*args)
+            end|
+          end
+        end      
+      end
+      
+      return method
     rescue Exception => oops
       build_and_raise_construction_error(key, oops)
     end
     
-		def construct_object(key)
-			# Find the object definition
-			obj_def = @defs[key]
-			raise "No object definition for '#{key}'" unless obj_def
-			# If object def mentions a library, load it
-      require obj_def.library	if obj_def.library
-
-			# Resolve all components for the object
-			arg_hash = {}
-			obj_def.components.each do |name,value|
-				case value
-				when Lookup
-					arg_hash[name.to_sym] = get_object(value.name)
-				when StringValue
-					arg_hash[name.to_sym] = value.literal_value
-				else
-					raise "Cannot cope with component definition '#{value.inspect}'"
-				end
-			end
-			# Get a reference to the class for the object
-			big_c = get_class_for_name_with_module_delimeters(obj_def.class_name)
-			# Make and return the instance
+    def construct_object(key)
+      # Find the object definition
+      obj_def = @defs[key]
+      raise "No object definition for '#{key}'" unless obj_def
+      # If object def mentions a library, load it
+      require obj_def.library if obj_def.library
+
+      # Resolve all components for the object
+      arg_hash = {}
+      obj_def.components.each do |name,value|
+        case value
+        when Lookup
+          arg_hash[name.to_sym] = get_object(value.name)
+        when StringValue
+          arg_hash[name.to_sym] = value.literal_value
+        else
+          raise "Cannot cope with component definition '#{value.inspect}'"
+        end
+      end
+      # Get a reference to the class for the object
+      big_c = get_class_for_name_with_module_delimeters(obj_def.class_name)
+      # Make and return the instance
       if obj_def.use_class_directly?
         return big_c
       elsif arg_hash.keys.size > 0
-  			return big_c.new(arg_hash)
-			else
-				return big_c.new
-			end
-		rescue Exception => oops
-		  build_and_raise_construction_error(key, oops)
-		end
-		
-		def build_and_raise_construction_error(key, oops)
-		  cerr = ConstructionError.new(key,oops)
-			cerr.set_backtrace(oops.backtrace)
-			raise cerr
-		end
-			
-		def get_class_for_name_with_module_delimeters(class_name)
-			class_name.split(/::/).inject(Object) do |mod,const_name| mod.const_get(const_name) end
-		end
-
-		def extra_inputs_has(key)
-			if key.nil? or key.strip == ''
-				raise ArgumentError.new("Cannot lookup objects with nil keys")
-			end
-			@extra_inputs.keys.member?(key) or @extra_inputs.keys.member?(key.to_sym)
-		end
+        return big_c.new(arg_hash)
+      else
+        return big_c.new
+      end
+    rescue Exception => oops
+      build_and_raise_construction_error(key, oops)
+    end
+    
+    def build_and_raise_construction_error(key, oops)
+      cerr = ConstructionError.new(key,oops)
+      cerr.set_backtrace(oops.backtrace)
+      raise cerr
+    end
+      
+    def get_class_for_name_with_module_delimeters(class_name)
+      class_name.split(/::/).inject(Object) do |mod,const_name| mod.const_get(const_name) end
+    end
+
+    def extra_inputs_has(key)
+      if key.nil? or key.strip == ''
+        raise ArgumentError.new("Cannot lookup objects with nil keys")
+      end
+      @extra_inputs.keys.member?(key) or @extra_inputs.keys.member?(key.to_sym)
+    end
 
     def parse_namespace(str)
       Namespace.new(str)
     end
-	end
+  end
   
   class Namespace #:nodoc:#
     def initialize(str)
@@ -248,69 +286,69 @@ module DIY #:nodoc:#
     end
   end
 
-	class Lookup #:nodoc:
-		attr_reader :name
-		def initialize(obj_name)
-			@name = obj_name
-		end
-	end
+  class Lookup #:nodoc:
+    attr_reader :name
+    def initialize(obj_name)
+      @name = obj_name
+    end
+  end
   
-  class MethodDef
-    attr_accessor :name, :object, :method
+  class MethodDef #:nodoc:
+    attr_accessor :name, :object, :method, :attach
     
     def initialize(opts)
-      @name, @object, @method = opts[:name], opts[:object], opts[:method]
+      @name, @object, @method, @attach = opts[:name], opts[:object], opts[:method], opts[:attach]
     end
   end
   
-	class ObjectDef #:nodoc:
-		attr_accessor :name, :class_name, :library, :components
-		def initialize(opts)
+  class ObjectDef #:nodoc:
+    attr_accessor :name, :class_name, :library, :components
+    def initialize(opts)
       name = opts[:name]
       raise "Can't make an ObjectDef without a name" if name.nil?
 
       info = opts[:info] || {}
       info = info.clone
 
-			@components = {}
+      @components = {}
 
-			# Object name
-			@name = name
+      # Object name
+      @name = name
 
-			# Class name
-			@class_name = info.delete 'class'
-			@class_name ||= info.delete 'type'
-			@class_name ||= Infl.camelize(@name)
+      # Class name
+      @class_name = info.delete 'class'
+      @class_name ||= info.delete 'type'
+      @class_name ||= Infl.camelize(@name)
 
       # Auto Require
       @auto_require = info.delete 'auto_require'
 
-			# Library
-			@library = info.delete 'library'
-			@library ||= info.delete 'lib'
-			@library ||= Infl.underscore(@class_name) if @auto_require
-
-			# Use Class Directly
-			@use_class_directly = info.delete 'use_class_directly'
-			
-			# Auto-compose
-			compose = info.delete 'compose'
-			if compose
-				case compose
-				when Array
-					auto_names = compose.map { |x| x.to_s }
-				when String
-					auto_names = compose.split(',').map { |x| x.to_s.strip }
-				when Symbol
-					auto_names = [ compose.to_s ]
-				else
-					raise "Cannot auto compose object #{@name}, bad 'compose' format: #{compose.inspect}"
-				end
-			end
-			auto_names ||= []
-			auto_names.each do |cname|
-				@components[cname] = Lookup.new(cname)
-			end
+      # Library
+      @library = info.delete 'library'
+      @library ||= info.delete 'lib'
+      @library ||= Infl.underscore(@class_name) if @auto_require
+
+      # Use Class Directly
+      @use_class_directly = info.delete 'use_class_directly'
+      
+      # Auto-compose
+      compose = info.delete 'compose'
+      if compose
+        case compose
+        when Array
+          auto_names = compose.map { |x| x.to_s }
+        when String
+          auto_names = compose.split(',').map { |x| x.to_s.strip }
+        when Symbol
+          auto_names = [ compose.to_s ]
+        else
+          raise "Cannot auto compose object #{@name}, bad 'compose' format: #{compose.inspect}"
+        end
+      end
+      auto_names ||= []
+      auto_names.each do |cname|
+        @components[cname] = Lookup.new(cname)
+      end
 
       # Singleton status
       if info['singleton'].nil?
@@ -320,12 +358,12 @@ module DIY #:nodoc:#
       end
       info.delete 'singleton'
 
-			# Remaining keys
-			info.each do |key,val|
-				@components[key.to_s] = Lookup.new(val.to_s)
-			end
+      # Remaining keys
+      info.each do |key,val|
+        @components[key.to_s] = Lookup.new(val.to_s)
+      end
 
-		end
+    end
 
     def singleton?
       @singleton
@@ -335,19 +373,19 @@ module DIY #:nodoc:#
       @use_class_directly == true
     end
 
-	end
-
-	class ConstructionError < RuntimeError #:nodoc:#
-		def initialize(object_name, cause=nil)
-			object_name = object_name
-			cause = cause
-			m = "Failed to construct '#{object_name}'"
-			if cause 
-				m << "\n  ...caused by:\n  >>> #{cause}"
-			end
-			super m
-		end
-	end
+  end
+
+  class ConstructionError < RuntimeError #:nodoc:#
+    def initialize(object_name, cause=nil)
+      object_name = object_name
+      cause = cause
+      m = "Failed to construct '#{object_name}'"
+      if cause 
+        m << "\n  ...caused by:\n  >>> #{cause}"
+      end
+      super m
+    end
+  end
 
   class NamespaceError < RuntimeError #:nodoc:#
   end 

data/test/diy_test.rb

@@ -540,7 +540,7 @@ class DIYTest < Test::Unit::TestCase
     
     assert_not_nil build_thing, "should not be nil"
     assert_kind_of(Method, build_thing)
-    assert_same(build_thing, @diy['build_thing'])
+    assert_equal(build_thing, @diy['build_thing'])
   end
   
   def test_bounded_method_can_be_used
@@ -564,6 +564,12 @@ class DIYTest < Test::Unit::TestCase
     assert_not_equal(@diy['build_thing'], @diy['thing_builder'].method(:build))
   end
   
+  def test_composing_bounded_methods_into_other_objects
+    load_context "functions/objects.yml"
+    @diy.build_everything
+    assert_equal(@diy['build_thing'], @diy['things_builder'].build_thing)
+  end
+  
   def test_raises_construction_error_if_invalid_method_specified
     load_context "functions/invalid_method.yml"
     assert_raises DIY::ConstructionError do
@@ -571,22 +577,26 @@ class DIYTest < Test::Unit::TestCase
     end
   end
   
+  def test_can_optionally_attach_method_to_other_objects_in_context
+    load_context "functions/objects.yml"
+    @diy.build_everything
+    
+    thing = @diy['attached_things_builder'].build_thing("the name", "flying")
+    assert_kind_of(Thing, thing)
+    assert_equal("the name", thing.name)
+    assert_equal("flying", thing.ability)    
+    
+    ["attached_things_builder", "things_builder"].each do |key|
+      thing = @diy[key].build_default_thing
+      assert_kind_of(Thing, thing)
+      assert_equal("Thing", thing.name)
+      assert_equal("nothing", thing.ability)    
+    end
+  end
+  
   #
   # HELPERS
   #
-  def path_to_test_file(fname)
-    path_to("/files/#{fname}")
-  end
-
-  def load_context(file_name)
-    hash = YAML.load(File.read(path_to_test_file(file_name)))
-    load_hash(hash)
-  end
-
-  def load_hash(hash)
-    @diy = DIY::Context.new(hash)
-  end
-
   def check_dog_objects(context)
     assert_not_nil context, "nil context"
     names = %w|dog_presenter dog_model dog_view file_resolver|

data/test/factory_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + "/test_helper"
+require 'diy'
+require 'fileutils'
+include FileUtils
+
+class FactoryTest < Test::Unit::TestCase
+
+  def setup
+    # Add load paths:
+    %w|factory|.each do |p|
+      libdir = path_to_test_file(p)
+      $: << libdir unless $:.member?(libdir)
+    end
+    DIY::Context.auto_require = true # Restore default
+  end
+
+
+  #
+  # TESTS
+  #
+
+  def test_creates_factory
+    load_context "factory/factory.yml"
+
+    cat_factory = @diy.get_object(:cat_factory)
+    assert_not_nil cat_factory
+
+    cat = cat_factory.create('a', 'b')
+
+    assert cat.is_a?(Kitten)
+    assert_equal "meow", cat.meow
+    assert_equal 'a', cat.a
+    assert_equal 'b', cat.b
+  end
+
+  def test_creates_factory_with_autorequire
+    load_context "factory/factory.yml"
+
+    dog_factory = @diy.get_object(:dog_factory)
+    assert_not_nil dog_factory
+
+    dog = dog_factory.create
+
+    assert dog.is_a?(Dog)
+    assert_equal "woof", dog.woof
+  end
+
+  def test_creates_factory_with_subcontext
+    load_context "factory/factory.yml"
+
+    @diy.within :inny do |context|
+      bull_factory = context.get_object(:bull_factory)
+      beef = bull_factory.create
+    end
+  end
+
+  def test_creates_factory_with_subcontext_and_namespace
+    load_context "factory/factory.yml"
+
+    @diy.within :congress do |context|
+      politician = context.get_object(:politician)
+      pork = politician.create
+      assert pork.is_a?(Farm::Pork)
+      assert_equal "money!", pork.oink
+    end
+  end
+
+  def test_creates_factory_with_namespace
+    load_context "factory/factory.yml"
+
+    llama_factory = @diy.get_object(:llama_factory)
+    assert_not_nil llama_factory
+
+    llama = llama_factory.create
+
+    assert llama.is_a?(Farm::Llama)
+    assert_equal "?", llama.make_llama_noise
+  end
+end

data/test/files/functions/attached_things_builder.rb

@@ -0,0 +1,2 @@
+class AttachedThingsBuilder
+end

data/test/files/functions/method_extractor.rb

@@ -0,0 +1,3 @@
+class MethodExtractor
+  
+end

data/test/files/functions/objects.yml

@@ -1,5 +1,22 @@
 thing_builder:
 
+method_extractor:
+  
+attached_things_builder:
+  
 method build_thing:
     object: thing_builder
-    method: build
+    method: build
+    attach:
+    - attached_things_builder
+
+method build_default_thing:
+    object: thing_builder
+    method: build_default
+    attach:
+    - attached_things_builder
+    - things_builder
+    
+things_builder:
+  compose:
+    - build_thing

data/test/files/functions/thing_builder.rb

@@ -17,5 +17,9 @@ class ThingBuilder
   
   def build(name, ability)
     Thing.new(:name => name, :ability => ability)
+  end
+  
+  def build_default
+    Thing.new(:name => "Thing", :ability => "nothing")
   end  
 end

data/test/files/functions/things_builder.rb

@@ -0,0 +1,3 @@
+class ThingsBuilder
+  constructor :build_thing, :accessors => true
+end

data/test/test_helper.rb

@@ -36,4 +36,20 @@ class Test::Unit::TestCase
 			@_tracked_tests[msym] = true
 		end
 	end
+
+  #
+  # HELPERS
+  #
+  def path_to_test_file(fname)
+    path_to("/files/#{fname}")
+  end
+
+  def load_context(file_name)
+    hash = YAML.load(File.read(path_to_test_file(file_name)))
+    load_hash(hash)
+  end
+
+  def load_hash(hash)
+    @diy = DIY::Context.new(hash)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: diy
 version: !ruby/object:Gem::Version 
-  version: "1.1"
+  version: 1.1.1
 platform: ruby
 authors: 
 - Atomic Object
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-20 00:00:00 -04:00
+date: 2009-11-01 01:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: constructor
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -23,14 +24,17 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.5.1
+        version: 2.3.3
     version: 
-description: "== DESCRIPTION:  DIY (Dependency Injection in YAML) is a simple dependency injection library which focuses on declarative composition of objects through constructor injection.  == INSTALL:  * gem install diy"
+description: |-
+  DIY (Dependency Injection in YAML) is a simple dependency injection library
+  which focuses on declarative composition of objects through constructor injection.
 email: dev@atomicobject.com
 executables: []
 
@@ -42,7 +46,6 @@ extra_rdoc_files:
 - README.txt
 - TODO.txt
 - homepage/Notes.txt
-- test/files/namespace/hello.txt
 files: 
 - History.txt
 - Manifest.txt
@@ -82,11 +85,14 @@ files:
 - test/files/donkey/foo/bar/qux.rb
 - test/files/fud/objects.yml
 - test/files/fud/toy.rb
+- test/files/functions/attached_things_builder.rb
 - test/files/functions/invalid_method.yml
+- test/files/functions/method_extractor.rb
 - test/files/functions/nonsingleton_objects.yml
 - test/files/functions/objects.yml
 - test/files/functions/thing.rb
 - test/files/functions/thing_builder.rb
+- test/files/functions/things_builder.rb
 - test/files/gnu/objects.yml
 - test/files/gnu/thinger.rb
 - test/files/goat/base.rb
@@ -132,6 +138,8 @@ files:
 - test/test_helper.rb
 has_rdoc: true
 homepage: 
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -153,9 +161,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: atomicobjectrb
-rubygems_version: 1.1.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Constructor-based dependency injection container using YAML input.
 test_files: 
 - test/diy_test.rb
+- test/factory_test.rb