diy 1.0.0 → 1.0.1

data/History.txt

@@ -1,3 +1,13 @@
+== 1.0.1 / 2007-12-02
+
+* Added 'using_namespace' directive for assuming a module for a group of object defs
+* Added 'use_class_directly' option for configuring an ObjectDef.  Instead of instantiating an instance
+  of the specified class, the class itself is referenced.  (Good for injecting ActiveRecord classes into 
+  other components in the guise of factories.
+* Added DIY::Context.auto_require boolean setting. When false, the library of a
+  class is not autoloaded ahead of object construction. Is true by default.
+* 'auto_require' can, if neccessary, be set in the YAML config for an individual object. 
+
 == 1.0.0 / 2007-11-19
 
 * Released!

data/README.txt

@@ -1,126 +1,186 @@
-diy
+== DIY
 
 * http://rubyforge.org/projects/atomicobjectrb/
 * http://atomicobjectrb.rubyforge.org/diy
 
 == DESCRIPTION:
 
-DIY (Dependency Injection in Yaml) is a simple dependency injection library
+DIY (Dependency Injection in YAML) is a simple dependency injection library
 which focuses on declarative composition of objects through constructor injection.
 
-Currently, all objects that get components put into them must have a
-constructor that gets a hash with symbols as keys.
-Best used with constructor.rb
-
-Auto-naming and auto-library support is done.
+== INSTALL:
 
-== FEATURES/PROBLEMS:
-  
-* Constructor-based dependency injection container using YAML input.
+* gem install diy
 
 == SYNOPSIS:
 
-=== A Simple Context
+=== Common Usage
 
-The context is a hash specified in in a yaml file.  Each top-level key identifies
-an object.  When the context is created and queried for an object, by default, 
-the context will require a file with the same name:
+Author a YAML file that describes your objects and how they fit together.
+This means you're building a Hash whose keys are the object names, and whose
+values are Hashes that define the object. 
 
-  require 'foo'
+The following context defines an automobile engine:
 
-Next, by default, it will call new on a class from the camel-cased name of the key:
+context.yml:
+  ---
+  engine:
+    compose: throttle, block
+  throttle:
+    compose: cable, pedal
+  block:
+  cable:
+  pedal:
+
+In your code, use DIY to load the YAML, then access its parts:
+
+  context = DIY::Context.from_file('context.yml')
+  context[:engine]  => <Engine:0x81eb0> 
+
+This approach assumes:
+
+* You've got classes for Engine, Throttle, Block, Cable and Pedal
+* They're defined in engine.rb, throttle.rb, etc
+* The library files are in your load-path
+* Engine and Throttle both have a constructor that accepts a Hash.  The Hash 
+  will contain keys 'throttle', 'block' (for Engine) and 'cable, 'pedal' (for Throttle)
+  and the values will be references to their respective objects.
+* Block, Cable and Pedal all have default constructors that accept no arguments
+
+Sample code for Engine's constructor:
+
+  class Engine
+    def initialize(components)
+      @throttle = components['throttle']
+      @block = components['block']
+    end
+  end
 
-  Foo.new
+Writing code like that is repetetive; that's why we created the Constructor gem, which lets you
+specify object components using the "constructor" class method:
 
-foo.rb:
-  class Foo; end
+* http://atomicobjectrb.rubyforge.org/constructor
 
-context.yml:
-  ---
-  foo:
-  bar:
+Using constructor, you can write Engine like this:
 
-  c = DIY::Context.from_file('context.yml')
-  c[:foo]  => <Foo:0x81eb0> 
+  class Engine
+    constructor :throttle, :block
+  end
 
-=== Specifying Ruby File to Require
+=== Special Cases
 
-If the file the class resides in isn't named after they key:
+If your object has a lot of components (or they have big names) you can specify an array of component names
+as opposed to a comma-separated list:
 
-fun_stuff.rb:
-  class Foo; end
- 
-context.yml:
-   ---
-   foo:
-     lib: fun_stuff
-   bar:
+  engine:
+    compose:
+    - throttle
+    - block
 
-=== Constructor Arguments
+Sometimes you won't be able to rely on DIY's basic assumptions about class names and library files.
 
-DIY allows specification of constructor arguments as hash key-value pairs
-using the <tt>compose</tt> directive.  
+* You can specify the 'class' option
+* You can specify the 'library' option.  If you do not, the library is inferred from the class name. 
+  (Eg, My::Train::Station will be sought in "my/train/station.rb"
 
-foo.rb:
-  class Foo
-    def initialize(args)
-      @bar = args[:bar]
-      @other = args[:other]
-    end
-  end
+  engine:
+    class: FourHorse::Base
+    library: general_engines/base
+    compose: throttle, block
+
+If the Hash coming into your constructor needs to have some keys that do not exactly match the official
+object names, you can specify them one-by-one:
+
+  engine:
+    the_throttle: throttle
+    the_block: block
+
+=== Non-singleton objects
  
-context.yml:
-  ---
+Non-singletons are named objects that provide a new instance every time you ask for them.
+By default, DIY considers all objects to be singletons.  To override, use the "singleton" setting and
+set it to false:
+
   foo:
-    compose: bar, other
-  bar:
-  other:
+    singleton: false
+
+=== Sub-Contexts
+
+Sub-contexts are useful for creating isolated object networks that may need to be instantiated 
+zero or many times in your application.  Objects defined in subcontexts can reference "upward" to 
+their surroundings, as well as objects in the subcontext itself. 
+
+If you wanted to be able to make more than one Engine from the preceding examples, you might try:
+
+  ---
+  epa_regulations:
+
+  +automotive_plant:
+    engine:
+      compose: block, throttle, epa_regulations
+    block:
+    throttle:
 
-=== Using DIY with constructor.rb:
+Each time you delve into the automotive_plant, you get a solar system of the defined objects.
+In this context, the objects are singleton-like.  The next time you invoke the subcontext, however,
+you'll be working with a fresh set of objects... another solar system with the same layout, so to speak.
 
-foo.rb:
-  class Foo
-    constructor :bar, :other
+Subcontexts are not initialized until you call upon them, which you do using the "within" method:
+
+  context = DIY::Context.from_file('context.yml')
+  context.within('automotive_plant') do |plant|
+    puts plant[:engine]
   end
 
-If the constructor argument names don't match up with the object keys
-in the context, they can be mapped explicitly.
+=== Direct Class References
 
- foo.rb:
-   class Foo
-     constructor :bar, :other
-   end
+Occasionally you will have a class at your disposal that you'd like to provide directly as components
+to other objects (as opposed to getting _instances_ of that class, you want to reference the class itself, eg, 
+to use its factory methods).  Enter the "use_class_directly" flag:
 
-context.yml:
   ---
-  foo:
-    bar: my_bar
-    other: the_other_one
-  my_bar:
-  the_other_one:
+  customer_order_finder:
+    class: CustomerOrder
+    use_class_directly: true
 
-=== Non-singleton objects
- 
-Non-singletons will be re-instantiated each time they are needed.
+This can be handy in Rails when you'd like to use some of class methods on an ActiveRecord subclass, but 
+you'd like to avoid direct ActiveRecord class usage in your code.  In this case, the customer_order_finder
+is actually the CustomerOrder class, and so, it has methods like "find" and "destroy_all".
 
-context.yml:
-  ---
-  foo:
-    singleton: false
+=== Namespace Convenience
 
-  bar:
+If you find yourself writing context entries like this:
 
+  ---
   engine:
-    compose: foo, bar
+    class: Car::Parts::Engine
+  throttle:
+    class: Car::Parts::Block
+  cable:
+    class: Car::Parts::Cable
 
-== REQUIREMENTS:
+You can set the "assumed" module for a group of objects like this:
 
-* rubygems
-* works best with constructor
+  ---
+  using_namespace Car Parts:
+    engine:
 
-== INSTALL:
+    throttle:
 
-* gem install diy
+    block:
+
+=== Preventing auto-requiring of library files
+
+Normally, DIY will "require" the library for an object just before it instantiates the object.
+If this is not desired (in Rails, auto-require can lead to library double-load issues), you
+can deactivate auto-require.  There is a global default setting (handled in code) and
+a per-object override (handled in the context YAML):
+
+  DIY::Context.auto_require = false 
+    
+  ---
+  engine:
+    auto_require: false
 
 == LICENSE:
 

data/Rakefile

@@ -15,3 +15,12 @@ Hoe.new('diy', DIY::VERSION) do |p|
   p.test_globs = 'test/*_test.rb'
   p.extra_deps << ['constructor', '>= 1.0.0']
 end
+
+load "../tools/tasks/homepage.rake"
+
+load "../tools/tasks/release_tagging.rake"
+ReleaseTagging.new do |t|
+  t.package = "diy"
+  t.version = DIY::VERSION
+end
+

data/lib/diy.rb

@@ -1,9 +1,18 @@
 require 'yaml'
 require 'set'
 
-module DIY
-  VERSION = '1.0.0'
+module DIY #:nodoc:#
+  VERSION = '1.0.1'
 	class Context
+
+    class << self
+      # Enable / disable automatic requiring of libraries. Default: true
+      attr_accessor :auto_require
+    end
+    @auto_require = true
+
+    # 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)
@@ -21,25 +30,7 @@ module DIY
 				@extra_inputs = extra_inputs
 			end
 
-			# Collect object and subcontext definitions
-			@defs = {}
-			@sub_context_defs = {}
-			context_hash.each do |name,info|
-				name = name.to_s
-				case name
-				when /^\+/ 
-					# subcontext
-					@sub_context_defs[name.gsub(/^\+/,'')] = info
-					
-				else 
-          # Normal singleton object def
-          if extra_inputs_has(name)
-            raise ConstructionError.new(name, "Object definition conflicts with parent context")
-          end
-          @defs[name] = ObjectDef.new(:name => name, :info => info)
-				end
-			end
-
+      collect_object_and_subcontext_defs context_hash
 
 			# init the cache
 			@cache = {}
@@ -47,16 +38,21 @@ module DIY
 		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
 
+    # 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
 
+    # 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]
@@ -73,6 +69,8 @@ module DIY
 		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)
@@ -80,6 +78,7 @@ module DIY
 		end
 		alias :[]= :set_object
 
+    # Provide a listing of object names
 		def keys
 			(@defs.keys.to_set + @extra_inputs.keys.to_set).to_a
 		end
@@ -95,11 +94,16 @@ module DIY
 			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
 
+    # 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
@@ -108,13 +112,56 @@ module DIY
 
 		private
 
+    def collect_object_and_subcontext_defs(context_hash)
+			@defs = {}
+			@sub_context_defs = {}
+      get_defs_from context_hash
+    end
+
+    def get_defs_from(hash, namespace=nil)
+      hash.each do |name,info|
+        name = name.to_s
+        case name
+        when /^\+/ 
+          # subcontext
+          @sub_context_defs[name.gsub(/^\+/,'')] = info
+          
+        when /^using_namespace/
+          # 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)
+
+        else 
+          # Normal object def
+          info ||= {}
+          if extra_inputs_has(name)
+            raise ConstructionError.new(name, "Object definition conflicts with parent context")
+          end
+          unless info.has_key?('auto_require')
+            info['auto_require'] = self.class.auto_require
+          end
+          if namespace 
+            if info['class']
+              info['class'] = namespace.build_classname(info['class'])
+            else
+              info['class'] = namespace.build_classname(name)
+            end
+          end
+            
+          @defs[name] = ObjectDef.new(:name => name, :info => info)
+
+        end
+      end
+    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
+      require search_for_file(obj_def.library) if obj_def.library
 
 			# Resolve all components for the object
 			arg_hash = {}
@@ -131,7 +178,9 @@ module DIY
 			# 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 arg_hash.keys.size > 0
+      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
@@ -142,6 +191,15 @@ module DIY
 			raise cerr
 		end
 
+    def search_for_file(path_suffix)
+      path_suffix = path_suffix + '.rb' unless path_suffix =~ /\.rb$/
+      $LOAD_PATH.each do |root|
+        path = File.join(root, path_suffix)
+        return path if File.file? path
+      end
+      raise ConstructionError, "no such file to load -- #{path_suffix}"
+    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
@@ -152,8 +210,33 @@ module DIY
 			end
 			@extra_inputs.keys.member?(key) or @extra_inputs.keys.member?(key.to_sym)
 		end
+
+    def parse_namespace(str)
+      Namespace.new(str)
+    end
 	end
 
+  class Namespace #:nodoc:#
+    def initialize(str)
+      # 'using_namespace Animal Reptile'
+      parts = str.split(/\s+/)
+      raise "Namespace definitions must begin with 'using_namespace'" unless parts[0] == 'using_namespace'
+      parts.shift
+
+      if parts.length > 0 and parts[0] =~ /::/
+        parts = parts[0].split(/::/)
+      end
+
+      raise NamespaceError, "Namespace needs to indicate a module" if parts.empty?
+
+      @module_nest = parts
+    end
+
+    def build_classname(name)
+      [ @module_nest, Infl.camelize(name) ].flatten.join("::")
+    end
+  end
+
 	class Lookup #:nodoc:
 		attr_reader :name
 		def initialize(obj_name)
@@ -178,13 +261,19 @@ module DIY
 			# Class name
 			@class_name = info.delete 'class'
 			@class_name ||= info.delete 'type'
-			@class_name ||= camelize(@name)
+			@class_name ||= Infl.camelize(@name)
+
+      # Auto Require
+      @auto_require = info.delete 'auto_require'
 
 			# Library
 			@library = info.delete 'library'
 			@library ||= info.delete 'lib'
-			@library ||= underscore(@class_name)
+			@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
@@ -223,20 +312,14 @@ module DIY
       @singleton
     end
 
-		private
-		# Ganked this from Inflector:
-		def camelize(lower_case_and_underscored_word)
-			lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-		end
-		# Ganked this from Inflector:
-		def underscore(camel_cased_word)
-			camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
-		end
+    def use_class_directly?
+      @use_class_directly == true
+    end
+
 	end
 
-	# Exception raised when an object can't be created which is defined in the context.
-	class ConstructionError < RuntimeError 
-		def initialize(object_name, cause=nil) #:nodoc:
+	class ConstructionError < RuntimeError #:nodoc:#
+		def initialize(object_name, cause=nil)
 			object_name = object_name
 			cause = cause
 			m = "Failed to construct '#{object_name}'"
@@ -246,4 +329,18 @@ module DIY
 			super m
 		end
 	end
+
+  class NamespaceError < RuntimeError #:nodoc:#
+  end 
+
+  module Infl #:nodoc:#
+    # Ganked this from Inflector:
+    def self.camelize(lower_case_and_underscored_word) 
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    # Ganked this from Inflector:
+    def self.underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+  end
 end

data/test/diy_test.rb

@@ -7,35 +7,13 @@ class DIYTest < Test::Unit::TestCase
 
   def setup
     # Add load paths:
-    %w|gnu dog cat yak donkey goat horse fud non_singleton|.each do |p|
+    %w|gnu dog cat yak donkey goat horse fud non_singleton namespace|.each do |p|
       libdir = path_to_test_file(p)
       $: << libdir unless $:.member?(libdir)
     end
+    DIY::Context.auto_require = true # Restore default
   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|
-    names.each do |n|
-      assert context.contains_object(n), "Context had no object '#{n}'"
-    end
-  end
 
   #
   # TESTS
@@ -85,6 +63,12 @@ class DIYTest < Test::Unit::TestCase
     assert_not_nil @diy['thinger'], "Should have got my thinger (which is hiding in a couple modules)"
   end
 
+  def test_use_class_directly
+    load_hash 'thinger' => {'class' => "DiyTesting::Bar::Foo", 'lib' => 'foo', 'use_class_directly' => true}
+    @diy.build_everything
+    assert_equal DiyTesting::Bar::Foo, @diy['thinger'], "Should be the class 'object'"
+  end
+
   def test_classname_inside_a_module_derives_the_namespaced_classname_from_the_underscored_object_def_key
     load_hash 'foo/bar/qux' => nil
     @diy.build_everything
@@ -413,6 +397,14 @@ class DIYTest < Test::Unit::TestCase
 		assert_same thinger, @diy[:thinger]
 	end
 
+	def test_should_be_able_to_turn_off_auto_require_for_all_objects
+	  DIY::Context.auto_require = false
+	  load_context 'horse/objects.yml'
+	  
+	  exception = assert_raise(DIY::ConstructionError) { @diy['holder_thing'] }
+	  assert_match(/uninitialized constant/, exception.message)
+  end
+
   def test_should_cause_non_singletons_to_be_rebuilt_every_time_they_are_accessed
     load_context 'non_singleton/objects.yml'
 
@@ -479,4 +471,90 @@ class DIYTest < Test::Unit::TestCase
       assert thread_spinner1.object_id != cat.thread_spinner.object_id, "cat's thread spinner matched the other spinner; should not be so"
     end
   end
+  
+  def test_should_provide_syntax_for_using_namespace
+    # This test exercises single and triple-level namespaces for nested
+    # modules, and their interaction with other namespaced-objects.
+    load_context "namespace/objects.yml"
+
+    %w{road sky cat bird lizard turtle}.each do |obj|
+      assert @diy.contains_object(obj), "Context had no object '#{obj}'"
+    end
+
+    road = @diy['road']
+    sky = @diy['sky']
+    cat = @diy['cat']
+    bird = @diy['bird']
+    lizard = @diy['lizard']
+    turtle = @diy['turtle']
+
+    assert_same road, cat.road, "Cat has wrong Road"
+    assert_same sky, bird.sky, "Bird has wrong Sky"
+    assert_same bird, lizard.bird, "Lizard has wrong Bird"
+  end
+
+  def test_should_combine_a_given_class_name_with_the_namespace
+    load_context "namespace/class_name_combine.yml"
+    assert_not_nil @diy['garfield'], "No garfield"
+    assert_kind_of Animal::Cat, @diy['garfield'], "Garfield wrong"
+  end
+
+  def test_should_let_you_use_namespaces_in_subcontexts
+    load_context "namespace/subcontext.yml"
+    @diy.build_everything
+    %w{road sky cat turtle}.each do |obj|
+      assert @diy.contains_object(obj), "Main context had no object '#{obj}'"
+    end
+    sky = @diy['sky']
+
+    @diy.within("aviary") do |subc|
+      assert subc.contains_object("bird"), "Sub context didn't have 'bird'"
+      assert subc.contains_object("lizard"), "Sub context didn't have 'lizard'"
+      bird = subc['bird']
+      lizard = subc['lizard']
+      assert_same sky, bird.sky, "Bird has wrong Sky"
+      assert_same bird, lizard.bird, "Lizard has wrong Bird"
+    end
+  end
+
+  def test_should_raise_for_namespace_w_no_modules_named
+    ex = assert_raises DIY::NamespaceError do
+      load_context "namespace/no_module_specified.yml"
+    end
+    assert_equal "Namespace needs to indicate a module", ex.message
+  end
+
+  def test_should_raise_for_namespace_whose_modules_dont_exist
+    load_context "namespace/bad_module_specified.yml"
+    ex = assert_raises DIY::ConstructionError do
+      @diy['bird']
+    end
+    assert_match(/failed to construct/i, ex.message)
+    assert_match(/no such file to load -- fuzzy_creature\/bird/, ex.message)
+  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|
+    names.each do |n|
+      assert context.contains_object(n), "Context had no object '#{n}'"
+    end
+  end
+
 end

data/test/files/cat/cat.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class Cat
 	constructor :heritage, :food, :strict => true, :accessors => true
 end

data/test/files/dog/dog_model.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class DogModel
 	constructor :file_resolver, :other_thing, :strict => true, :accessors => true
 end

data/test/files/dog/dog_presenter.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class DogPresenter
 	constructor :model, :view, :strict => true, :accessors => true
 end

data/test/files/fud/toy.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 
 class Toy
 	constructor :widget, :trinket, :accessors => true, :strict => true

data/test/files/gnu/thinger.rb

@@ -1,5 +1,4 @@
 
-require 'constructor'
 
 class Thinger
 	constructor :injected

data/test/files/goat/plane.rb

@@ -1,5 +1,4 @@
 require 'base'
-require 'constructor'
 class Plane < Base
 	constructor :wings, :strict => true
 	def setup

data/test/files/horse/holder_thing.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class HolderThing
 	constructor :thing_held, :strict => true, :accessors => true
 end

data/test/files/non_singleton/fat_cat.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class FatCat
   constructor :thread_spinner, :tick, :yard, :accessors => true
 end

data/test/files/non_singleton/pig.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class Pig
   constructor :thread_spinner, :yard, :accessors => true
 end

data/test/files/non_singleton/thread_spinner.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class ThreadSpinner
   constructor :air, :accessors => true
 end

data/test/files/non_singleton/tick.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class Tick
   constructor :thread_spinner, :accessors => true
 end

data/test/files/yak/core_model.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class CoreModel
 	constructor :data_source, :strict => true
 end

data/test/files/yak/core_presenter.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class CorePresenter
 	constructor :model, :view, :strict => true
 end

data/test/files/yak/fringe_model.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class FringeModel
 	constructor :connected, :accessors => true, :strict => true
 end

data/test/files/yak/fringe_presenter.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class FringePresenter
 	constructor :fringe_model, :fringe_view, :strict => true
 end

data/test/files/yak/giant_squid.rb

@@ -1,4 +1,3 @@
-require 'constructor'
 class GiantSquid
   constructor :fringe_view, :core_model, :krill, :accessors => true
 end

data/test/test_helper.rb

@@ -6,6 +6,7 @@ require 'fileutils'
 require 'find'
 require 'yaml'
 require 'ostruct'
+require "#{here}/constructor"
 
 class Test::Unit::TestCase
 	include FileUtils

metadata

@@ -1,33 +1,45 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
 name: diy
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2007-11-20 00:00:00 -05:00
-summary: Constructor-based dependency injection container using YAML input.
-require_paths: 
-- lib
-email: dev@atomicobject.com
-homepage: 
-rubyforge_project: atomicobjectrb
-description: "== DESCRIPTION:  DIY (Dependency Injection in Yaml) is a simple dependency injection library which focuses on declarative composition of objects through constructor injection.  Currently, all objects that get components put into them must have a constructor that gets a hash with symbols as keys. Best used with constructor.rb  Auto-naming and auto-library support is done."
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
-platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
+  version: 1.0.1
+platform: ""
 authors: 
 - Atomic Object
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2007-12-03 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: constructor
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    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"
+email: dev@atomicobject.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
 files: 
 - History.txt
 - Manifest.txt
@@ -82,37 +94,32 @@ files:
 - test/files/yak/my_objects.yml
 - test/files/yak/sub_sub_context_test.yml
 - test/test_helper.rb
-test_files: 
-- test/diy_test.rb
+has_rdoc: true
+homepage: 
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: constructor
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.0.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.3.0
-    version: 
+rubyforge_project: atomicobjectrb
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: Constructor-based dependency injection container using YAML input.
+test_files: 
+- test/diy_test.rb