needle-extras 1.0.0

data/lib/needle/extras.rb

@@ -0,0 +1,17 @@
+require 'needle/extras/require-library'
+
+module Needle
+  module Extras
+
+    def register_services( container )
+      container.define do |b|
+        b.require 'needle/extras/attr-inject', 'Needle::Extras::AttrInject'
+        b.require 'needle/extras/multicast',   'Needle::Extras::Multicast'
+      end
+    end
+    module_function :register_services
+
+  end
+
+  register_library "needle/extras", Needle::Extras
+end

data/lib/needle/extras/attr-inject.rb

@@ -0,0 +1,73 @@
+require 'needle/pipeline/element'
+
+class Class
+
+  # Add a hook for declaring properties of an object that should be injected
+  # into instances of this class. See Object#inject_attributes.
+  def attr_inject( *properties )
+    ( @injectable_attributes ||= [] ).concat properties.map { |p| p.to_sym }
+  end
+  private :attr_inject
+
+  # Returns an array of attributes of the class that have been declared to
+  # be injectable. See #attr_inject and Object#inject_attributes.
+  def injectable_attributes
+    if defined?(@injectable_attributes)
+      @injectable_attributes
+    else
+      []
+    end
+  end
+
+end
+
+class Object
+
+  # Injects all injectable attributes of the instance's class with the
+  # corresponding services from the given container. Each attribute is
+  # injected into an identically named instance variable of the object,
+  # from an identically named service in the container.
+  #
+  # This returns the object itself.
+  def inject_attributes( container )
+    self.class.injectable_attributes.each do |attribute|
+      instance_variable_set "@#{attribute}", container.get( attribute )
+    end
+    self
+  end
+
+end
+
+module Needle
+  module Extras
+    module AttrInject
+
+      # A specialized pipeline element that injects the constructed service
+      # with dependent services from the point's container.
+      class InjectorElement < Needle::Pipeline::Element
+        set_default_priority 0
+        
+        def call( *args )
+          succ.
+            call( *args ).
+            inject_attributes( service_point.container )
+        end
+
+      end
+
+      # Registers the InjectorElement pipeline element, and adds some new
+      # service models (multiton_inject, prototype_inject, and
+      # singleton_inject).
+      def register_services( container )
+        container.pipeline_elements[ :attr_inject ] = InjectorElement
+        container.service_models.update(
+          :multiton_inject  => [ :multiton, :attr_inject ],
+          :prototype_inject => [ :attr_injector ],
+          :singleton_inject => [ :singleton, :attr_inject ]
+        )
+      end
+      module_function :register_services
+
+    end
+  end
+end

data/lib/needle/extras/multicast.rb

@@ -0,0 +1,42 @@
+module Needle
+  module Extras
+    module Multicast
+
+      # A proxy that wraps an array of other objects. Whenever a message
+      # is received by this proxy, it delegates the call to the objects in the
+      # array.
+      class Target
+
+        # Creates a new Target object that acts as a proxy for the given list
+        # of delegates.
+        def initialize( *delegates )
+          @delegates = delegates
+        end
+
+        # Forwards the method to each object in the array. It does no checking
+        # to ensure that the receiver can understand the message before sending
+        # it. This will return an array of the results of calling each of the
+        # other messages.
+        def method_missing( sym, *args, &block )
+          @delegates.inject( [] ) do |a,d|
+            a << d.__send__( sym, *args, &block )
+          end
+        end
+
+      end
+
+      # Register the multicast factory service in the given container. The
+      # multicast service is a parameterized service which accepts a single
+      # parameter--an array of the targets to apply to the multicaster. It
+      # will then return an instance of a multicast service.
+      def register_services( container )
+        container.define.multicast :model => :prototype do |c,p,*targets|
+          Multicast::Target.new( *targets )
+        end
+      end
+      module_function :register_services
+
+    end
+  end
+end
+

data/lib/needle/extras/require-library.rb

@@ -0,0 +1,34 @@
+require 'needle/container'
+
+module Needle
+
+  # This constant represents the collection of registered libraries. Each
+  # value in it must respond to the #call method, accepting a single
+  # parameter (the container to register the library with).
+  LIBRARIES = Hash.new
+
+  class Container
+
+    # Require the library registered under the given name. A Kernel.require
+    # is done on the name, and then if a library has been registered under
+    # that name, its #call method is invoked with the container as the
+    # parameter.
+    def require_library( name )
+      Kernel.require name
+      LIBRARIES[ name ].call( self ) if LIBRARIES[ name ]
+    end
+
+  end
+
+  # A convenience method for registering libraries with the "require-library"
+  # subsystem. +name+ must correspond to a file to require with Kernel.require.
+  # +mod+ is a module containing the registration method named by the
+  # +registration_method+ parameter (defaulting to <tt>:register_library</tt>).
+  def register_library( name, mod, registration_method=:register_services )
+    LIBRARIES[ name ] = lambda do |container|
+      mod.__send__( registration_method, container )
+    end
+  end
+  module_function :register_library
+
+end

data/lib/needle/extras/version.rb

@@ -0,0 +1,13 @@
+module Needle
+  module Extras
+    module Version
+
+      MAJOR = 1
+      MINOR = 0
+      TINY  = 0
+
+      STRING = [MAJOR,MINOR,TINY].join('.')
+
+    end
+  end
+end

data/test/ALL-TESTS.rb

@@ -0,0 +1,9 @@
+$:.unshift "../lib"
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+Dir.chdir File.dirname(__FILE__)
+Dir["**/tc_*.rb"].each { |file| load file }

data/test/tc_attr-inject.rb

@@ -0,0 +1,115 @@
+$:.unshift "../lib"
+
+require 'test/unit'
+require 'needle'
+require 'needle/extras/attr-inject'
+
+class TC_AttrInject_Class < Test::Unit::TestCase
+
+  def test_attr_inject
+    assert_nothing_raised do
+      Class.new do
+        attr_inject :foo
+        attr_inject :bar, :baz
+        attr_inject "test"
+      end
+    end
+  end
+
+  def test_injectable_attributes
+    klass = Class.new do
+      attr_inject :foo
+      attr_inject :bar, :baz
+      attr_inject "test"
+    end
+    assert_equal [ :foo, :bar, :baz, :test ], klass.injectable_attributes
+  end
+
+end
+
+
+class AttrInject_MockContainer
+  def get( attribute )
+    attribute
+  end
+end
+
+
+class TC_AttrInject_Object < Test::Unit::TestCase
+
+  def test_inject_attributes
+    klass = Class.new { attr_inject :foo, :bar }
+    obj = klass.new.inject_attributes( AttrInject_MockContainer.new )
+    assert_equal :foo, obj.instance_variable_get( "@foo" )
+    assert_equal :bar, obj.instance_variable_get( "@bar" )
+  end
+
+end
+
+
+class TC_AttrInject_InjectorElement < Test::Unit::TestCase
+
+  def setup
+    point = Class.new do
+      attr_reader :container
+      def initialize( c ); @container = c; end
+    end.new( AttrInject_MockContainer.new )
+
+    klass = Class.new { attr_inject :foo, :bar }
+
+    @element = Needle::Extras::AttrInject::InjectorElement.new( point )
+    @element.succ = proc { klass.new }
+  end
+
+  def test_default_priority
+    assert_equal 0, @element.priority
+  end
+
+  def test_call_multiargs
+    assert_nothing_raised do
+      @element.call( 1, 2, 3 )
+    end
+  end
+
+  def test_call
+    obj = @element.call( 1, 2, 3 )
+    assert_equal :foo, obj.instance_variable_get( "@foo" )
+    assert_equal :bar, obj.instance_variable_get( "@bar" )
+  end
+
+end
+
+
+class TC_AttrInject_Services < Test::Unit::TestCase
+
+  def setup
+    @reg = Needle::Registry.new
+    Needle::Extras::AttrInject.register_services( @reg )
+    @reg.register( :foo ) { "foo is wizard!" }
+    @reg.register( :bar ) { "bar is teh bomb!" }
+  end
+
+  def test_no_inject
+    @reg.register( :hit_me, :model => :singleton_inject ) do
+      Class.new { def hello; "hello"; end }.new
+    end
+    hit_me = nil
+    assert_nothing_raised do
+      hit_me = @reg.hit_me
+    end
+    assert_equal "hello", hit_me.hello
+  end
+
+  def test_inject
+    @reg.register( :hit_me, :model => :singleton_inject ) do
+      Class.new { attr_inject :foo, :bar; attr_reader :foo, :bar }.new
+    end
+    hit_me = nil
+    assert_nothing_raised do
+      hit_me = @reg.hit_me
+    end
+    assert_equal "foo is wizard!", hit_me.foo
+    assert_equal "bar is teh bomb!", hit_me.bar
+  end
+
+end

data/test/tc_multicast.rb

@@ -0,0 +1,46 @@
+$:.unshift "../lib"
+
+require 'test/unit'
+require 'needle'
+require 'needle/extras/multicast'
+
+class TC_Multicast_Target < Test::Unit::TestCase
+
+  def test_empty_delegation
+    target = Needle::Extras::Multicast::Target.new
+    assert_equal [], target.length
+  end
+
+  def test_non_empty_delegation
+    target = Needle::Extras::Multicast::Target.new( "foo", "bar baz",
+      [ 1, 2, 3, 4, 5 ] )
+    assert_equal [ 3, 7, 5 ], target.length
+  end
+
+  def test_send_bad_message
+    target = Needle::Extras::Multicast::Target.new( 5 )
+    assert_raise( NoMethodError ) do
+      target.length
+    end
+  end
+
+end
+
+class TC_Multicast_Service < Test::Unit::TestCase
+
+  def test_service
+    reg = Needle::Registry.define do |b|
+      b.require 'needle/extras/multicast', Needle::Extras::Multicast
+
+      b.a { "a" }
+      b.b { "b" }
+      b.c { |c,| [ c.a, c.b, "c" ] }
+
+      b.sender { |c,| c.multicast( c.a, c.c ) }
+    end
+
+    sender = reg.sender
+    assert_equal [ 1, 3 ], sender.length
+  end
+
+end

data/test/tc_require-library.rb

@@ -0,0 +1,70 @@
+$:.unshift "../lib"
+
+require 'test/unit'
+require 'needle'
+require 'needle/extras/require-library'
+
+class TC_RequireLibrary_Container < Test::Unit::TestCase
+
+  def test_require_library_registered
+    reg = Needle::Registry.new
+    assert !reg.keys.include?( :multicast )
+    reg.require_library "needle/extras"
+    assert reg.keys.include?( :multicast )
+  end
+
+  def test_require_library_unregistered
+    reg = Needle::Registry.new
+    assert_nothing_raised do
+      reg.require_library "rational"
+    end
+  end
+
+  def test_require_library_custom_hook
+    called_by = nil
+    Needle::LIBRARIES['yaml'] = lambda { |container| called_by = container }
+    reg = Needle::Registry.new
+    reg.require_library "yaml"
+    assert_same called_by, reg
+  end
+
+end
+
+class TC_RequireLibrary_Needle < Test::Unit::TestCase
+
+  Klass = Class.new do
+    attr_reader :events
+
+    def method_missing( sym, *args )
+      @events ||= []
+      @events << [ sym, *args ]
+    end
+  end
+
+  def test_register_library
+    mod = Klass.new
+
+    assert !Needle::LIBRARIES.has_key?( "openssl" )
+    Needle.register_library( "openssl", mod )
+    assert Needle::LIBRARIES.has_key?( "openssl" )
+
+    reg = Needle::Registry.new
+    reg.require_library "openssl"
+
+    assert_equal [ [ :register_services, reg ] ], mod.events
+  end
+
+  def test_register_library_custom_method
+    mod = Klass.new
+
+    assert !Needle::LIBRARIES.has_key?( "net/http" )
+    Needle.register_library( "net/http", mod, :register_foo )
+    assert Needle::LIBRARIES.has_key?( "net/http" )
+
+    reg = Needle::Registry.new
+    reg.require_library "net/http"
+
+    assert_equal [ [ :register_foo, reg ] ], mod.events
+  end
+
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: needle-extras
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2004-11-18
+summary: Needle-Extras is a collection of additional services that can be used with Needle. This is basically a test-bed of services that may eventually find their way into Needle itself.
+require_paths: 
+  - lib
+author: Jamis Buck
+email: jgb3@email.byu.edu
+homepage: http://needle.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: needle/extras
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - doc/README
+  - doc/LICENSE-RUBY
+  - doc/manual-html
+  - doc/LICENSE-BSD
+  - doc/LICENSE-GPL
+  - doc/manual
+  - doc/manual-html/manual.css
+  - doc/manual-html/chapter-1.html
+  - doc/manual-html/chapter-2.html
+  - doc/manual-html/chapter-3.html
+  - doc/manual-html/chapter-4.html
+  - doc/manual-html/index.html
+  - doc/manual/manual.css
+  - doc/manual/manual.yml
+  - doc/manual/parts
+  - doc/manual/chapter.erb
+  - doc/manual/page.erb
+  - doc/manual/index.erb
+  - doc/manual/manual.rb
+  - doc/manual/parts/multicast_usage.txt
+  - doc/manual/parts/multicast_overview.txt
+  - doc/manual/parts/intro_usage.txt
+  - doc/manual/parts/attrinject_usage.txt
+  - doc/manual/parts/requirelibrary_overview.txt
+  - doc/manual/parts/intro_license.txt
+  - doc/manual/parts/attrinject_overview.txt
+  - doc/manual/parts/intro_support.txt
+  - doc/manual/parts/requirelibrary_usage.txt
+  - doc/manual/parts/intro_what_is_extras.txt
+  - lib/needle
+  - lib/needle/extras
+  - lib/needle/extras.rb
+  - lib/needle/extras/attr-inject.rb
+  - lib/needle/extras/multicast.rb
+  - lib/needle/extras/version.rb
+  - lib/needle/extras/require-library.rb
+  - test/ALL-TESTS.rb
+  - test/tc_attr-inject.rb
+  - test/tc_multicast.rb
+  - test/tc_require-library.rb
+test_files: 
+  - test/ALL-TESTS.rb
+rdoc_options: 
+  - "--title"
+  - "Needle-Extras -- Services for Needle"
+  - "--main"
+  - doc/README
+extra_rdoc_files: 
+  - doc/README
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: needle
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.2.0
+      version: