micon 0.1.17 → 0.1.18

data/lib/micon.rb

@@ -5,12 +5,17 @@ end
 
 %w{
   support
-  
+
   metadata
   config
   core
   helper
-  
+
   module
   class
-}.each{|f| require "micon/#{f}"}
+}.each{|f| require "micon/#{f}"}
+
+# Initializing Micon
+Micon::Core.send :include, Micon::Helper
+micon = Micon::Core.new
+micon.initialize!

data/lib/micon/config.rb

@@ -1,10 +1,10 @@
-class Micon::Config  
+class Micon::Config
   attr_reader :micon, :name
   def initialize micon, name
     @micon, @name = micon, name
   end
-  
-  def load  
+
+  def load
     files = []
     files.push *config_paths.collect{|path| find_file(path, $LOAD_PATH)}
     files.push *runtime_config_paths.collect{|path| find_file(path, [micon.runtime_path])} if micon.runtime_path?
@@ -19,7 +19,7 @@ class Micon::Config
 
     config.empty? ? nil : config
   end
-  
+
   protected
     def config_paths
       fs_name = name.to_s.gsub(/::/, '/')
@@ -37,7 +37,7 @@ class Micon::Config
       end
       paths
     end
-  
+
     def find_file path, directories
       files = directories.collect{|dir| "#{dir}#{path}"}.select{|f| File.exist? f}
       raise "multiple configs for :#{name} component" if files.size > 1

data/lib/micon/core.rb

@@ -1,20 +1,20 @@
 # Predefined scopes are: :application | :session | :instance | :"custom_name"
 #
 # Micons :"custom_name" are managed by 'scope_begin' / 'scope_end' methods
-#  
+#
 # :"custom_name" can't be nested (it will destroy old and start new one) and always should be explicitly started!.
 class Micon::Core
   #
   # Scope Management
   #
   attr_accessor :custom_scopes
-  
+
   def activate sname, container, &block
-    raise_without_self "Only custom scopes can be activated!" if sname == :application or sname == :instance  
+    raise_without_self "Only custom scopes can be activated!" if sname == :application or sname == :instance
     raise "container should have type of Hash but has #{container.class.name}" unless container.is_a? Hash
-  
+
     raise_without_self "Scope '#{sname}' already active!" if !block and @custom_scopes[sname]
-  
+
     if block
       begin
         outer_container_or_nil = @custom_scopes[sname]
@@ -27,7 +27,7 @@ class Micon::Core
           @custom_scopes.delete sname
         end
       end
-    else  
+    else
       # not support nested scopes without block
       @custom_scopes[sname] = container
       @metadata.call_before_scope sname, container
@@ -36,9 +36,9 @@ class Micon::Core
 
   def deactivate sname
     raise_without_self "Only custom scopes can be deactivated!" if sname == :application or sname == :instance
-  
+
     raise_without_self "Scope '#{sname}' not active!" unless container = @custom_scopes[sname]
-  
+
     @metadata.call_after_scope sname, container
     @custom_scopes.delete sname
     container
@@ -49,10 +49,10 @@ class Micon::Core
       true
     else
       @custom_scopes.include? sname
-    end  
+    end
   end
 
-  def clear  
+  def clear
     @application.clear
     @custom_scopes.clear
   end
@@ -62,12 +62,12 @@ class Micon::Core
   end
 
 
-  #  
+  #
   # Object Management
-  #  
+  #
   def include? key
     sname = @registry[key]
-  
+
     case sname
     when nil
       false
@@ -84,34 +84,34 @@ class Micon::Core
 
   def [] key
     sname = @registry[key] || autoload_component_definition(key)
-  
+
     case sname
-    when :instance  
+    when :instance
       return create_object(key)
-    when :application  
-      o = @application[key]  
+    when :application
+      o = @application[key]
       unless o
         return create_object(key, @application)
       else
         return o
       end
-    else # custom  
+    else # custom
       container = @custom_scopes[sname]
       raise_without_self "Scope '#{sname}' not started!" unless container
       o = container[key]
       unless o
-        return create_object(key, container)  
+        return create_object(key, container)
       else
         return o
       end
     end
   end
-  
+
   def []= key, value
     raise "can't assign nill as :#{key} component!" unless value
-  
+
     sname = @registry[key] || autoload_component_definition(key)
-  
+
     value = case sname
     when :instance
       raise_without_self "You can't outject variable with the 'instance' sname!"
@@ -122,15 +122,15 @@ class Micon::Core
       raise_without_self "Scope '#{sname}' not started!" unless container
       container[key] = value
     end
-  
+
     @metadata.call_after key, value
-  
+
     value
-  end  
+  end
 
   def delete key
     sname = @registry[key] # || autoload_component_definition(key)
-  
+
     case sname
     when nil
     when :instance
@@ -142,8 +142,8 @@ class Micon::Core
       # raise_without_self "Scope '#{sname}' not started!" unless container
       container.delete key if container
     end
-  end  
-  
+  end
+
   def delete_all key
     metadata.delete key
     delete key
@@ -154,23 +154,23 @@ class Micon::Core
     self[key]
   end
 
-  #  
+  #
   # Metadata
-  #  
+  #
   attr_accessor :metadata
-  
+
   def register key, options = {}, &initializer
     raise "key should not be nil or false value!" unless key
-    options = options.symbolize_keys  
-  
+    options = options.symbolize_keys
+
     sname = options.delete(:scope) || :application
     dependencies = Array(options.delete(:require) || options.delete(:depends_on))
     # constant = options.delete(:constant) || false
-  
+
     raise "unknown options :#{options.keys.join(', :')}!" unless options.empty?
-  
+
     unless @registry.object_id == @metadata.registry.object_id
-      raise "internal error, reference to registry aren't equal to actual registry!"  
+      raise "internal error, reference to registry aren't equal to actual registry!"
     end
     @metadata.registry[key] = sname
     @metadata.initializers[key] = [initializer, dependencies] #, constant]
@@ -200,11 +200,11 @@ class Micon::Core
       else
         block.call self[component]
       end
-    end  
+    end
     @metadata.register_after component, &block
   end
 
-  def before_scope sname, options = {}, &block  
+  def before_scope sname, options = {}, &block
     options[:bang] = true unless options.include? :bang
     raise_without_self "scope :#{sname} already started!" if options[:bang] and active?(sname)
     @metadata.register_before_scope sname, &block
@@ -215,9 +215,9 @@ class Micon::Core
     raise_without_self "scope :#{sname} already started!" if options[:bang] and active?(sname)
     @metadata.register_after_scope sname, &block
   end
-  
-  
-  
+
+
+
   def clone
     another = super
     %w(@metadata @application @custom_scopes).each do |name| # @loaded_classes, @constants
@@ -226,45 +226,45 @@ class Micon::Core
     end
     another.instance_variable_set '@registry', another.metadata.registry
     another.instance_variable_set '@initialized', another.instance_variable_get('@initialized')
-    another  
+    another
   end
   alias_method :deep_clone, :clone
-  
-  def initialize!  
+
+  def initialize!
     unless @initialized
       # quick access to Metadata inner variable.
       # I intentially broke the Metadata incapsulation to provide better performance, don't refactor it.
       @registry = {} # @loaded_classes, @constants = {}, {}
       @metadata = Micon::Metadata.new(@registry)
       @stack = {}
-  
+
       @application, @custom_scopes = {}, {}
-  
+
       @initialized = true
     end
-  
-    # Micon::Core is independent itself and there can be multiple Cores simultaneously.  
-    # But some of it's extensions can work only with one global instance, and them need to know how to get it,  
+
+    # Micon::Core is independent itself and there can be multiple Cores simultaneously.
+    # But some of it's extensions can work only with one global instance, and them need to know how to get it,
     # the MICON constant references this global instance.
     Object.send(:remove_const, :MICON) if Object.const_defined?(:MICON)
-    Object.const_set :MICON, self  
+    Object.const_set :MICON, self
   end
-  
+
   def deinitialize!
     Object.send(:remove_const, :MICON) if Object.const_defined?(:MICON)
-  
+
     # @loaded_classes.each do |class_name, tuple|
     #   namespace, const = tuple
     #   namespace.send(:remove_const, const)
     # end
     # @loaded_classes.clear
   end
-  
-  #  
+
+  #
   # :mode, :runtime_path, used in component configuration
   # - 'app/runtime'
   # - :development, :test, :production
-  #  
+  #
   def runtime_path; @runtime_path || raise(":runtime_path not defined!") end
   def runtime_path= runtime_path
     runtime_path, force = runtime_path
@@ -272,74 +272,74 @@ class Micon::Core
     @runtime_path = runtime_path
   end
   def runtime_path?; !!@runtime_path end
-  
+
   def mode; @mode || raise(":mode not defined!") end
-  def mode= mode  
-    mode, force = mode  
+  def mode= mode
+    mode, force = mode
     raise "some components has been already initialized before You set :mode!" unless empty? or force
     @mode = mode
   end
   def mode?; !!@mode end
-  
-  protected  
+
+  protected
     def autoload_component_definition key, bang = true
       begin
         require "components/#{key.to_s.gsub(/::/, '/')}"
       rescue LoadError
-      end  
+      end
       sname = @registry[key]
       raise_without_self "'#{key}' component not managed!" if bang and !sname
       sname
     end
 
-    def create_object key, container = nil  
+    def create_object key, container = nil
       initializer, dependencies, config = @metadata.initializers[key]
       raise "no initializer for :#{key} component!" unless initializer
-  
-      raise "component :#{key} used before it's initialization is finished!" if @stack.include? key  
+
+      raise "component :#{key} used before it's initialization is finished!" if @stack.include? key
       begin
         dependencies.each{|d| self[d]}
-        @metadata.call_before key  
+        @metadata.call_before key
 
         # we need to check container first, in complex cases (circullar dependency)
         # the object already may be initialized.
         # See "should allow to use circullar dependency in :after callback".
         @stack[key] = true
         o = (container && container[key]) || initializer.call
-  
+
         unless config == false
-          unless config  
+          unless config
             # loading and caching config
             config = get_config key
             config = false unless config # we use false to differentiate from nil
             @metadata.initializers[key] = [initializer, dependencies, config]
-  
+
             apply_config o, config if config
           else
             apply_config o, config
-          end  
+          end
         end
-  
+
         container[key] = o if container
-  
+
         raise "initializer for component :#{key} returns nill!" unless o
       ensure
         @stack.delete key
       end
-  
+
       @metadata.call_after key, o
-      o  
+      o
     end
-  
+
     def get_config key
       ::Micon::Config.new(self, key).load
     end
-  
+
     def apply_config component, config
       # config already have keys like "#{k}="
       config.each{|k, v| component.send(k, v)}
     end
-  
+
     def name_hack namespace
       if namespace
         namespace.to_s.gsub("#<Class:", "").gsub(">", "")

data/lib/micon/helper.rb

@@ -1,26 +1,26 @@
-#  
+#
 # Generates helper methods for Micon,
 # so you can use micon.config instead of micon[:config]
 #
-module Micon::Helper  
+module Micon::Helper
   def method_missing m, *args, &block
     super if args.size > 1 or block
-  
+
     key = m.to_s.sub(/[?=]$/, '').to_sym
     self.class.class_eval do
       define_method key do
         self[key]
       end
-  
+
       define_method "#{key}=" do |value|
         self[key] = value
       end
-  
+
       define_method "#{key}?" do
         include? key
       end
     end
-  
+
     send m, *args
   end
 end

data/lib/micon/metadata.rb

@@ -1,14 +1,14 @@
-#  
+#
 # This class intentially made using "wired and not clear code", to provide better performance.
-#  
+#
 class Micon::Metadata
   attr_accessor :registry, :initializers, :before, :after
-  
+
   def initialize registry
     @registry = registry
     @before, @after, @before_scope, @after_scope, @initializers = {}, {}, {}, {}, {}
   end
-  
+
   def clear
     @registry.clear
     @initializers.clear
@@ -17,7 +17,7 @@ class Micon::Metadata
     @before_scope.clear
     @after_scope.clear
   end
-  
+
   def delete key
     @registry.delete key
     @initializers.delete key
@@ -26,7 +26,7 @@ class Micon::Metadata
     @before_scope.delete key
     @after_scope.delete key
   end
-  
+
   def clone
     another = super
     %w(@registry @before @after @before_scope @after_scope @initializers).each do |name|
@@ -36,43 +36,43 @@ class Micon::Metadata
     another
   end
   alias_method :deep_clone, :clone
-  
-  
-  #  
+
+
+  #
   # Registry
-  #  
+  #
   def [] key
     @registry[key]
   end
-  
+
   # def []= key, value
   #   @registry[key] = value
   # end
-  
+
   def include? key
     @registry.include? key
   end
-  
-  
-  #  
+
+
+  #
   # Callbacks
-  #  
+  #
   def register_before key, &block
     raise "you should provide block!" unless block
     (@before[key] ||= []) << block
   end
-  
+
   def register_after key, &block
     raise "you should provide block!" unless block
     (@after[key] ||= []) << block
   end
-  
+
   def call_before key
     if callbacks = @before[key]
-      callbacks.each{|c| c.call}  
+      callbacks.each{|c| c.call}
     end
   end
-  
+
   def call_after key, object
     if callbacks = @after[key]
       callbacks.each{|c| c.call(object)}
@@ -80,46 +80,46 @@ class Micon::Metadata
   end
 
 
-  #  
+  #
   # Scope callbacks
-  #  
+  #
   def register_before_scope key, &block
     raise "you should provide block!" unless block
     (@before_scope[key] ||= []) << block
   end
-  
+
   def register_after_scope key, &block
     raise "you should provide block!" unless block
     (@after_scope[key] ||= []) << block
   end
-  
+
   def call_before_scope key, container
     if callbacks = @before_scope[key]
       callbacks.each{|c| c.call container}
     end
   end
-  
+
   def call_after_scope key, container
     if callbacks = @after_scope[key]
       callbacks.each{|c| c.call container}
     end
   end
-  
+
   def with_scope_callbacks key, container, &block
     call_before_scope key, container
     result = block.call
     call_after_scope key, container
     result
   end
-  
-  
-  #  
+
+
+  #
   # Other
-  #  
+  #
   # def inspect
   #   "Registry: " + self.registry.keys.inspect
   # end
-  
+
   # def deep_clone
   #   m = Metadata.new
   #   m.registry = {}