ceedling 0.0.2 → 0.0.3

data/new_project_template/vendor/ceedling/vendor/constructor/specs/constructor_struct_spec.rb

@@ -1,84 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/constructor_struct'
-
-describe ConstructorStruct, "#new" do
-  def struct(*accessors)
-    ConstructorStruct.new(*accessors)
-  end
-  
-  def instance_of(clazz, args=nil)
-    args = [args] || []
-    clazz.new(*args)
-  end
-  
-  before do
-    AClass = struct(:hello, :world) unless defined?(AClass)
-  end
-  
-  it "creates a new class with accessors given a set of symbols or strings" do
-    instance_of(AClass, {:hello => "foo", :world => "bar"}).hello.should == "foo"
-    instance_of(AClass, {:hello => "foo", :world => "bar"}).world.should == "bar"
-  end
-  
-  it "creates a real class" do
-    instance_of(AClass).class.should == AClass
-  end
-  
-  it "has the option of creating a strict accessors" do
-    lambda { instance_of(struct(:foo, :strict => true)) }.should raise_error
-  end
-  
-  it "does not have the option of not creating accessors" do
-    instance_of(struct(:foo, :accessors => false), :foo => "bar").foo.should == "bar"
-  end
-
-  describe "equivalence" do
-    before do
-      @hello = "Hello"
-      @world = "World"
-      @args = { :hello => @hello, :world => @world }
-      @target = AClass.new(@args)
-    end
-
-    it "uses all accessors" do
-      [ nil, :hello, :world ].each do |field_to_alter|
-        alt = AClass.new(:hello => @hello, :world => @world)
-
-        unless field_to_alter
-          # Base case: they should be equal
-          @target.should == alt
-          @target.eql?(alt).should be_true #should eql(alt)
-        else
-          # Change 1 field and see not equal
-          alt.send("#{field_to_alter}=", "other data")
-          @target.should_not == alt
-          @target.should_not eql(alt)
-        end
-      end
-    end
-
-    it "will not compare to another class with same fields" do
-      BClass = ConstructorStruct.new(:hello, :world)
-      alt = BClass.new(:hello => @hello, :world => @world)
-      @target.should_not == alt
-      @target.should_not eql(alt)
-    end
-  end
-
-  describe "extra method definitions" do
-    NightTrain = ConstructorStruct.new(:beer, :conductor) do
-      def setup
-        @conductor ||= "Bill"
-      end
-    end
-
-    it "lets you declare instance methods within a block" do
-      night_train = NightTrain.new(:beer => "Founders")
-      night_train.beer.should == "Founders"
-      night_train.conductor.should == "Bill"
-
-      other_train = NightTrain.new(:beer => "Bells", :conductor => "Dave")
-      other_train.conductor.should == "Dave"
-    end
-  end
-
-end

data/new_project_template/vendor/ceedling/vendor/diy/Rakefile

@@ -1,33 +0,0 @@
-require 'rubygems'
-
-task :default => [ :test ]
-
-require 'rake/testtask'
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.test_files = FileList['test/**/*_test.rb']
-  t.verbose = true
-end
-
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    $: << "lib"
-    require 'diy.rb'
-    gemspec.name = 'diy'
-    gemspec.version = DIY::VERSION
-    gemspec.summary = 'Constructor-based dependency injection container using YAML input.'
-    gemspec.description = 'Constructor-based dependency injection container using YAML input.'
-    gemspec.homepage = 'http://atomicobject.github.com/diy'
-    gemspec.authors = 'Atomic Object'
-    gemspec.email = 'github@atomicobject.com'
-    gemspec.test_files = FileList['test/*_test.rb']
-    gemspec.add_dependency 'constructor', '>= 1.0.0'
-  end
-
-  Jeweler::GemcutterTasks.new
-
-rescue LoadError
-  puts "(jeweler not installed)"
-end

data/new_project_template/vendor/ceedling/vendor/diy/TODO.txt

@@ -1,9 +0,0 @@
-Sun Dec  2 19:59:16 EST 2007
-crosby
-
-Features from FRE's rogue diy.rb (inside Injection) that need to be
-incorporated into trunk:
-
-* auto_require
-* use_class_directly
-

data/new_project_template/vendor/ceedling/vendor/diy/diy.gemspec

@@ -1,131 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{diy}
-  s.version = "1.1.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Atomic Object"]
-  s.date = %q{2009-12-01}
-  s.description = %q{Constructor-based dependency injection container using YAML input.}
-  s.email = %q{github@atomicobject.com}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    "History.txt",
-     "README.rdoc",
-     "Rakefile",
-     "TODO.txt",
-     "diy.gemspec",
-     "lib/diy.rb",
-     "lib/diy/factory.rb",
-     "sample_code/car.rb",
-     "sample_code/chassis.rb",
-     "sample_code/diy_example.rb",
-     "sample_code/engine.rb",
-     "sample_code/objects.yml",
-     "test/constructor.rb",
-     "test/diy_test.rb",
-     "test/factory_test.rb",
-     "test/files/broken_construction.yml",
-     "test/files/cat/cat.rb",
-     "test/files/cat/extra_conflict.yml",
-     "test/files/cat/heritage.rb",
-     "test/files/cat/needs_input.yml",
-     "test/files/cat/the_cat_lineage.rb",
-     "test/files/dog/dog_model.rb",
-     "test/files/dog/dog_presenter.rb",
-     "test/files/dog/dog_view.rb",
-     "test/files/dog/file_resolver.rb",
-     "test/files/dog/other_thing.rb",
-     "test/files/dog/simple.yml",
-     "test/files/donkey/foo.rb",
-     "test/files/donkey/foo/bar/qux.rb",
-     "test/files/factory/beef.rb",
-     "test/files/factory/dog.rb",
-     "test/files/factory/factory.yml",
-     "test/files/factory/farm/llama.rb",
-     "test/files/factory/farm/pork.rb",
-     "test/files/factory/kitten.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",
-     "test/files/goat/can.rb",
-     "test/files/goat/goat.rb",
-     "test/files/goat/objects.yml",
-     "test/files/goat/paper.rb",
-     "test/files/goat/plane.rb",
-     "test/files/goat/shirt.rb",
-     "test/files/goat/wings.rb",
-     "test/files/horse/holder_thing.rb",
-     "test/files/horse/objects.yml",
-     "test/files/namespace/animal/bird.rb",
-     "test/files/namespace/animal/cat.rb",
-     "test/files/namespace/animal/reptile/hardshell/turtle.rb",
-     "test/files/namespace/animal/reptile/lizard.rb",
-     "test/files/namespace/bad_module_specified.yml",
-     "test/files/namespace/class_name_combine.yml",
-     "test/files/namespace/hello.txt",
-     "test/files/namespace/no_module_specified.yml",
-     "test/files/namespace/objects.yml",
-     "test/files/namespace/road.rb",
-     "test/files/namespace/sky.rb",
-     "test/files/namespace/subcontext.yml",
-     "test/files/non_singleton/air.rb",
-     "test/files/non_singleton/fat_cat.rb",
-     "test/files/non_singleton/objects.yml",
-     "test/files/non_singleton/pig.rb",
-     "test/files/non_singleton/thread_spinner.rb",
-     "test/files/non_singleton/tick.rb",
-     "test/files/non_singleton/yard.rb",
-     "test/files/yak/core_model.rb",
-     "test/files/yak/core_presenter.rb",
-     "test/files/yak/core_view.rb",
-     "test/files/yak/data_source.rb",
-     "test/files/yak/fringe_model.rb",
-     "test/files/yak/fringe_presenter.rb",
-     "test/files/yak/fringe_view.rb",
-     "test/files/yak/giant_squid.rb",
-     "test/files/yak/krill.rb",
-     "test/files/yak/my_objects.yml",
-     "test/files/yak/sub_sub_context_test.yml",
-     "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://atomicobject.github.com/diy}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Constructor-based dependency injection container using YAML input.}
-  s.test_files = [
-    "test/diy_test.rb",
-     "test/factory_test.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<constructor>, [">= 1.0.0"])
-    else
-      s.add_dependency(%q<constructor>, [">= 1.0.0"])
-    end
-  else
-    s.add_dependency(%q<constructor>, [">= 1.0.0"])
-  end
-end
-

data/new_project_template/vendor/ceedling/vendor/diy/sample_code/car.rb

@@ -1,7 +0,0 @@
-class Car
-  attr_reader :engine, :chassis
-  def initialize(arg_hash)
-    @engine = arg_hash[:engine]
-    @chassis = arg_hash[:chassis]
-  end
-end

data/new_project_template/vendor/ceedling/vendor/diy/sample_code/chassis.rb

@@ -1,5 +0,0 @@
-class Chassis
-  def to_s
-    "Chassis"
-  end
-end

data/new_project_template/vendor/ceedling/vendor/diy/sample_code/diy_example.rb

@@ -1,26 +0,0 @@
-require "rubygems"
-require "diy"
-
-class Car
-  attr_reader :engine, :chassis
-  def initialize(arg_hash)
-    @engine = arg_hash[:engine]
-    @chassis = arg_hash[:chassis]
-  end
-end
-
-class Chassis
-  def to_s
-    "Chassis"
-  end
-end
-
-class Engine
-  def to_s
-    "Engine"
-  end
-end
-
-context = DIY::Context.from_file("objects.yml")
-car = context['car']
-puts "Car is made of: #{car.engine} and #{car.chassis}"

data/new_project_template/vendor/ceedling/vendor/diy/sample_code/engine.rb

@@ -1,5 +0,0 @@
-class Engine
-  def to_s
-    "Engine"
-  end
-end

data/new_project_template/vendor/ceedling/vendor/diy/sample_code/objects.yml

@@ -1,10 +0,0 @@
----
-car:
-  compose:
-    - engine
-    - chassis
-
-engine:
-
-chassis:
-

data/new_project_template/vendor/ceedling/vendor/diy/test/constructor.rb

@@ -1,119 +0,0 @@
-CONSTRUCTOR_VERSION = '1.0.2' #:nodoc:#
-
-class Class #:nodoc:#
-  def constructor(*attrs, &block)
-    call_block = ''
-    if block_given?
-      @constructor_block = block
-      call_block = 'self.instance_eval(&self.class.constructor_block)'
-    end
-    # Look for embedded options in the listing:
-    opts = attrs.find { |a| a.kind_of?(Hash) and attrs.delete(a) } 
-    do_acc = opts.nil? ? false : opts[:accessors] == true
-    require_args = opts.nil? ? true : opts[:strict] != false
-    super_args = opts.nil? ? nil : opts[:super]
-
-    # Incorporate superclass's constructor keys, if our superclass
-    if superclass.constructor_keys
-      similar_keys = superclass.constructor_keys & attrs
-      raise "Base class already has keys #{similar_keys.inspect}" unless similar_keys.empty?
-      attrs = [attrs,superclass.constructor_keys].flatten
-    end
-    # Generate ivar assigner code lines
-    assigns = ''
-    attrs.each do |k|
-      assigns += "@#{k.to_s} = args[:#{k.to_s}]\n"
-    end 
-
-    # If accessors option is on, declare accessors for the attributes:
-    if do_acc
-      self.class_eval "attr_accessor " + attrs.map {|x| ":#{x.to_s}"}.join(',')
-    end
-
-    # If user supplied super-constructor hints:
-    super_call = ''
-    if super_args
-      list = super_args.map do |a|
-        case a
-        when String
-          %|"#{a}"|
-        when Symbol
-          %|:#{a}|
-        end
-      end
-      super_call  = %|super(#{list.join(',')})|
-    end
-
-    # If strict is on, define the constructor argument validator method,
-    # and setup the initializer to invoke the validator method.
-    # Otherwise, insert lax code into the initializer.
-    validation_code = "return if args.nil?"
-    if require_args
-      self.class_eval do 
-        def _validate_constructor_args(args)
-          # First, make sure we've got args of some kind
-          unless args and args.keys and args.keys.size > 0 
-            raise ConstructorArgumentError.new(self.class.constructor_keys)
-          end
-          # Scan for missing keys in the argument hash
-          a_keys = args.keys
-          missing = []
-          self.class.constructor_keys.each do |ck|
-            unless a_keys.member?(ck)
-              missing << ck
-            end
-            a_keys.delete(ck) # Delete inbound keys as we address them
-          end
-          if missing.size > 0 || a_keys.size > 0
-            raise ConstructorArgumentError.new(missing,a_keys)
-          end
-        end
-      end
-      # Setup the code to insert into the initializer:
-      validation_code = "_validate_constructor_args args "
-    end
-
-    # Generate the initializer code
-    self.class_eval %{
-      def initialize(args=nil)
-        #{super_call}
-        #{validation_code}
-        #{assigns}
-        setup if respond_to?(:setup)
-        #{call_block}
-      end
-    }
-
-    # Remember our constructor keys
-    @_ctor_keys = attrs
-  end
-
-  # Access the constructor keys for this class
-  def constructor_keys; @_ctor_keys ||=[]; end
-
-  def constructor_block #:nodoc:#
-    @constructor_block
-  end
-
-end
-
-# Fancy validation exception, based on missing and extraneous keys.
-class ConstructorArgumentError < RuntimeError #:nodoc:#
-  def initialize(missing,rejected=[])
-    err_msg = ''
-    if missing.size > 0
-      err_msg = "Missing constructor args [#{missing.join(',')}]"
-    end
-    if rejected.size > 0
-      # Some inbound keys were not addressed earlier; this means they're unwanted
-      if err_msg
-        err_msg << "; " # Appending to earlier message about missing items
-      else
-        err_msg = ''
-      end
-      # Enumerate the rejected key names
-      err_msg << "Rejected constructor args [#{rejected.join(',')}]"
-    end
-    super err_msg
-  end
-end

data/new_project_template/vendor/ceedling/vendor/diy/test/diy_test.rb

@@ -1,608 +0,0 @@
-require File.dirname(__FILE__) + "/test_helper"
-require 'diy'
-require 'fileutils'
-include FileUtils
-
-class DIYTest < Test::Unit::TestCase
-
-  def setup
-    # Add load paths:
-    %w|gnu dog cat yak donkey goat horse fud non_singleton namespace functions|.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_essential_use_case
-    load_context "dog/simple.yml"
-
-    # Check object defs
-    check_dog_objects @diy
-
-    # Tweak the load-path
-    $: << path_to_test_file("dog")
-
-    # Get the objects, use reference comparison to check composition
-    presenter = @diy.get_object('dog_presenter')
-    assert_not_nil presenter, 'nil dog_presenter'
-
-    model = @diy.get_object('dog_model') 
-    assert_not_nil model, 'nil dog_model'
-    assert_same presenter.model, model, "Different model came from context than found in presenter"
-
-    view = @diy.get_object('dog_view') 
-    assert_not_nil view, 'nil dog_view'
-    assert_same presenter.view, view, "Different view came from context than found in presenter"
-
-    resolver = @diy.get_object('file_resolver')
-    assert_not_nil resolver, 'nil file_resolver'
-    assert_same model.file_resolver, resolver, "File resolver in model is different than one in context"
-
-    # Check repeat access:
-    assert_same model, @diy.get_object('dog_model'), "Second access of model yielded different result"
-    assert_same view, @diy.get_object('dog_view'), "Second access of view yielded different result"
-    assert_same presenter, @diy.get_object('dog_presenter'), "Second access of presenter got difrnt result"
-  end
-
-  def test_classname_inside_a_module
-    load_hash 'thinger' => {'class' => "DiyTesting::Bar::Foo", 'lib' => 'foo'}
-    @diy.build_everything
-    assert_not_nil @diy['thinger'], "Should have got my thinger (which is hiding in a couple modules)"
-  end
-
-  def test_classname_inside_a_module_loads_from_directories_named_after_the_underscored_module_names
-    load_hash 'thinger' => {'class' => "Foo::Bar::Qux"}
-    # expect it to be loaded from: foo/bar/qux.rb
-    @diy.build_everything
-    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
-    assert_not_nil @diy['foo/bar/qux'], "Should have got my qux (which is hiding in a couple modules)"
-  end
-    
-  def test_keys
-    load_context "dog/simple.yml"
-    assert_equal %w|dog_model dog_presenter dog_view file_resolver other_thing|, @diy.keys.sort
-  end
-
-  def test_subcontext_keys_should_include_parent_context_keys
-    load_context 'yak/sub_sub_context_test.yml'
-    main_keys = %w|core_presenter core_model core_view data_source|.sort
-    assert_equal main_keys, @diy.keys.sort, "Wrong keys in main context"
-    @diy.within :fringe_context do |fcontext|
-      fringe_keys = [main_keys, %w|fringe_model fringe_view fringe_presenter|].flatten.sort
-      assert_equal fringe_keys, fcontext.keys.sort, "Wrong keys in fringe context"
-      fcontext.within :deep_context do |dcontext|
-        deep_keys = [fringe_keys, %w|krill giant_squid|].flatten.sort
-        assert_equal deep_keys, dcontext.keys.sort
-      end
-    end
-  end
-
-  def test_constructor_no_hash
-    assert_raise RuntimeError do DIY::Context.new(nil) end
-  end
-
-  def test_constructor_bad_extra_inputs
-    err = assert_raise RuntimeError  do
-      DIY::Context.new({}, Object.new)
-    end
-    assert_match(/extra inputs/i, err.message)
-  end
-
-  def test_from_yaml
-    text = File.read(path_to_test_file("dog/simple.yml"))
-    diy = DIY::Context.from_yaml(text)
-    check_dog_objects diy
-  end
-
-  def test_from_yaml_extra_inputs
-    extra = { 'the_cat_lineage' => 'siamese', :some_meat => 'horse' }
-    diy = DIY::Context.from_yaml(File.read(path_to_test_file('cat/needs_input.yml')), extra)
-    cat = diy['cat']
-    assert_equal 'siamese', cat.heritage
-    assert_equal 'horse', cat.food
-  end
-
-  def test_from_file
-    diy = DIY::Context.from_file(path_to_test_file("dog/simple.yml"))
-    check_dog_objects diy
-  end
-
-  def test_from_file_bad
-    assert_raise RuntimeError do
-      DIY::Context.from_file(nil)
-    end
-    assert_raise Errno::ENOENT  do
-      DIY::Context.from_file("bad file name")
-    end
-  end
-
-  def test_from_file_extra_inputs
-    extra = { 'the_cat_lineage' => 'siamese', :some_meat => 'horse' }
-    diy = DIY::Context.from_file(path_to_test_file('cat/needs_input.yml'), extra)
-    cat = diy['cat']
-    assert_equal 'siamese', cat.heritage
-    assert_equal 'horse', cat.food
-  end
-
-  def test_contains_object
-    load_context "dog/simple.yml"
-    assert @diy.contains_object('dog_presenter'), "Should be true for dog_presenter"
-    assert !@diy.contains_object('woops'), "Should return false for 'woops'"
-    err = assert_raise ArgumentError do
-      @diy.contains_object(nil)
-    end
-  end
-
-  def test_contains_object_extra_inputs
-    extra = { 'the_cat_lineage' => 'siamese', :some_meat => 'horse' }
-    main = YAML.load(File.read(path_to_test_file('cat/needs_input.yml')))
-    diy = DIY::Context.new(main, extra)
-
-    assert diy.contains_object('cat')
-    assert diy.contains_object('the_cat_lineage')
-    assert diy.contains_object('some_meat')
-  end
-
-  def test_get_object
-    load_context "dog/simple.yml"
-    assert_not_nil @diy.get_object('file_resolver'), "nil resolver?"
-    assert_raise ArgumentError do
-      @diy.get_object(nil)
-    end
-    assert_raise DIY::ConstructionError do
-      @diy.get_object("no such object")
-    end
-  end
-
-  def test_hash_style_access
-    load_context "dog/simple.yml"
-    assert_not_nil @diy['file_resolver'], "nil resolver?"
-    assert_raise ArgumentError do
-      @diy[nil]
-    end
-    assert_raise DIY::ConstructionError do
-      @diy["no such object"]
-    end
-  end
-
-  def test_get_object_construction_error
-    load_context "broken_construction.yml"
-    err = assert_raise DIY::ConstructionError  do
-      @diy.get_object 'dog_presenter'
-    end
-    assert_match(/dog_presenter/, err.message)  
-  end
-
-  def test_context_with_extra_inputs
-    extra = { 'the_cat_lineage' => 'siamese', :some_meat => 'horse' }
-    main = YAML.load(File.read(path_to_test_file('cat/needs_input.yml')))
-    diy = DIY::Context.new(main, extra)
-    cat = diy['cat']
-    assert_equal 'siamese', cat.heritage
-    assert_equal 'horse', cat.food
-  end
-
-  def test_conflicting_extra_inputs
-    extra = { 'the_cat_lineage' => 'siamese', :some_meat => 'horse' }
-    main = YAML.load(File.read(path_to_test_file('cat/extra_conflict.yml')))
-
-    DIY::Context.new(main,extra)
-    flunk "Should have raised err"
-  rescue Exception => err
-    assert_match(/conflict/i, err.message)
-  end
-
-  def test_sub_context
-    load_context 'yak/my_objects.yml'
-
-    core_model = @diy['core_model']
-    assert_not_nil core_model, "no core model in main context?"
-
-    fmodel1 = nil
-    fview1 = nil
-    @diy.within('fringe_context') do |fc|
-      assert_not_nil fc["fringe_presenter"], "no fringe presenter"
-      fmodel1 = fc["fringe_model"]
-      fmodel1a = fc["fringe_model"]
-      assert_same fmodel1, fmodel1a, "Second fring model in fringe_context came out different"
-      assert_not_nil fmodel1, "no fringe_model"
-      fview1 = fc["fringe_view"]
-      assert_not_nil fview1, "no fringe_view"
-      assert_same  core_model, fmodel1.connected
-    end
-
-    fmodel2 = nil
-    fview2 = nil
-    @diy.within('fringe_context') do |fc|
-      assert_not_nil fc["fringe_presenter"], "2: no fringe presenter"
-      fmodel2 = fc["fringe_model"]
-      fmodel2a = fc["fringe_model"]
-      assert_same fmodel2, fmodel2a, "Second fringe model in fringe_context came out different"
-      assert_not_nil fmodel2, "2: no fringe_model"
-      fview2 = fc["fringe_view"]
-      assert_not_nil fview2, "2: no fringe_view"
-      assert_same  core_model, fmodel2.connected
-
-      assert fmodel1.object_id != fmodel2.object_id, "fringe models 1 and 2 are same!"
-      assert fview1.object_id != fview2.object_id, "fringe views 1 and 2 are same!"
-    end
-  end
-
-  def test_sub_sub_context
-    load_context 'yak/sub_sub_context_test.yml'
-
-    core_model = @diy['core_model']
-    assert_not_nil core_model, "no core model in main context?"
-
-    fmodel1 = nil
-    fview1 = nil
-    @diy.within('fringe_context') do |fc|
-      assert_not_nil fc["fringe_presenter"], "no fringe presenter"
-      fmodel1 = fc["fringe_model"]
-      fmodel1a = fc["fringe_model"]
-      assert_same fmodel1, fmodel1a, "Second fring model in fringe_context came out different"
-      assert_not_nil fmodel1, "no fringe_model"
-      fview1 = fc["fringe_view"]
-      assert_not_nil fview1, "no fringe_view"
-      assert_same  core_model, fmodel1.connected
-
-      fc.within :deep_context do |dc|
-        krill = dc['krill']
-        assert_not_nil krill, "nil krill"
-        assert_same krill, dc['krill'], "krill was different second time"
-        giant_squid = dc['giant_squid']
-        assert_same fview1, giant_squid.fringe_view, "wrong view in squid"
-        assert_same core_model, giant_squid.core_model, "wrong model in squid"
-        assert_same krill, giant_squid.krill, "wrong krill in squid"
-      end
-    end
-
-  end
-
-  def test_build_everything
-    # Singletons in the goat context will generate test output in their constructors.
-    # We just gotta tell em where:
-    ofile = path_to_test_file('goat/output.tmp')
-    $goat_test_output_file = ofile
-
-    # Reusable setup for this test
-    prep_output = proc do 
-    remove ofile if File.exist?(ofile)
-  end
-
-  # Reusable assertion set and cleanup
-  examine_output = proc do
-    # Examine output file for expected construction
-    assert File.exist?(ofile), "no goat output created"
-    lines = File.readlines(ofile).map { |x| x.strip }
-    %w|can paper shirt goat|.each do |object|
-      assert lines.member?("#{object} built"), "Didn't see constructor output for #{object}"
-    end
-    assert_equal 4, lines.size, "wrong number of entries in output file"
-
-    # Make sure the subcontext was not built
-    assert !lines.member?("plane built"), "plane should not have been built -- it's in the subcontext"
-    assert !lines.member?("wings built"), "wings should not have been built -- it's in the subcontext"
-
-    # Check the objects in the context
-    %w|can paper shirt goat|.each do |object|
-      assert_same @diy[object], @diy[object], "Multiple accesses on #{object} yielded different refs"
-    end
-
-    # Try the subcontext
-    @diy.within('the_sub_context') do |tsc|
-      %w|plane wings|.each do |object|
-        assert_same tsc[object], tsc[object], "Multiple accesses on #{object} (in subcontext) yielded different refs"
-      end
-    end
-    # cleanup
-    remove ofile if File.exist?(ofile)
-  end
-
-  # Test all three methods
-  [:build_everything, :build_all, :preinstantiate_singletons].each do |method_name|
-    prep_output.call
-    load_context 'goat/objects.yml'
-    # go
-    @diy.send method_name
-    examine_output.call
-  end
-  ensure
-    # cleanup
-    remove ofile if File.exist?(ofile)
-  end
-
-  # See that the current object factory context can be referenced within the yaml
-  def test_this_context
-    load_context 'horse/objects.yml'
-
-    assert_same @diy, @diy['this_context'], "basic self-reference failed"
-    assert_same @diy, @diy['holder_thing'].thing_held, "composition self-reference failed"
-  end
-
-  def test_this_context_works_for_subcontexts
-    load_context 'horse/objects.yml'
-
-    @diy.within('repeater') do |ctx|
-      assert_same ctx, ctx['this_context'], "self-ref inside a subcontext doesn't work"
-    end
-  end
-
-  def test_multiple_classes_in_one_file
-    load_context 'fud/objects.yml'
-
-    toy = @diy['toy']
-    widget = @diy['widget']
-    thing = @diy['thing_ama_jack']
-    trinket = @diy['trinket']
-
-    assert_same widget, toy.widget, "wrong widget in toy"
-    assert_same trinket, toy.trinket, "wrong trinket in toy"
-    assert_same thing, trinket.thing_ama_jack, "wrong thing_ama_jack in trinket"
-  end
-
-  def test_objects_can_be_set_in_a_context_and_diy_will_not_attempt_to_build_it_as_a_dependency
-    load_context 'gnu/objects.yml'
-
-    injected = 'boom'
-    @diy[:injected] = injected
-    thinger = @diy[:thinger]
-    assert_not_nil thinger
-    assert_same injected, thinger.injected
-    assert_same injected, @diy[:injected]
-
-    inner_injected = 'slam'
-    @diy.within :inny  do |sub|
-      sub.set_object :inner_injected, inner_injected
-      inner_thinger = sub[:inner_thinger]
-      assert_not_nil inner_thinger
-      assert_same inner_injected, inner_thinger.injected
-      assert_same inner_injected, sub[:inner_injected]
-    end
-  end
-
-	def test_should_not_allow_setting_of_an_object_which_has_already_been_loaded
-    load_context 'gnu/objects.yml'
-
-    injected = 'boom'
-    @diy[:injected] = injected
-		err = assert_raise RuntimeError do
-			@diy[:injected] = injected
-		end
-		assert_match(/object 'injected' already exists/i, err.message)
-		assert_same injected, @diy[:injected]
-
-		thinger = @diy[:thinger]
-		err = assert_raise RuntimeError do
-			@diy[:thinger] = 'sdf'
-		end
-		assert_match(/object 'thinger' already exists/i, err.message)
-		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'
-
-    air = @diy['air']
-    assert_not_nil air, "No air"
-    assert_same air, @diy['air'], "Air should be a singleton"
-
-    yard = @diy['yard']
-    assert_not_nil yard, "No yard"
-    assert_same yard, @diy['yard'], "yard should be a singleton"
-
-    pig = @diy['pig']
-    assert_not_nil pig, "No pig"
-    assert_same pig, @diy['pig'], "Pig should be a singleton"
-
-    thread_spinner1 = @diy['thread_spinner']
-    assert_not_nil thread_spinner1, "Couldn't get thread spinner"
-    thread_spinner2 = @diy['thread_spinner']
-    assert_not_nil thread_spinner2, "Couldn't get second thread spinner"
-    assert thread_spinner1.object_id != thread_spinner2.object_id, "Thread spinners should be different instances"
-    thread_spinner3 = pig.thread_spinner
-    assert_not_nil thread_spinner3, "Didn't get a spinner from the pig"
-    assert thread_spinner2.object_id != thread_spinner3.object_id, "Thread spinner from pig should be different instance than the others"
-    assert thread_spinner1.object_id != thread_spinner3.object_id, "Thread spinner from pig should be different instance than the others"
-
-    assert_same air, thread_spinner1.air, "spinner 1 air should be singleton reference"
-    assert_same air, thread_spinner2.air, "spinner 2 air should be singleton reference"
-    assert_same air, thread_spinner3.air, "spinner 3 air should be singleton reference"
-  end
-
-  def test_should_handle_nonsingletons_in_sub_contexts
-    load_context 'non_singleton/objects.yml'
-
-    yard = @diy['yard']
-    assert_not_nil yard, "No yard"
-    assert_same yard, @diy['yard'], "yard should be a singleton"
-
-    thread_spinner1 = @diy['thread_spinner']
-    assert_not_nil thread_spinner1, "Couldn't get thread spinner"
-
-    air = @diy['air']
-    assert_not_nil air, "No air"
-    assert_same air, @diy['air'], "Air should be a singleton"
-
-    @diy.within :inner_sanctum do |sanct|
-      tick1 = sanct['tick']
-      assert_not_nil tick1, "Couldn't get tick1 from inner sanctum"
-      tick2 = sanct['tick']
-      assert_not_nil tick2, "Couldn't get tick2 from inner sanctum"
-      assert tick1.object_id != tick2.object_id, "Tick should not be a singleton"
-
-      cat = sanct['fat_cat']
-      assert_not_nil cat, "Couldn't get cat from sanctum"
-      assert_same cat, sanct['fat_cat'], "Cat SHOULD be singleton"
-
-      tick3 = cat.tick
-      assert_not_nil  tick3, "Couldn't get tick from cat"
-      assert tick1.object_id != tick3.object_id, "tick from cat matched an earlier tick; should not be so"
-      
-      assert_same yard, cat.yard, "Cat's yard should be same as other yard"
-      assert_not_nil cat.thread_spinner, "No thread spinner in cat?"
-
-      assert_same air, cat.thread_spinner.air, "spinner 1 air should be singleton reference"
-      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
-
-  def test_should_be_able_define_and_access_bounded_methods
-    load_context "functions/objects.yml"
-    @diy.build_everything
-    build_thing = @diy['build_thing']
-    
-    assert_not_nil build_thing, "should not be nil"
-    assert_kind_of(Method, build_thing)
-    assert_equal(build_thing, @diy['build_thing'])
-  end
-  
-  def test_bounded_method_can_be_used
-    load_context "functions/objects.yml"
-    @diy.build_everything
-    build_thing = @diy['build_thing']
-    
-    thing = build_thing["the name", "flying"]
-    
-    assert_equal("the name", thing.name)
-    assert_equal("flying", thing.ability)
-  end
-  
-  def test_building_bounded_method_uses_object_in_diy_context_correctly
-    load_context "functions/objects.yml"
-    @diy.build_everything
-    assert_equal(@diy['build_thing'], @diy['thing_builder'].method(:build))
-    
-    load_context "functions/nonsingleton_objects.yml"
-    @diy.build_everything
-    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
-      @diy.build_everything
-    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 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