micon 0.1.6 → 0.1.7

data/lib/micon/metadata.rb

@@ -1,136 +1,132 @@
 # 
 # This class intentially made using "wired and not clear code", to provide better performance.
 # 
-module Micon
-  class Metadata
-    attr_accessor :registry, :initializers, :before, :after
-    
-    def initialize registry, sync
-      @registry, @sync = registry, sync
-      @before, @after, @before_scope, @after_scope, @initializers = {}, {}, {}, {}, {}
-    end
-    
-    def clear
-      @sync.synchronize do 
-        @registry.clear
-        @initializers.clear
-        @before.clear
-        @after.clear
-        @before_scope.clear
-        @after_scope.clear
-      end
-    end
-    
-    def delete key
-      @sync.synchronize do
-        @registry.delete key
-        @initializers.delete key
-        @before.delete key
-        @after.delete key
-        @before_scope.delete key
-        @after_scope.delete key
-      end
-    end
-    
-    
-    # 
-    # Registry
-    # 
-    def [] key
-      @sync.synchronize{@registry[key]}
-    end
-    
-    # def []= key, value
-    #   @sync.synchronize{@registry[key] = value}
-    # end
-    
-    def include? key
-      @sync.synchronize{@registry.include? key}
-    end
-    
-    
-    # 
-    # Callbacks
-    # 
-    def register_before key, &block
-      @sync.synchronize do
-        raise "you should provide block!" unless block
-        (@before[key] ||= []) << block
-      end
-    end
-    
-    def register_after key, &block
-      @sync.synchronize do
-        raise "you should provide block!" unless block
-        (@after[key] ||= []) << block
-      end
+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
+    @before.clear
+    @after.clear
+    @before_scope.clear
+    @after_scope.clear
+  end
+  
+  def delete key
+    @registry.delete key
+    @initializers.delete key
+    @before.delete key
+    @after.delete key
+    @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|
+      value = instance_variable_get name
+      another.instance_variable_set name, value.clone
     end
-    
-    def call_before key
-      if callbacks = @before[key]
-        callbacks.each{|c| c.call} 
-      end
+    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} 
     end
-    
-    def call_after key, object
-      if callbacks = @after[key]
-        callbacks.each{|c| c.call(object)}
-      end
+  end
+  
+  def call_after key, object
+    if callbacks = @after[key]
+      callbacks.each{|c| c.call(object)}
     end
+  end
 
 
-    # 
-    # Scope callbacks
-    # 
-    def register_before_scope key, &block
-      @sync.synchronize do
-        raise "you should provide block!" unless block
-        (@before_scope[key] ||= []) << block
-      end
-    end
-    
-    def register_after_scope key, &block
-      @sync.synchronize do
-        raise "you should provide block!" unless block
-        (@after_scope[key] ||= []) << block
-      end
-    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
+  # 
+  # 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
-    
-    def with_scope_callbacks key, container, &block
-      call_before_scope key, container
-      result = block.call
-      call_after_scope key, container
-      result
+  end
+  
+  def call_after_scope key, container
+    if callbacks = @after_scope[key]
+      callbacks.each{|c| c.call container}
     end
-    
-    
-    # 
-    # Other
-    # 
-    # def inspect
-    #   "Registry: " + self.registry.keys.inspect
-    # end
-    
-    # def deep_clone
-    #   m = Metadata.new @sync
-    #   m.registry = {}
-    #   registry.each do |k, v|
-    #     m.registry[k] = v
-    #   end
-    #   p m
-    #   m
-    # 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 = {}
+  #   registry.each do |k, v|
+  #     m.registry[k] = v
+  #   end
+  #   p m
+  #   m
+  # end
 end

data/lib/micon/module.rb

@@ -1,9 +1,11 @@
-class Module  
-  # inject :attribute => :session
+Module.class_eval do
+  # 
+  # inject attribute: :session
+  # 
   def inject attributes
-    Micon.raise_without_self "Invalid argument!" unless attributes.is_a? Hash
+    ::MICON.raise_without_self "Invalid argument!" unless attributes.is_a? Hash
     attributes.each do |name, specificator|
-      Micon.raise_without_self "Attribute name should be a Symbol!" unless name.is_a? Symbol        
+      ::MICON.raise_without_self "Attribute name should be a Symbol!" unless name.is_a? Symbol        
   
       if [Class, Module].include? specificator.class
         specificator = specificator.name
@@ -13,15 +15,44 @@ class Module
         specificator = "\"#{specificator}\""
       end
 
-      script = %{\
+      script = <<-RUBY
 def #{name}
-::Micon[#{specificator}]
+  ::MICON[#{specificator}]
 end
 
 def #{name}= value
-::Micon[#{specificator}] = value
-end}
+  ::MICON[#{specificator}] = value
+end
+
+def #{name}?
+  ::MICON.include? #{specificator}
+end
+      RUBY
+      
       self.class_eval script, __FILE__, __LINE__
     end
   end 
+  
+  
+  # 
+  # Hook to use Constants as Components
+  # 
+#   if defined? ::ClassLoader
+#     text = <<-TEXT
+# It seems that ClassLoader already defined, but it supposed to be activated after the Micon, otherwise it can cause performance loss!
+# Micon.const_missing extension should be included before than ClassLoader.const_missing otherwise the Micon.const_missing will be 
+# called (and will ping file system) for every loaded class!
+#     TEXT
+#     warn text
+#   end
+#   
+#   alias_method :const_missing_without_micon, :const_missing
+#   protected :const_missing_without_micon
+#   def const_missing const
+#     if value = ::MICON.get_constant(self, const)
+#       value
+#     else
+#       const_missing_without_micon const
+#     end
+#   end
 end

data/lib/micon/rad.rb

@@ -0,0 +1,8 @@
+Micon::Core.include Micon::Helper
+
+micon = Micon::Core.new
+micon.initialize!
+
+def rad
+  ::MICON
+end

data/lib/micon/spec.rb

@@ -0,0 +1,20 @@
+require 'rspec_ext'
+
+rspec do
+  def self.with_micon options = {}
+    scope = options[:before] || :all
+    
+    old, tmp = nil
+    
+    before scope do      
+      old = MICON
+      tmp = old.clone
+      tmp.initialize!
+    end
+    
+    after scope do
+      tmp.deinitialize!
+      old.initialize!
+    end
+  end
+end

data/lib/micon/support.rb

@@ -1,17 +1,31 @@
-require 'monitor'
-
-module Micon
-  def self.raise_without_self message
-    raise RuntimeError, message, caller.select{|path| path !~ /\/lib\/micon\//}
-  end
+class Micon::Core
+  protected
+    def raise_without_self message
+      raise RuntimeError, message, caller.select{|path| path !~ /\/lib\/micon\//}
+    end
 end
 
-unless {}.respond_to? :symbolize_keys
-  class Hash  
+class Hash  
+  unless method_defined? :symbolize_keys
     def symbolize_keys
       r = {}
       each{|k, v| r[k.to_sym] = v}
       r
     end
   end
-end
+end
+
+# class Module
+#   unless respond_to? :namespace_for
+#     # TODO3 cache it?
+#     def self.namespace_for class_name
+#       list = class_name.split("::")
+#       if list.size > 1
+#         list.pop
+#         return eval(list.join("::"), TOPLEVEL_BINDING, __FILE__, __LINE__)
+#       else
+#         return nil
+#       end
+#     end
+#   end
+# end

data/readme.md

@@ -1,4 +1,4 @@
-# Assembles and manages pieces of your application
+# Assembles and manages pieces of Your Application
 
 Micon is infrastructural component, invisible to user and it's main goal is to simplify development. It reduces complex monolithic application to set of simple low coupled components. 
 
@@ -39,12 +39,12 @@ Let's suppose you are building the Ruby on Rails clone, there are lots of module
 
 	# dynamic components, will be created and destroyed for every request
 	class Request
-		register_as :request, :scope => :request
+		register_as :request, scope: :request
 	end
 
 	class Application
 		# injecting components into attributes
-		inject :request => :request, :logger => :logger
+		inject request: :request, logger: :logger
 
 		def do_business
 			# now we can use injected component
@@ -68,11 +68,25 @@ Let's suppose you are building the Ruby on Rails clone, there are lots of module
 	RackAdapter.new.call({})
 	
 For actual code go to spec/overview_spec.rb
+
+## Note
+
+Current wersion isn't thread-safe, instead it supported evented IO (EventMachine).
+Actually I implemented first wersion as thread-safe, but because there's no actual multithreading in
+Ruby, the only thing it does - adds complexity and performance losses, so I removed it.
+But if you need it it can be done very easy.
 	
 ## Installation
 
 	$ sudo gem install micon
+	
+## TODO
+
+- remove threads and synchronization support, probably it will be never needed in any real situation, because 
+there's no multithreading in ruby.
+- refactor specs, they are messy a little.
+- maybe it makes sense to add ability to add dependencies for components after component registration?
 
-Copyright (c) 2009 Alexey Petrushin [http://bos-tec.com](http://bos-tec.com), released under the MIT license.
+Copyright (c) Alexey Petrushin [http://4ire.net](http://4ire.net), released under the MIT license.
 
 [ioc]: http://en.wikipedia.org/wiki/Inversion_of_control

data/spec/callbacks_spec.rb

@@ -1,38 +1,42 @@
 require 'spec_helper'
 
 describe "Callbacks" do
-  before :each do
-    Micon.clear
-    Micon.metadata.clear
+  before do
+    self.micon = Micon::Core.new
   end
   
   describe "components callbacs" do
     it "basic" do
-      Micon.register(:the_object){"The Object"}
+      micon.register(:the_object){"The Object"}
     
       check = mock
-      check.should_receive(:done)
-      Micon.before :the_object do
-        check.done
+      check.should_receive(:before)
+      micon.before :the_object do
+        check.before
       end
     
-      Micon.after :the_object do |o|
-        o << " updated"
+      check.should_receive(:after1).ordered
+      check.should_receive(:after2).ordered
+      obj = nil
+      micon.after :the_object do |o|        
+        check.after1
+        obj = o
       end
-      Micon.after :the_object do |o|
-        o << " even more updated"
+      micon.after :the_object do |o|
+        check.after2
+        obj.object_id.should == o.object_id
       end
-    
-      Micon[:the_object].should == "The Object updated even more updated"
+      
+      micon[:the_object].should == obj
     end
   
     it "should be able reference to the component itself inside of after filter (cycle reference)" do
-      Micon.register(:the_object){"The Object"}
+      micon.register(:the_object){"The Object"}
       check = nil
-      Micon.after :the_object do
-        check = Micon[:the_object]
+      micon.after :the_object do
+        check = micon[:the_object]
       end
-      Micon[:the_object]
+      micon[:the_object]
       check.should == "The Object"
     end
   end
@@ -45,11 +49,50 @@ describe "Callbacks" do
       check.should_receive(:after).with({}).ordered
       check.should_receive(:after2).with({}).ordered
 
-      Micon.before_scope(:custom){|container| check.before container}
-      Micon.after_scope(:custom){|container| check.after container}
-      Micon.after_scope(:custom){|container| check.after2 container}
+      micon.before_scope(:custom){|container| check.before container}
+      micon.after_scope(:custom){|container| check.after container}
+      micon.after_scope(:custom){|container| check.after2 container}
 
-      Micon.activate(:custom, {}){check.run}
+      micon.activate(:custom, {}){check.run}
     end    
-  end  
+  end 
+  
+  describe "micelaneous" do
+    it "should fire callbacks after assigning component" do
+      micon.register(:the_object)
+      check = mock
+      check.should_receive(:done)
+      micon.after :the_object do
+        check.done
+      end
+      micon.the_object = 'the_object'
+    end
+    
+    it "should raise error if callback defined after component already created" do
+      micon.register(:the_object){"the_object"}
+      micon[:the_object]
+      
+      -> {micon.before(:the_object){}}.should raise_error(/already created/)
+      -> {micon.after(:the_object){}}.should raise_error(/already created/)
+    end
+    
+    it "should raise error if callback defined after scope already started" do
+      micon.activate :custom, {} do
+        -> {micon.before_scope(:custom){}}.should raise_error(/already started/)
+        -> {micon.after_scope(:custom){}}.should raise_error(/already started/)
+      end
+    end
+    
+    it ":after with bang: false should execute callback if component already started and also register it as :after callback" do
+      micon.register(:the_object){"the_object"}
+      micon[:the_object]
+      
+      check = mock
+      check.should_receive(:first).twice      
+      micon.after(:the_object, bang: false){check.first}
+      
+      micon.delete :the_object
+      micon[:the_object]
+    end
+  end 
 end