needle 0.5.0 → 0.6.0

data/lib/needle/thread.rb

@@ -0,0 +1,87 @@
+#--
+# =============================================================================
+# 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
+# =============================================================================
+#++
+
+require 'thread'
+
+module Needle
+
+  # A subclass of Mutex that allows clients to discover which thread has the
+  # mutex locked. This is necessary for (among other things) discovering
+  # cycles in the dependency graph of services.
+  class QueryableMutex < Mutex
+
+    # Checks to see if the current thread has the mutex locked, and if it
+    # does, raises an exception. Otherwise, locks the mutex and sets the
+    # locking thread to Thread.current.
+    def lock
+      if @locking_thread == Thread.current
+        raise ThreadError,
+          "an attempt was made to reacquire an existing lock " +
+          "(this could happen if you have a circular dependency on a service)"
+      end
+
+      while (Thread.critical = true; @locked)
+        @waiting.push Thread.current
+        Thread.stop
+      end
+      @locked = true
+      @locking_thread = Thread.current
+      Thread.critical = false
+      self
+    end
+
+    # Attempts to acquire the lock. Returns +true+ if the lock was acquired,
+    # and +false+ if the mutex was already locked.
+    def try_lock
+      result = false
+      Thread.critical = true
+      unless @locked
+        @locked = true
+        result = true
+        @locking_thread = Thread.current
+      end
+      Thread.critical = false
+      result
+    end
+    
+    # Unlocks the mutex and sets the locking thread to +nil+.
+    def unlock
+      return unless @locked
+      Thread.critical = true
+      @locked = false
+      begin
+        t = @waiting.shift
+        t.wakeup if t
+      rescue ThreadError
+        retry
+      end
+      @locking_thread = nil
+      Thread.critical = false
+      begin
+        t.run if t
+      rescue ThreadError
+      end
+      self
+    end
+
+    # Return +true+ if the current thread has locked this mutex.
+    def self_locked?
+      @locking_thread == Thread.current
+    end
+
+  end
+
+end

data/lib/needle/version.rb

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

data/{lib/needle/models/prototype.rb → test/lifecycle/tc_deferred.rb}

@@ -14,26 +14,24 @@
 # =============================================================================
 #++
 
-module Needle
-  module Models
+$:.unshift "../../lib"
 
-    # The definition of the "prototype" lifecycle service model. This will
-    # result in immediate instantiation of the requested service, with a new
-    # instance being returned every time #instance is invoked.
-    class Prototype
+require "needle/lifecycle/deferred"
+require "test/unit"
 
-      # Create a new instance of the Prototype service model.
-      def initialize( container, opts={}, &callback )
-        @container = container
-        @callback = callback
-      end
+class TC_Lifecycle_Deferred < Test::Unit::TestCase
 
-      # Invoke the callback that was given when the service model was
-      # instantiated, passing the service model's container reference.
-      def instance
-        @callback.call( @container )
-      end
-    end
+  def test_instantiability
+    instantiated = false
+    element = Needle::Lifecycle::Deferred.new( nil )
+    element.succ = Proc.new { instantiated = true; Hash.new }
 
+    assert !instantiated
+    proto = element.call
+    assert !instantiated
+    proto[:test] = :value
+    assert instantiated
+    assert_equal :value, proto[:test]
   end
+
 end

data/test/lifecycle/tc_initialize.rb

@@ -0,0 +1,62 @@
+#--
+# =============================================================================
+# 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/initialize"
+require "test/unit"
+
+class TC_Lifecycle_Initialize < Test::Unit::TestCase
+
+  class MockNoInit
+  end
+
+  class MockInit
+    attr_reader :value
+
+    def initialize_service
+      @value = :initialize
+    end
+
+    def custom_init
+      @value = :custom
+    end
+  end
+
+  def test_no_initialize
+    element = Needle::Lifecycle::Initialize.new( nil )
+    element.succ = Proc.new { MockNoInit.new }
+    result = nil
+    assert_nothing_raised { result = element.call }
+    assert_instance_of MockNoInit, result
+  end
+
+  def test_initialize
+    element = Needle::Lifecycle::Initialize.new( nil )
+    element.succ = Proc.new { MockInit.new }
+    result = element.call
+    assert_equal :initialize, result.value
+  end
+
+  def test_custom_initialize
+    element = Needle::Lifecycle::Initialize.new( nil, nil, nil,
+      :init_method => :custom_init )
+    element.succ = Proc.new { MockInit.new }
+    result = element.call
+    assert_equal :custom, result.value
+  end
+
+end

data/test/{models → lifecycle}/tc_proxy.rb

@@ -16,13 +16,13 @@
 
 $:.unshift "../../lib"
 
-require "needle/models/proxy"
+require "needle/lifecycle/proxy"
 require "test/unit"
 
-class TC_ModelsProxy < Test::Unit::TestCase
+class TC_LifecycleProxy < Test::Unit::TestCase
 
   def test_fail
-    proxy = Needle::Models::Proxy.new( nil ) { Bogus.new }
+    proxy = Needle::Lifecycle::Proxy.new( nil ) { Bogus.new }
     assert_raise( NameError ) do
       proxy.hello
     end
@@ -33,7 +33,7 @@ class TC_ModelsProxy < Test::Unit::TestCase
 
   def test_succeed
     instantiated = false
-    proxy = Needle::Models::Proxy.new( nil ) { instantiated = true; Hash.new }
+    proxy = Needle::Lifecycle::Proxy.new( nil ) { instantiated = true; Hash.new }
     assert !instantiated
     proxy[:test] = :value
     assert instantiated
@@ -41,7 +41,7 @@ class TC_ModelsProxy < Test::Unit::TestCase
   end
 
   def test_container
-    proxy = Needle::Models::Proxy.new( :container ) do |c|
+    proxy = Needle::Lifecycle::Proxy.new( nil, :container ) do |c|
       assert_equal :container, c
       Hash.new
     end

data/test/lifecycle/tc_singleton.rb

@@ -0,0 +1,32 @@
+#--
+# =============================================================================
+# 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/singleton"
+require "test/unit"
+
+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
+    assert_same p1, p2
+  end
+
+end

data/{lib/needle/models/prototype-deferred.rb → test/lifecycle/tc_threaded.rb}

@@ -14,28 +14,34 @@
 # =============================================================================
 #++
 
-require 'needle/models/proxy'
+$:.unshift "../../lib"
 
-module Needle
-  module Models
+require "needle/lifecycle/threaded"
+require "test/unit"
 
-    # The definition of the "prototype-deferred" lifecycle service model.
-    # This will result in deferred instantiation of the requested service,
-    # with a new instance being returned every time #instance is invoked.
-    class PrototypeDeferred
+class TC_Lifecycle_Threaded < Test::Unit::TestCase
 
-      # Create a new PrototypeDeferred service model.
-      def initialize( container, opts={}, &callback )
-        @container = container
-        @callback = callback
-      end
+  def setup
+    mock = Struct.new( :fullname ).new( "test" )
+    @counter = 0
+    @element = Needle::Lifecycle::Threaded.new( mock )
+    @element.succ = Proc.new { @counter += 1 }
+  end
 
-      # Return a new Proxy instance that wraps the container and callback
-      # references given when the service model was instantiated.
-      def instance
-        Proxy.new( @container, &@callback )
-      end
-    end
+  def test_single_thread
+    @element.call
+    @element.call
+    @element.call
+    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.each { |t| t.join }
+    assert_equal 3, @counter
   end
+
 end

data/test/models/model_test.rb

@@ -0,0 +1,131 @@
+#--
+# =============================================================================
+# 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"
+require "test/unit"
+
+class ModelTest_MockService
+  attr_reader :init_result
+
+  def initialize
+    @init_result = :none
+  end
+
+  def initialize_service
+    @init_result = :initialized
+  end
+
+end
+
+module ModelTest
+
+  def self.append_features( base )
+    super
+    base.extend ClassFeatures
+  end
+
+  module ClassFeatures
+    attr_reader :model
+
+    def use( model )
+      @model = model
+    end
+
+    def assert_prototype
+      define_method( :test_multiplicity ) do
+        o1 = @registry[ :test ]
+        o2 = @registry[ :test ]
+        assert_not_same o1, o2
+      end
+    end
+
+    def assert_singleton
+      define_method( :test_multiplicity ) do
+        o1 = @registry[ :test ]
+        o2 = @registry[ :test ]
+        assert_same o1, o2
+      end
+    end
+
+    def assert_threaded
+      define_method( :extra_setup ) do
+        cache = Thread.current[:threaded_services]
+        cache.delete "[].test" if cache
+      end
+
+      define_method( :test_multiplicity_singlethread ) do
+        @registry[ :test ].init_result
+        @registry[ :test ].init_result
+        @registry[ :test ].init_result
+        assert_equal 1, @count 
+      end
+
+      define_method( :test_multiplicity_multithread ) do
+        threads = []
+        threads << Thread.new { @registry[ :test ].init_result }
+        threads << Thread.new { @registry[ :test ].init_result }
+        threads << Thread.new { @registry[ :test ].init_result }
+        threads.each { |t| t.join }
+        assert_equal 3, @count 
+      end
+    end
+
+    def assert_immediate
+      define_method( :test_laziness ) do
+        @registry[ :test ]
+        assert_equal 1, @count 
+      end
+    end
+
+    def assert_deferred
+      define_method( :test_laziness ) do
+        o = @registry[ :test ]
+        assert_equal 0, @count
+        o.init_result
+        assert_equal 1, @count
+      end
+    end
+
+    def assert_no_init
+      define_method( :test_initialize ) do
+        o = @registry[ :test ]
+        assert_equal :none, o.init_result
+      end
+    end
+
+    def assert_init
+      define_method( :test_initialize ) do
+        o = @registry[ :test ]
+        assert_equal :initialized, o.init_result
+      end
+    end
+  end
+
+  def setup
+    @count = 0
+    @registry = Needle::Registry.new do |r|
+      r.register :test, :model => self.class.model do 
+        @count += 1
+        ModelTest_MockService.new
+      end
+    end
+
+    extra_setup if respond_to?( :extra_setup )
+  end
+
+end

data/test/models/tc_prototype.rb

@@ -16,38 +16,17 @@
 
 $:.unshift "../../lib"
 
-require "needle/models/prototype"
+require "needle"
 require "test/unit"
+require File.join( File.dirname( __FILE__ ), "model_test" )
 
-class TC_ModelsPrototype < Test::Unit::TestCase
+class TC_Model_Prototype < Test::Unit::TestCase
+  include ModelTest
 
-  def test_instance
-    instantiated = false
-    model = Needle::Models::Prototype.new( nil ) { 
-      instantiated = true
-      Hash.new
-    }
-
-    assert !instantiated
-    proto = model.instance
-    assert instantiated
-    proto[:test] = :value
-    assert_equal :value, proto[:test]
-  end
-
-  def test_container
-    model = Needle::Models::Prototype.new( :container ) { |c|
-      assert_equal :container, c
-      Hash.new
-    }
-    model.instance
-  end
-
-  def test_model
-    model = Needle::Models::Prototype.new( nil ) { Hash.new }
-    p1 = model.instance
-    p2 = model.instance
-    assert_not_same p1, p2
-  end
+  use :prototype
 
+  assert_prototype
+  assert_immediate
+  assert_no_init
+  
 end

data/test/models/tc_prototype_deferred.rb

@@ -16,39 +16,17 @@
 
 $:.unshift "../../lib"
 
-require "needle/models/prototype-deferred"
+require "needle"
 require "test/unit"
+require File.join( File.dirname( __FILE__ ), "model_test" )
 
-class TC_ModelsPrototypeDeferred < Test::Unit::TestCase
+class TC_Model_Prototype_Deferred < Test::Unit::TestCase
+  include ModelTest
 
-  def test_instance
-    instantiated = false
-    model = Needle::Models::PrototypeDeferred.new( nil ) { 
-      instantiated = true
-      Hash.new
-    }
-
-    assert !instantiated
-    proto = model.instance
-    assert !instantiated
-    proto[:test] = :value
-    assert instantiated
-    assert_equal :value, proto[:test]
-  end
-
-  def test_container
-    model = Needle::Models::PrototypeDeferred.new( :container ) { |c|
-      assert_equal :container, c
-      Hash.new
-    }
-    model.instance[:test] = :value
-  end
-
-  def test_model
-    model = Needle::Models::PrototypeDeferred.new( nil ) { Hash.new }
-    p1 = model.instance
-    p2 = model.instance
-    assert_not_same p1, p2
-  end
+  use :prototype_deferred
 
+  assert_prototype
+  assert_deferred
+  assert_no_init
+  
 end

data/test/models/tc_prototype_deferred_initialize.rb

@@ -0,0 +1,32 @@
+#--
+# =============================================================================
+# 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"
+require "test/unit"
+require File.join( File.dirname( __FILE__ ), "model_test" )
+
+class TC_Model_Prototype_Deferred_Initialize < Test::Unit::TestCase
+  include ModelTest
+
+  use :prototype_deferred_initialize
+
+  assert_prototype
+  assert_deferred
+  assert_init
+  
+end

data/test/models/tc_prototype_initialize.rb

@@ -0,0 +1,32 @@
+#--
+# =============================================================================
+# 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"
+require "test/unit"
+require File.join( File.dirname( __FILE__ ), "model_test" )
+
+class TC_Model_Prototype_Initialize < Test::Unit::TestCase
+  include ModelTest
+
+  use :prototype_initialize
+
+  assert_prototype
+  assert_immediate
+  assert_init
+  
+end

data/test/models/tc_singleton.rb

@@ -16,38 +16,17 @@
 
 $:.unshift "../../lib"
 
-require "needle/models/singleton"
+require "needle"
 require "test/unit"
+require File.join( File.dirname( __FILE__ ), "model_test" )
 
-class TC_ModelsSingleton < Test::Unit::TestCase
+class TC_Model_Singleton < Test::Unit::TestCase
+  include ModelTest
 
-  def test_instance
-    instantiated = false
-    model = Needle::Models::Singleton.new( nil ) { 
-      instantiated = true
-      Hash.new
-    }
+  use :singleton
 
-    assert !instantiated
-    proto = model.instance
-    assert instantiated
-    proto[:test] = :value
-    assert_equal :value, proto[:test]
-  end
-
-  def test_container
-    model = Needle::Models::Singleton.new( :container ) { |c|
-      assert_equal :container, c
-      Hash.new
-    }
-    model.instance
-  end
-
-  def test_model
-    model = Needle::Models::Singleton.new( nil ) { Hash.new }
-    p1 = model.instance
-    p2 = model.instance
-    assert_same p1, p2
-  end
+  assert_singleton
+  assert_immediate
+  assert_no_init
 
 end