needle 1.0.0 → 1.1.0

data/test/tc_container.rb

@@ -16,67 +16,73 @@
 
 $:.unshift "../lib"
 
-require 'needle/container'
-require 'needle/registry'
 require 'test/unit'
 
-class TC_Container < Test::Unit::TestCase
-
-  class TC_DefinitionContext < Test::Unit::TestCase
-    class MockContainer
-      attr_reader :events
-      def initialize; @events = []; end
-      def method_missing(s,*a,&b)
-        @events << { :name => s, :args => a, :block => b }
-      end
-    end
-
-    def setup
-      @container = MockContainer.new
-      @ctx = Needle::Container::DefinitionContext.new( @container )
-    end
-
-    def test_register
-      assert_nothing_raised do
-        @ctx.hello { "world" }
-      end
-      assert_equal :register, @container.events[0][:name]
-      assert_equal [ :hello ], @container.events[0][:args]
-      assert_not_nil @container.events[0][:block]
-    end
+require 'needle/container'
+require 'needle/definition-context'
+require 'needle/interceptor'
+require 'needle/lifecycle/deferred'
+require 'needle/lifecycle/initialize'
+require 'needle/lifecycle/singleton'
+require 'needle/lifecycle/threaded'
+require 'needle/log-factory'
+require 'needle/logging-interceptor'
+require 'needle/pipeline/interceptor'
 
-    def test_reference_bad
-      assert_raise( NoMethodError ) do
-        @ctx.hello( :arg )
-      end
-    end
+class TC_Container < Test::Unit::TestCase
 
-    def test_register_good
-      assert_nothing_raised do
-        @ctx.hello 
-      end
-      assert_equal :[], @container.events[0][:name]
-      assert_equal [ :hello ], @container.events[0][:args]
-      assert_nil @container.events[0][:block]
-    end
+  class CustomContainer < Needle::Container
+  end
 
-    def test_intercept
-      assert_nothing_raised do
-        @ctx.intercept( :foo )
-      end
-      assert_equal :intercept, @container.events[0][:name]
-      assert_equal [ :foo ], @container.events[0][:args]
-      assert_nil @container.events[0][:block]
-    end
+  class CustomBuilder < Needle::DefinitionContext
+  end
 
-    def test_this_container
-      assert_equal @container, @ctx.this_container
-    end
+  class CustomInterceptor < Needle::Interceptor
+  end
 
+  def new_container( *args )
+    container = Needle::Container.new( *args )
+
+    container.register( :pipeline_elements, :pipeline=>[] ) { Hash.new }
+    container.pipeline( :pipeline_elements ).add( :singleton,
+      Needle::Lifecycle::Singleton )
+
+    container[:pipeline_elements].update(
+      :singleton   => Needle::Lifecycle::Singleton,
+      :initialize  => Needle::Lifecycle::Initialize,
+      :deferred    => Needle::Lifecycle::Deferred,
+      :interceptor => Needle::Pipeline::InterceptorElement,
+      :threaded    => Needle::Lifecycle::Threaded
+    )
+
+    container.register( :service_models, :pipeline=>[:singleton] ) { Hash.new }
+    container[:service_models].update(
+      :prototype                     => [],
+      :prototype_initialize          => [ :initialize ],
+      :prototype_deferred            => [ :deferred ],
+      :prototype_deferred_initialize => [ :deferred, :initialize ],
+      :singleton                     => [ :singleton ],
+      :singleton_initialize          => [ :singleton, :initialize ],
+      :singleton_deferred            => [ :singleton, :deferred ],
+      :singleton_deferred_initialize => [ :singleton, :deferred, :initialize ],
+      :threaded                      => [ :threaded ],
+      :threaded_initialize           => [ :threaded, :initialize ],
+      :threaded_deferred             => [ :threaded, :deferred ],
+      :threaded_deferred_initialize  => [ :threaded, :deferred, :initialize ]
+    )
+
+    container.register( :definition_context_factory ) { Needle::DefinitionContext }
+    container.register( :namespace_impl_factory ) { Needle::Container }
+    container.register( :interceptor_impl_factory ) { Needle::Interceptor }
+
+    container.register( :logs ) { LogFactory.new( opts[:logs] || {} ) }
+    container.register( :logging_interceptor ) { Needle::LoggingInterceptor }
+
+    container
   end
 
   def test_default
-    container = Needle::Container.new
+    container = new_container
     assert_nil container.parent
     assert_nil container.name
     assert_equal container, container.root
@@ -84,7 +90,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_named
-    container = Needle::Container.new( nil, "name" )
+    container = new_container( nil, "name" )
     assert_nil container.parent
     assert_equal "name", container.name
     assert_equal container, container.root
@@ -92,36 +98,36 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_nested
-    outer = Needle::Container.new
-    inner = Needle::Container.new( outer )
+    outer = new_container
+    inner = new_container( outer )
     assert_same outer, inner.parent
     assert_equal outer, inner.root
   end
 
   def test_root
-    outer = Needle::Container.new
-    middle = Needle::Container.new( outer )
-    inner = Needle::Container.new( middle )
+    outer = new_container
+    middle = new_container( outer )
+    inner = new_container( middle )
     assert_same middle, inner.parent
     assert_equal outer, inner.root
   end
 
   def test_nested_named
-    outer = Needle::Container.new( nil, "outer" )
-    inner = Needle::Container.new( outer, "inner" )
+    outer = new_container( nil, "outer" )
+    inner = new_container( outer, "inner" )
     assert_equal "inner", inner.name
     assert_equal "outer.inner", inner.fullname
   end
 
   def test_service_not_found
-    container = Needle::Container.new
+    container = new_container
     assert_raise( Needle::ServiceNotFound ) do
       container[:test]
     end
   end
 
   def test_register
-    container = Needle::Container.new
+    container = new_container
     container.register( :test, :pipeline=>[] ) { Hash.new }
 
     assert_nothing_raised { container[:test] }
@@ -134,7 +140,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_builder
-    container = Needle::Container.new
+    container = new_container
     b1 = container.builder
     b2 = container.builder
 
@@ -142,7 +148,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_define_block
-    container = Needle::Container.new
+    container = new_container
 
     container.define do |b|
       b.test( :pipeline=>[] ) { Hash.new }
@@ -158,14 +164,14 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_define_noblock
-    container = Needle::Container.new
+    container = new_container
     container.define.test( :pipeline=>[] ) { Hash.new }
     assert container.has_key?( :test )
     assert_instance_of Hash, container.test
   end
 
   def test_define!
-    container = Needle::Container.new
+    container = new_container
 
     container.define! do
       test( :pipeline=>[] ) { Hash.new }
@@ -181,7 +187,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_namespace
-    container = Needle::Container.new
+    container = new_container
     container.namespace( :test, :pipeline=>[] )
     assert_instance_of Needle::Container, container.test
 
@@ -193,7 +199,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_namespace_define
-    container = Needle::Container.new
+    container = new_container
     container.namespace_define( :test, :pipeline=>[] ) do |b|
       b.item( :pipeline=>[] ) { Hash.new }
     end
@@ -202,7 +208,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_namespace_define!
-    container = Needle::Container.new
+    container = new_container
     container.namespace_define!( :test, :pipeline=>[] ) do
       item( :pipeline=>[] ) { Hash.new }
     end
@@ -211,7 +217,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_namespace!
-    container = Needle::Container.new
+    container = new_container
     container.namespace!( :test, :pipeline=>[] ) do
       item( :pipeline=>[] ) { Hash.new }
     end
@@ -220,7 +226,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_has_key
-    container = Needle::Container.new
+    container = new_container
 
     assert !container.has_key?(:test)
     container.register( :test, :pipeline=>[] ) { Hash.new }
@@ -228,7 +234,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_knows_key
-    container = Needle::Container.new
+    container = new_container
 
     assert !container.knows_key?(:test)
     container.register( :test, :pipeline=>[] ) { Hash.new }
@@ -236,8 +242,8 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_parent_knows_key
-    outer = Needle::Container.new
-    inner = Needle::Container.new( outer )
+    outer = new_container
+    inner = new_container( outer )
 
     outer.register( :test, :pipeline=>[] ) { Hash.new }
     assert !inner.has_key?(:test)
@@ -245,8 +251,8 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_service_in_parent
-    outer = Needle::Container.new
-    inner = Needle::Container.new( outer )
+    outer = new_container
+    inner = new_container( outer )
 
     outer.register( :test, :pipeline=>[] ) { Hash.new }
     assert_nothing_raised do
@@ -255,8 +261,8 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_service_not_in_parent
-    outer = Needle::Container.new
-    inner = Needle::Container.new( outer )
+    outer = new_container
+    inner = new_container( outer )
 
     assert_raise( Needle::ServiceNotFound ) do
       inner[:test]
@@ -264,14 +270,14 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_intercept_not_found
-    container = Needle::Container.new
+    container = new_container
     assert_raise( Needle::ServiceNotFound ) do
       container.intercept( :test )
     end
   end
 
   def test_intercept
-    container = Needle::Registry.new
+    container = new_container
     container.register( :test ) { Hash.new }
 
     filtered = false
@@ -284,25 +290,25 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_find_definition_missing
-    container = Needle::Container.new
+    container = new_container
     assert_nil container.find_definition( :bogus )
   end
 
   def test_find_definition_found_local
-    container = Needle::Container.new
+    container = new_container
     container.register( :test, :pipeline=>[] ) { Object.new }
     assert_not_nil container.find_definition( :test )
   end
 
   def test_find_definition_found_ancestor
-    outer = Needle::Container.new
-    inner = Needle::Container.new( outer )
+    outer = new_container
+    inner = new_container( outer )
     outer.register( :test, :pipeline=>[] ) { Object.new }
     assert_not_nil inner.find_definition( :test )
   end
 
   def test_pipeline
-    container = Needle::Container.new
+    container = new_container
     container.register( :test, :pipeline=>[] ) { Object.new }
     assert_instance_of Needle::Pipeline::Collection, container.pipeline( :test )
 
@@ -312,7 +318,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_require_default
-    container = Needle::Container.new
+    container = new_container
     container.register( :service_models, :pipeline=>[] ) { Hash[ :singleton => [] ] }
     container.require( "services", "A::B::C" )
     
@@ -321,7 +327,7 @@ class TC_Container < Test::Unit::TestCase
   end
 
   def test_require_custom
-    container = Needle::Container.new
+    container = new_container
     container.register( :service_models , :pipeline=>[] ) { Hash[ :singleton => [] ] }
     container.require( "services", "A::B::C", :register_other_services )
     
@@ -329,4 +335,39 @@ class TC_Container < Test::Unit::TestCase
     assert_not_nil container[:blah][:baz]
   end
 
+  def test_custom_namespace_impl
+    container = new_container
+    container.namespace :subspace
+
+    subspace = container.subspace
+    subspace.register( :namespace_impl_factory ) { CustomContainer }
+    subspace.namespace :custom_namespace
+    ns = subspace.custom_namespace
+
+    assert_instance_of Needle::Container, subspace
+    assert_instance_of CustomContainer, ns
+  end
+
+  def test_custom_builder_impl
+    container = new_container
+    container.namespace :subspace
+
+    subspace = container.subspace
+    subspace.register( :definition_context_factory ) { CustomBuilder }
+
+    assert_equal Needle::DefinitionContext, container.builder.class
+    assert_equal CustomBuilder, subspace.builder.class
+  end
+
+  def test_custom_interceptor_impl
+    container = new_container
+    container.namespace :subspace
+
+    subspace = container.subspace
+    subspace.register( :interceptor_impl_factory ) { CustomInterceptor }
+
+    assert_equal Needle::Interceptor, container.intercept( :logs ).class
+    assert_equal CustomInterceptor, subspace.intercept( :logs ).class
+  end
+
 end

data/test/tc_definition_context.rb

@@ -0,0 +1,75 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+#
+# This source file is distributed as part of the Needle dependency injection
+# library for Ruby. This file (and the library as a whole) may be used only as
+# allowed by either the BSD license, or the Ruby license (or, by association
+# with the Ruby license, the GPL). See the "doc" subdirectory of the Needle
+# distribution for the texts of these licenses.
+# -----------------------------------------------------------------------------
+# needle website : http://needle.rubyforge.org
+# project website: http://rubyforge.org/projects/needle
+# =============================================================================
+#++
+
+$:.unshift "../lib"
+
+require 'needle/definition-context'
+require 'needle/registry'
+require 'test/unit'
+
+class TC_DefinitionContext < Test::Unit::TestCase
+
+  class MockContainer
+    attr_reader :events
+    def initialize; @events = []; end
+    def method_missing(s,*a,&b)
+      @events << { :name => s, :args => a, :block => b }
+    end
+  end
+
+  def setup
+    @container = MockContainer.new
+    @ctx = Needle::DefinitionContext.new( @container )
+  end
+
+  def test_register
+    assert_nothing_raised do
+      @ctx.hello { "world" }
+    end
+    assert_equal :register, @container.events[0][:name]
+    assert_equal [ :hello ], @container.events[0][:args]
+    assert_not_nil @container.events[0][:block]
+  end
+
+  def test_reference_bad
+    assert_raise( NoMethodError ) do
+      @ctx.hello( :arg )
+    end
+  end
+
+  def test_register_good
+    assert_nothing_raised do
+      @ctx.hello 
+    end
+    assert_equal :[], @container.events[0][:name]
+    assert_equal [ :hello ], @container.events[0][:args]
+    assert_nil @container.events[0][:block]
+  end
+
+  def test_intercept
+    assert_nothing_raised do
+      @ctx.intercept( :foo )
+    end
+    assert_equal :intercept, @container.events[0][:name]
+    assert_equal [ :foo ], @container.events[0][:args]
+    assert_nil @container.events[0][:block]
+  end
+
+  def test_this_container
+    assert_equal @container, @ctx.this_container
+  end
+
+end

data/test/tc_registry.rb

@@ -86,4 +86,27 @@ class TC_Registry < Test::Unit::TestCase
     assert_nil @registry.fullname
   end
 
+  def test_nested_parent
+    inner = Needle::Registry.new( :parent => @registry )
+    assert_equal @registry, inner.parent
+  end
+
+  def test_explicit_name
+    reg = Needle::Registry.new( :name => :test )
+    assert_equal :test, reg.name
+    assert_nil reg.fullname
+  end
+
+  def test_nested_fullname
+    middle = Needle::Registry.new( :parent => @registry, :name => :middle )
+    inner = Needle::Registry.new( :parent => middle, :name => :test )
+    assert_equal "middle.test", inner.fullname
+  end
+
+  def test_bootstrap_once
+    inner = Needle::Registry.new( :parent => @registry )
+    assert inner.knows_key?( :pipeline_elements )
+    assert !inner.has_key?( :pipeline_elements )
+  end
+
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: needle
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2004-11-04
+  version: 1.1.0
+date: 2004-11-11
 summary: Needle is a Dependency Injection/Inversion of Control container for Ruby. It supports both type-2 (setter) and type-3 (constructor) injection. It takes advantage of the dynamic nature of Ruby to provide a rich and flexible approach to injecting dependencies.
 require_paths: 
   - lib
@@ -50,6 +50,7 @@ files:
   - doc/manual-html/chapter-6.html
   - doc/manual-html/chapter-7.html
   - doc/manual-html/chapter-8.html
+  - doc/manual-html/chapter-9.html
   - doc/manual-html/index.html
   - doc/images/di_classdiagram.jpg
   - doc/manual/manual.css
@@ -69,6 +70,7 @@ files:
   - doc/manual/parts/02_services.txt
   - doc/manual/parts/04_setup.txt
   - doc/manual/parts/01_alternatives.txt
+  - doc/manual/parts/customizing_contexts.txt
   - doc/manual/parts/04_overview.txt
   - doc/manual/parts/models_models.txt
   - doc/manual/parts/logging_overview.txt
@@ -81,8 +83,10 @@ files:
   - doc/manual/parts/01_license.txt
   - doc/manual/parts/01_use_cases.txt
   - doc/manual/parts/libraries_creating.txt
+  - doc/manual/parts/customizing_interceptors.txt
   - doc/manual/parts/02_overview.txt
   - doc/manual/parts/03_conventional.txt
+  - doc/manual/parts/customizing_namespaces.txt
   - doc/manual/parts/logging_configuration.txt
   - doc/manual/parts/interceptors_custom.txt
   - doc/manual/parts/libraries_overview.txt
@@ -104,6 +108,7 @@ files:
   - lib/needle/version.rb
   - lib/needle/log-factory.rb
   - lib/needle/errors.rb
+  - lib/needle/definition-context.rb
   - lib/needle/pipeline/interceptor.rb
   - lib/needle/pipeline/collection.rb
   - lib/needle/pipeline/element.rb
@@ -115,6 +120,7 @@ files:
   - test/tc_service_point.rb
   - test/tc_registry.rb
   - test/pipeline
+  - test/tc_definition_context.rb
   - test/tc_interceptor.rb
   - test/ALL-TESTS.rb
   - test/lifecycle