needle 1.1.0 → 1.2.0

data/lib/needle/lifecycle/singleton.rb

@@ -35,11 +35,11 @@ module Needle
       # Returns the cached reference, if it has been previously cached.
       # Otherwise, invokes the next element in the pipeline and caches the
       # result. The cached reference is returned.
-      def call( *args )
+      def call( container, point )
         unless @is_cached
           @mutex.synchronize do
             unless @is_cached
-              @cached = succ.call( *args )
+              @cached = succ.call( container, point )
               @is_cached = true
             end
           end

data/lib/needle/lifecycle/threaded.rb

@@ -33,12 +33,12 @@ module Needle
       # Returns the cached reference, if it has been previously cached for
       # the current thread. Otherwise, invokes the next element in the pipeline
       # and caches the result. The cached reference is returned.
-      def call( *args )
+      def call( container, point )
         cache = service_cache
         name = service_point.fullname
 
         unless cache.has_key?( name )
-          service = succ.call( *args )
+          service = succ.call( container, point )
           cache[ name ] = service
         end
 
@@ -46,7 +46,8 @@ module Needle
       end
 
       # Resets the cached singleton instance, so that the next time it is
-      # requested it is re-constructed.
+      # requested it is re-constructed. Only the cache for the current thread
+      # and service point is reset.
       def reset!
         cache = service_cache
         cache.delete service_point.fullname

data/lib/needle/pipeline/collection.rb

@@ -20,7 +20,7 @@ module Needle
   module Pipeline
 
     # Represents a collection of pipeline elements. Elements may be added to
-    # the pipeline, and then returned as a single object representing thechain
+    # the pipeline, and then returned as a single object representing the chain
     # of pipeline elements.
     class Collection
 
@@ -105,6 +105,15 @@ module Needle
         @elements.find { |el| name == el.name }
       end
 
+      # Clears the state for each named element. If no elements are named, all
+      # elements are cleared.
+      def reset!( *args )
+        @elements.each do |element|
+          element.reset! if args.empty? || args.include?( element.name )
+        end
+        self
+      end
+
       # Builds a linked list of the elements, with the last element being the
       # block (or block-like) object given by the parameter. Higher-priority
       # elements will be closer to the head of the list.

data/lib/needle/pipeline/element.rb

@@ -78,6 +78,12 @@ module Needle
         raise NotImplementedError
       end
 
+      # Invoked by Pipeline::Collection#reset!. Subclasses of Element that
+      # save any kind of state should override this method to clear that
+      # state on demand.
+      def reset!
+      end
+
       alias :[] :call
     end
 

data/lib/needle/registry.rb

@@ -20,6 +20,7 @@ require 'needle/errors'
 require 'needle/interceptor'
 require 'needle/lifecycle/deferred'
 require 'needle/lifecycle/initialize'
+require 'needle/lifecycle/multiton'
 require 'needle/lifecycle/singleton'
 require 'needle/lifecycle/threaded'
 require 'needle/log-factory'
@@ -125,11 +126,16 @@ module Needle
         :initialize  => Needle::Lifecycle::Initialize,
         :deferred    => Needle::Lifecycle::Deferred,
         :interceptor => Needle::Pipeline::InterceptorElement,
+        :multiton    => Needle::Lifecycle::Multiton,
         :threaded    => Needle::Lifecycle::Threaded
       )
 
       register( :service_models, :pipeline=>[:singleton] ) { Hash.new }
       self[:service_models].update(
+        :multiton                      => [ :multiton ],
+        :multiton_initialize           => [ :multiton, :initialize ],
+        :multiton_deferred             => [ :multiton, :deferred ],
+        :multiton_deferred_initialize  => [ :multiton, :deferred, :initialize ],
         :prototype                     => [],
         :prototype_initialize          => [ :initialize ],
         :prototype_deferred            => [ :deferred ],
@@ -137,7 +143,7 @@ module Needle
         :singleton                     => [ :singleton ],
         :singleton_initialize          => [ :singleton, :initialize ],
         :singleton_deferred            => [ :singleton, :deferred ],
-        :singleton_deferred_initialize => [ :singleton, :deferred, :initialize ],
+        :singleton_deferred_initialize => [ :singleton, :deferred, :initialize],
         :threaded                      => [ :threaded ],
         :threaded_initialize           => [ :threaded, :initialize ],
         :threaded_deferred             => [ :threaded, :deferred ],
@@ -145,11 +151,18 @@ module Needle
       )
 
       register( :definition_context_factory ) { DefinitionContext }
-      register( :namespace_impl_factory ) { Container }
-      register( :interceptor_impl_factory ) { Interceptor }
 
-      register( :logs ) { LogFactory.new( opts[:logs] || {} ) }
-      register( :logging_interceptor ) { LoggingInterceptor }
+      define do |b|
+        b.namespace_impl_factory   { Container }
+        b.interceptor_impl_factory { Interceptor }
+
+        b.logs { LogFactory.new( opts[:logs] || {} ) }
+
+        # a parameterized version of c[:logs] for easier access
+        b.log_for( :model => :prototype ) { |c,p,name| c[:logs].get(name) }
+
+        b.logging_interceptor { LoggingInterceptor }
+      end
     end
     private :bootstrap
 

data/lib/needle/service-point.rb

@@ -20,7 +20,7 @@ require 'needle/thread'
 module Needle
 
   # A "service point" is a definition of a service. Just as a class defines the
-  # behavior of an object, so does a service point describes a service. In
+  # behavior of an object, so does a service point describe a service. In
   # particular, a service point also knows how to instantiate a service.
   #
   # A ServicePoint should never be directly instantiated. Instead, define
@@ -57,7 +57,9 @@ module Needle
       @callback = callback
       @pipeline = Needle::Pipeline::Collection.new self
       @chain = nil
-      @mutex = QueryableMutex.new
+
+      @chain_mutex = QueryableMutex.new
+      @element_mutex = QueryableMutex.new
 
       if opts[:pipeline]
         elements = opts[:pipeline]
@@ -66,6 +68,7 @@ module Needle
         elements = @container[:service_models][model]
       end
 
+      elements.concat [ *opts[:include] ] if opts[:include]
       elements.each { |element| @pipeline.add element, opts }
     end
 
@@ -84,26 +87,34 @@ module Needle
     # Adds the given interceptor definition to this service point. The
     # parameter should act like an instance of Interceptor.
     def interceptor( interceptor )
-      element = @pipeline.get( :interceptor )
-      unless element
-        @chain = nil
-        @pipeline.add( :interceptor )
+      @element_mutex.synchronize do
         element = @pipeline.get( :interceptor )
+        unless element
+          @pipeline.add( :interceptor )
+          element = @pipeline.get( :interceptor )
+        end
+        element.interceptors << interceptor
+        @pipeline.reset!
+        @chain = nil
       end
-      element.interceptors << interceptor
     end
 
     # Return the service instance represented by this service point. Depending
     # on the style of lifecycle management chosen for this service point, this
     # may or may not be a new instance for every invocation of this method.
-    def instance
+    #
+    # Any arguments to this method will be passed through to the chain, which
+    # may cause an error if there is an element in the pipeline that does not
+    # accept additional arguments. Regardless, the first two parameters to
+    # the chain will always be the container and the service point.
+    def instance( *args )
       unless @chain
-        @mutex.synchronize do
+        @chain_mutex.synchronize do
           @chain = @pipeline.chain_to( @callback ) unless @chain
         end
       end
 
-      @chain.call( @container, self )
+      @chain.call( @container, self, *args )
     end
 
   end

data/lib/needle/version.rb

@@ -18,7 +18,7 @@ module Needle
   module Version
 
     MAJOR = 1
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
     
     # The version of the Needle library in use.

data/test/lifecycle/tc_multiton.rb

@@ -0,0 +1,43 @@
+#--
+# =============================================================================
+# 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/lifecycle/multiton"
+require "test/unit"
+
+class TC_Lifecycle_Multiton < Test::Unit::TestCase
+
+  def test_multiplicity
+    element = Needle::Lifecycle::Multiton.new( nil )
+    element.succ = Proc.new { |c,p,x| "value: #{x}" }
+    p1 = element.call( nil, nil, :v )
+    p2 = element.call( nil, nil, :v )
+    assert_same p1, p2
+    p3 = element.call( nil, nil, :x )
+    assert_not_same p1, p3
+  end
+
+  def test_reset!
+    element = Needle::Lifecycle::Multiton.new( nil )
+    element.succ = Proc.new { |c,p,x| "value: #{x}" }
+    p1 = element.call( nil, nil, :v )
+    element.reset!
+    p2 = element.call( nil, nil, :v )
+    assert_not_same p1, p2
+  end
+
+end

data/test/lifecycle/tc_singleton.rb

@@ -24,9 +24,25 @@ class TC_Lifecycle_Singleton < Test::Unit::TestCase
   def test_multiplicity
     element = Needle::Lifecycle::Singleton.new( nil )
     element.succ = Proc.new { Hash.new }
-    p1 = element.call
-    p2 = element.call
+    p1 = element.call( nil, nil )
+    p2 = element.call( nil, nil )
     assert_same p1, p2
   end
 
+  def test_extra_args_disallowed
+    element = Needle::Lifecycle::Singleton.new( nil )
+    assert_raise( ArgumentError ) do
+      element.call( 1, 2, 3 )
+    end
+  end
+
+  def test_reset!
+    element = Needle::Lifecycle::Singleton.new( nil )
+    element.succ = Proc.new { Hash.new }
+    p1 = element.call( nil, nil )
+    element.reset!
+    p2 = element.call( nil, nil )
+    assert_not_same p1, p2
+  end
+
 end

data/test/lifecycle/tc_threaded.rb

@@ -29,19 +29,25 @@ class TC_Lifecycle_Threaded < Test::Unit::TestCase
   end
 
   def test_single_thread
-    @element.call
-    @element.call
-    @element.call
+    @element.call(1,2)
+    @element.call(1,2)
+    @element.call(1,2)
     assert_equal 1, @counter
   end
 
   def test_multi_thread
     threads = []
-    threads << Thread.new { @element.call }
-    threads << Thread.new { @element.call }
-    threads << Thread.new { @element.call }
+    threads << Thread.new { @element.call(1,2) }
+    threads << Thread.new { @element.call(1,2) }
+    threads << Thread.new { @element.call(1,2) }
     threads.each { |t| t.join }
     assert_equal 3, @counter
   end
 
+  def test_extra_args_disallowed
+    assert_raise( ArgumentError ) do
+      @element.call(1,2,3)
+    end
+  end
+
 end

data/test/pipeline/tc_collection.rb

@@ -27,9 +27,12 @@ class TC_Pipeline_Collection < Test::Unit::TestCase
     attr_reader :priority
     attr_accessor :succ
 
+    attr_reader :events
+
     def initialize( point, name, priority, options )
       @service_point = point
       @name, @priority = name, priority
+      @events = []
     end
 
     def call( *args )
@@ -41,11 +44,16 @@ class TC_Pipeline_Collection < Test::Unit::TestCase
     def <=>( element )
       priority <=> element.priority
     end
+
+    def reset!
+      @events << :reset!
+    end
   end
 
   def setup
-    elements = { :pipeline_elements => { :mock => MockElement } }
-    point = Struct.new( :container ).new( elements )
+    elements = Struct.new( :fullname, :pipeline_elements ).new(
+      "test", { :mock => MockElement, :mock2 => MockElement } )
+    point = Struct.new( :container, :fullname ).new( elements, "test" )
     @collection = Needle::Pipeline::Collection.new( point )
   end
 
@@ -113,4 +121,20 @@ class TC_Pipeline_Collection < Test::Unit::TestCase
     assert_equal b, "|proc|Mock|tail|Done|end"
   end
 
+  def test_reset_one!
+    @collection.add :mock, 25
+    @collection.add :mock2, 25
+    @collection.reset! :mock2
+    assert_equal [ :reset! ], @collection.get( :mock2 ).events
+    assert_equal [], @collection.get( :mock ).events
+  end
+
+  def test_reset!
+    @collection.add :mock, 25
+    @collection.add :mock2, 25
+    @collection.reset!
+    assert_equal [ :reset! ], @collection.get( :mock2 ).events
+    assert_equal [ :reset! ], @collection.get( :mock ).events
+  end
+
 end

data/test/services.rb

@@ -16,6 +16,14 @@ module A
       end
       module_function :register_other_services
 
+      def register_parameterized_services( container )
+        container.define do |b|
+          b.baz1 { |c,p,*args| args.join(":") }
+          b.baz2( :model=>:prototype ) { |c,p,*a| a.join(":") }
+        end
+      end
+      module_function :register_parameterized_services
+
     end
   end
 end

data/test/tc_container.rb

@@ -370,4 +370,86 @@ class TC_Container < Test::Unit::TestCase
     assert_equal CustomInterceptor, subspace.intercept( :logs ).class
   end
 
+  def test_descended_from?
+    outer = new_container
+    middle = new_container( outer )
+    inner = new_container( middle )
+    assert inner.descended_from?( outer )
+    assert inner.descended_from?( middle )
+    assert inner.descended_from?( inner )
+    assert !outer.descended_from?( inner )
+  end
+
+  def test_defaults_inherited
+    root = new_container
+    root.defaults[:hello] = :world
+    c1   = new_container( root )
+    assert_equal :world, c1.defaults[:hello]
+    root.defaults[:hello] = :jisang
+    assert_equal :world, c1.defaults[:hello]
+  end
+
+  def test_defaults_used
+    root = new_container
+    root.define.foo { Object.new }
+    root.defaults[:model] = :prototype
+    root.define.bar { Object.new }
+    f1 = root.foo
+    f2 = root.foo
+    assert_same f1, f2
+    b1 = root.bar
+    b2 = root.bar
+    assert_not_same b1, b2
+  end
+
+  def test_use_bang_without_block
+    root = new_container
+    original = root.use! :model => :prototype
+    assert original.empty?
+    o2 = root.use! :pipeline => [ :threaded ]
+    assert_nil root.defaults[:model]
+    assert_equal [ :threaded ], root.defaults[:pipeline]
+    root.use! o2
+    assert_nil root.defaults[:pipeline]
+    assert_equal :prototype, root.defaults[:model]
+  end
+
+  def test_use_bang_with_block
+    root = new_container
+    root.use! :model => :prototype do |r|
+      assert_same root, r
+      assert_equal :prototype, root.defaults[:model]
+      root.use! :pipeline => [ :threaded ] do
+        assert_nil root.defaults[:model]
+        assert_equal [ :threaded ], root.defaults[:pipeline]
+      end
+      assert_nil root.defaults[:pipeline]
+      assert_equal :prototype, root.defaults[:model]
+    end
+    assert_nil root.defaults[:model]
+  end
+
+  def test_use_without_block
+    root = new_container
+    o1 = root.use :model => :prototype
+    o2 = root.use :pipeline => [ :threaded ]
+    assert_equal :prototype, root.defaults[:model]
+    assert_equal [ :threaded ], root.defaults[:pipeline]
+  end
+
+  def test_use_with_block
+    root = new_container
+    root.use :model => :prototype do |r|
+      assert_same root, r
+      assert_equal :prototype, root.defaults[:model]
+      root.use :pipeline => [ :threaded ] do
+        assert_equal :prototype, root.defaults[:model]
+        assert_equal [ :threaded ], root.defaults[:pipeline]
+      end
+      assert_nil root.defaults[:pipeline]
+      assert_equal :prototype, root.defaults[:model]
+    end
+    assert_nil root.defaults[:model]
+  end
+
 end