needle 0.5.0

data/test/models/tc_proxy.rb

@@ -0,0 +1,51 @@
+#--
+# =============================================================================
+# 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/models/proxy"
+require "test/unit"
+
+class TC_ModelsProxy < Test::Unit::TestCase
+
+  def test_fail
+    proxy = Needle::Models::Proxy.new( nil ) { Bogus.new }
+    assert_raise( NameError ) do
+      proxy.hello
+    end
+    assert_nothing_raised do
+      proxy.hello
+    end
+  end
+
+  def test_succeed
+    instantiated = false
+    proxy = Needle::Models::Proxy.new( nil ) { instantiated = true; Hash.new }
+    assert !instantiated
+    proxy[:test] = :value
+    assert instantiated
+    assert_equal :value, proxy[:test]
+  end
+
+  def test_container
+    proxy = Needle::Models::Proxy.new( :container ) do |c|
+      assert_equal :container, c
+      Hash.new
+    end
+    proxy[:test] = :value
+  end
+
+end

data/test/models/tc_singleton.rb

@@ -0,0 +1,53 @@
+#--
+# =============================================================================
+# 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/models/singleton"
+require "test/unit"
+
+class TC_ModelsSingleton < Test::Unit::TestCase
+
+  def test_instance
+    instantiated = false
+    model = Needle::Models::Singleton.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::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
+
+end

data/test/models/tc_singleton_deferred.rb

@@ -0,0 +1,54 @@
+#--
+# =============================================================================
+# 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/models/singleton-deferred"
+require "test/unit"
+
+class TC_ModelsSingletonDeferred < Test::Unit::TestCase
+
+  def test_instance
+    instantiated = false
+    model = Needle::Models::SingletonDeferred.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::SingletonDeferred.new( :container ) { |c|
+      assert_equal :container, c
+      Hash.new
+    }
+    model.instance[:test] = :value
+  end
+
+  def test_model
+    model = Needle::Models::SingletonDeferred.new( nil ) { Hash.new }
+    p1 = model.instance
+    p2 = model.instance
+    assert_same p1, p2
+  end
+
+end

data/test/tc_container.rb

@@ -0,0 +1,246 @@
+#--
+# =============================================================================
+# 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/container'
+require 'test/unit'
+
+class TC_Container < Test::Unit::TestCase
+
+  class TC_RegistrationContext < 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::RegistrationContext.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
+
+  end
+
+  class Model
+    def initialize( container, opts={}, &callback )
+      @container, @callback = container, callback
+      @inst = nil
+    end
+    def instance
+      return @inst if @inst
+      @inst = @callback.call( @container )
+    end
+  end
+
+  def test_default
+    container = Needle::Container.new
+    assert_nil container.parent
+    assert_nil container.name
+    assert_equal container, container.root
+    assert_equal "", container.fullname
+  end
+
+  def test_named
+    container = Needle::Container.new( nil, "name" )
+    assert_nil container.parent
+    assert_equal "name", container.name
+    assert_equal container, container.root
+    assert_equal "name", container.fullname
+  end
+
+  def test_nested
+    outer = Needle::Container.new
+    inner = Needle::Container.new( 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 )
+    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" )
+    assert_equal "inner", inner.name
+    assert_equal "outer.inner", inner.fullname
+  end
+
+  def test_service_not_found
+    container = Needle::Container.new
+    assert_raise( Needle::ServiceNotFound ) do
+      container[:test]
+    end
+  end
+
+  def test_register
+    container = Needle::Container.new
+    container.register( :test, :model=>Model ) { Hash.new }
+
+    assert_nothing_raised { container[:test] }
+    assert_nothing_raised { container.test }
+
+    assert_instance_of Hash, container[:test]
+    assert_instance_of Hash, container.test
+
+    assert container.respond_to?(:test)
+  end
+
+  def test_register!
+    container = Needle::Container.new
+
+    container.register! do
+      test( :model=>Model ) { Hash.new }
+      namespace :subitem, :model=>Model do
+        test2( :model=>Model ) { Hash.new }
+      end
+    end
+
+    assert container.has_key?( :test )
+    assert_instance_of Hash, container.test
+    assert container.subitem.has_key?( :test2 )
+    assert_instance_of Hash, container.subitem.test2
+  end
+
+  def test_namespace
+    container = Needle::Container.new
+    container.namespace( :test, :model=>Model )
+    assert_instance_of Needle::Container, container.test
+
+    container.namespace( :test2, :model=>Model ) do |ns|
+      assert_instance_of Needle::Container, ns
+    end
+
+    assert_instance_of Needle::Container, container.test2
+  end
+
+  def test_multi_namespace
+    container = Needle::Container.new
+    container.namespace( :test, :test2, :test3, :model=>Model )
+    assert_instance_of Needle::Container, container.test
+    assert_instance_of Needle::Container, container.test.test2
+    assert_instance_of Needle::Container, container.test.test2.test3
+
+    container.namespace( :test, :test2, :test3, :model=>Model ) do |ns|
+      assert_same ns, container.test.test2.test3
+    end
+  end
+
+  def test_has_key
+    container = Needle::Container.new
+
+    assert !container.has_key?(:test)
+    container.register( :test, :model=>Model ) { Hash.new }
+    assert container.has_key?(:test)
+  end
+
+  def test_knows_key
+    container = Needle::Container.new
+
+    assert !container.knows_key?(:test)
+    container.register( :test, :model=>Model ) { Hash.new }
+    assert container.knows_key?(:test)
+  end
+
+  def test_parent_knows_key
+    outer = Needle::Container.new
+    inner = Needle::Container.new( outer )
+
+    outer.register( :test, :model=>Model ) { Hash.new }
+    assert !inner.has_key?(:test)
+    assert inner.knows_key?(:test)
+  end
+
+  def test_service_in_parent
+    outer = Needle::Container.new
+    inner = Needle::Container.new( outer )
+
+    outer.register( :test, :model=>Model ) { Hash.new }
+    assert_nothing_raised do
+      inner[:test]
+    end
+  end
+
+  def test_service_not_in_parent
+    outer = Needle::Container.new
+    inner = Needle::Container.new( outer )
+
+    assert_raise( Needle::ServiceNotFound ) do
+      inner[:test]
+    end
+  end
+
+  def test_intercept_not_found
+    container = Needle::Container.new
+    assert_raise( Needle::ServiceNotFound ) do
+      container.intercept( :test )
+    end
+  end
+
+  def test_intercept
+    container = Needle::Container.new
+    container.register( :test, :model=>Model ) { Hash.new }
+
+    filtered = false
+    container.intercept( :test ).doing { |chain,ctx| filtered = true; chain.process_next(ctx) }
+
+    assert !filtered
+    svc = container.test
+    svc[:hello] = :world
+    assert filtered
+  end
+
+end

data/test/tc_interceptor.rb

@@ -0,0 +1,92 @@
+#--
+# =============================================================================
+# 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/interceptor'
+require 'test/unit'
+
+class TC_Interceptor < Test::Unit::TestCase
+
+  def test_empty
+    i = Needle::Interceptor.new
+    assert_equal [ :priority ], i.options.keys
+    assert_equal 0, i.options[:priority]
+  end
+
+  def test_missing_action
+    i = Needle::Interceptor.new
+
+    assert_raise( Needle::InterceptorConfigurationError ) do
+      i.action
+    end
+  end
+
+  def test_with_redefined
+    i = Needle::Interceptor.new
+
+    assert_raise( Needle::InterceptorConfigurationError ) do
+      i.with { :a }.with { :a }
+    end
+  end
+
+  def test_doing_redefined
+    i = Needle::Interceptor.new
+
+    assert_raise( Needle::InterceptorConfigurationError ) do
+      i.doing { :a }.doing { :a }
+    end
+  end
+
+  def test_with_doing
+    i = Needle::Interceptor.new
+
+    assert_raise( Needle::InterceptorConfigurationError ) do
+      i.with { :a }.doing { :a }
+    end
+  end
+
+  def test_doing_with
+    i = Needle::Interceptor.new
+
+    assert_raise( Needle::InterceptorConfigurationError ) do
+      i.doing { :a }.with { :a }
+    end
+  end
+
+  def test_options
+    i = Needle::Interceptor.new.
+      with_options(
+        :priority => 5,
+        :exclude => [ /^__/ ],
+        :include => [ /^__foo/ ] )
+
+    assert_equal 5, i[:priority]
+    assert_equal [ /^__/ ], i[:exclude]
+    assert_equal [ /^__foo/ ], i[:include]
+  end
+
+  def test_with
+    i = Needle::Interceptor.new.with { |c| Hash.new }
+    assert_instance_of Hash, i.action.call(nil)
+  end
+
+  def test_doing
+    i = Needle::Interceptor.new.doing { |ch,ctx| ch.process_next(ctx) }
+    assert_instance_of Needle::Interceptor::DynamicInterceptor, i.action.call(nil)
+  end
+
+end

data/test/tc_interceptor_chain.rb

@@ -0,0 +1,181 @@
+#--
+# =============================================================================
+# 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/interceptor-chain'
+require 'test/unit'
+require 'ostruct'
+
+class TC_InterceptorChainElement < Test::Unit::TestCase
+
+  class Interceptor
+    attr_reader :next_obj
+    attr_reader :context
+
+    def process( next_obj, context )
+      @next_obj = next_obj
+      @context = context
+    end
+  end
+
+  def test_process_next
+    interceptor = Interceptor.new
+    element =
+      Needle::InterceptorChainBuilder::InterceptorChainElement.new interceptor
+
+    element.next = :next_obj
+    element.process_next :context
+
+    assert_equal :next_obj, interceptor.next_obj
+    assert_equal :context, interceptor.context
+  end
+
+end
+
+class TC_ProxyObjectChainElement < Test::Unit::TestCase
+
+  Context = Struct.new( :sym, :args, :block )
+
+  class ProxyObject
+    attr_reader :args
+    attr_reader :value
+
+    def invoke( *args, &block )
+      @args = args
+      @value = block.call
+    end
+  end
+
+  def test_process_next
+    obj = ProxyObject.new
+    element = Needle::InterceptorChainBuilder::ProxyObjectChainElement.new obj
+    ctx = Context.new( :invoke, [ 1, 2, 3 ], proc { "value" } )
+    element.process_next( ctx )
+
+    assert_equal [ 1, 2, 3 ], obj.args
+    assert_equal "value", obj.value
+  end
+
+end
+
+class TC_InterceptorChainBuilder < Test::Unit::TestCase
+
+  class Interceptor
+    def initialize( point, opts, name=nil )
+      @opts = opts
+      @name = name
+    end
+
+    def process( chain, context )
+      @opts[:hash][:chain] << @opts[:name]
+      @opts[:hash][:sym] = context.sym
+      @opts[:hash][:args] = context.args.length
+      @opts[:hash][:has_block] = !context.block.nil?
+      chain.process_next( context )
+    end
+  end
+
+  def setup
+    @point = OpenStruct.new
+  end
+
+  def test_nil
+    service = Object.new
+    service2 = Needle::InterceptorChainBuilder.build( @point, service, nil )
+    assert_same service, service2
+  end
+
+  def test_none
+    service = Object.new
+    service2 = Needle::InterceptorChainBuilder.build( @point, service, [] )
+    assert_same service, service2
+  end
+
+  def test_one
+    service = Hash.new
+    data = { :chain=>[] }
+    interceptors = [
+      OpenStruct.new( :action=>proc { Interceptor },
+        :options=> { :hash=>data } )
+    ]
+
+    service2 = Needle::InterceptorChainBuilder.build( @point, service, interceptors )
+
+    assert_instance_of(
+      Needle::InterceptorChainBuilder::InterceptedServiceProxy, service2 )
+
+    service2.length
+    assert_equal :length, data[:sym]
+    assert_equal 0, data[:args]
+    assert !data[:has_block]
+
+    service2[:hello] = :something
+    assert_equal :[]=, data[:sym]
+    assert_equal 2, data[:args]
+    assert !data[:has_block]
+
+    service2.each_key { |k| }
+    assert_equal :each_key, data[:sym]
+    assert_equal 0, data[:args]
+    assert data[:has_block]
+  end
+
+  def test_many
+    service = Hash.new
+    chain = []
+    data = Array.new( 4 ) { { :chain=>chain } }
+    interceptors = [
+      OpenStruct.new( :action=>proc { Interceptor },
+        :options=>{ :hash=>data[0], :priority=>5, :name=>"A" } ),
+      OpenStruct.new( :action=>proc { Interceptor },
+        :options=>{ :hash=>data[1], :priority=>3, :name=>"B" } ),
+      OpenStruct.new( :action=>proc { Interceptor },
+        :options=>{ :hash=>data[2], :priority=>7, :name=>"C" } ),
+      OpenStruct.new( :action=>proc { Interceptor },
+        :options=>{ :hash=>data[3], :priority=>5, :name=>"D" } )
+    ]
+
+    service2 = Needle::InterceptorChainBuilder.build( @point, service, interceptors )
+    expect_chain = [ "B", "A", "D", "C" ]
+
+    service2.length
+    4.times do |i|
+      assert_equal :length, data[i][:sym]
+      assert_equal 0, data[i][:args]
+      assert !data[i][:has_block]
+    end
+    assert_equal expect_chain, chain
+    chain.clear
+
+    service2[:hello] = :something
+    4.times do |i|
+      assert_equal :[]=, data[i][:sym]
+      assert_equal 2, data[i][:args]
+      assert !data[i][:has_block]
+    end
+    assert_equal expect_chain, chain
+    chain.clear
+
+    service2.each_key { |k| }
+    4.times do |i|
+      assert_equal :each_key, data[i][:sym]
+      assert_equal 0, data[i][:args]
+      assert data[i][:has_block]
+    end
+    assert_equal expect_chain, chain
+  end
+end