Files

Needle::Registry

Registry is a specialization of Container, with additional functionality for bootstrapping basic services into a new registry. It also supports a # method for easily registering new services.

Usage:

  require 'needle'

  registry = Needle::Registry.new
  registry.register( :foo ) { Foo.new }
  registry.register( :bar ) { |c| Bar.new( c.foo ) }

  bar = registry.bar

Public Class Methods

define( *parms, &block ) click to toggle source

Instantiate a new Registry (via #) and immediately invoke # using the given block.

Usage:

  registry = Needle::Registry.define do |b|
    b.add { Adder.new }
    ...
  end

  adder = registry.add
    # File lib/needle/registry.rb, line 74
74:     def self.define( *parms, &block )
75:       raise NeedleError, "needs a block" if block.nil?
76:       new( *parms ) { |reg| reg.define( &block ) }
77:     end
define!( *parms, &block ) click to toggle source

Instantiate a new Registry (via #) and immediately invoke # using the given block.

Usage:

  registry = Needle::Registry.define! do
    add { Adder.new }
    ...
  end

  adder = registry.add
    # File lib/needle/registry.rb, line 58
58:     def self.define!( *parms, &block )
59:       raise NeedleError, "needs a block" if block.nil?
60:       new( *parms ) { |reg| reg.define!( &block ) }
61:     end
new( opts={} ) click to toggle source

Instantiate a new Registry. The options hash may include the following keys:

:logs

options used to initialize the logger factory. The value to this key should be another hash.

:parent

The parent container of this registry.

:name

The name of this registry.

If a block is given, the constructed registry instance is yielded to it.

Usage:

  registry = Needle::Registry.new

or

  registry = Needle::Registry.new do |reg|
    reg.register( :add ) { Adder.new }
  end

or

  registry = Needle::Registry.new(
    :logs => { :filename => "/dev/null" }
  )
     # File lib/needle/registry.rb, line 104
104:     def initialize( opts={} )
105:       super( opts[:parent], opts[:name] )
106:       bootstrap( opts ) if parent.nil?
107:       yield( self ) if block_given?
108:     end

Public Instance Methods

fullname() click to toggle source

Returns nil, unless the registry has a parent, in which case it acts like Container#fullname. Registries are usually unnamed containers.

     # File lib/needle/registry.rb, line 112
112:     def fullname
113:       parent ? super : nil
114:     end

Private Instance Methods

bootstrap( opts ) click to toggle source

Bootstraps the pipeline elements, service models, logger factory, and logging interceptor services into the current registry. This is only called when a new, root (parentless) registry is created.

     # File lib/needle/registry.rb, line 119
119:     def bootstrap( opts )
120:       register( :pipeline_elements, :pipeline=>[] ) { Hash.new }
121:       pipeline( :pipeline_elements ).add( :singleton,
122:         Needle::Lifecycle::Singleton )
123: 
124:       self[:pipeline_elements].update(
125:         :singleton   => Needle::Lifecycle::Singleton,
126:         :initialize  => Needle::Lifecycle::Initialize,
127:         :deferred    => Needle::Lifecycle::Deferred,
128:         :interceptor => Needle::Pipeline::InterceptorElement,
129:         :multiton    => Needle::Lifecycle::Multiton,
130:         :threaded    => Needle::Lifecycle::Threaded
131:       )
132: 
133:       register( :service_models, :pipeline=>[:singleton] ) { Hash.new }
134:       self[:service_models].update(
135:         :multiton                      => [ :multiton ],
136:         :multiton_initialize           => [ :multiton, :initialize ],
137:         :multiton_deferred             => [ :multiton, :deferred ],
138:         :multiton_deferred_initialize  => [ :multiton, :deferred, :initialize ],
139:         :prototype                     => [],
140:         :prototype_initialize          => [ :initialize ],
141:         :prototype_deferred            => [ :deferred ],
142:         :prototype_deferred_initialize => [ :deferred, :initialize ],
143:         :singleton                     => [ :singleton ],
144:         :singleton_initialize          => [ :singleton, :initialize ],
145:         :singleton_deferred            => [ :singleton, :deferred ],
146:         :singleton_deferred_initialize => [ :singleton, :deferred, :initialize],
147:         :threaded                      => [ :threaded ],
148:         :threaded_initialize           => [ :threaded, :initialize ],
149:         :threaded_deferred             => [ :threaded, :deferred ],
150:         :threaded_deferred_initialize  => [ :threaded, :deferred, :initialize ]
151:       )
152: 
153:       register( :definition_context_factory ) { DefinitionContext }
154: 
155:       define do |b|
156:         b.namespace_impl_factory   { Container }
157:         b.interceptor_impl_factory { Interceptor }
158: 
159:         b.logs { LogFactory.new( opts[:logs] || {} ) }
160: 
161:         # a parameterized version of c[:logs] for easier access
162:         b.log_for( :model => :prototype ) { |c,p,name| c[:logs].get(name) }
163: 
164:         b.logging_interceptor { LoggingInterceptor }
165:       end
166:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.