micon 0.1.17 → 0.1.18

data/lib/micon/module.rb

@@ -1,12 +1,12 @@
 Module.class_eval do
-  #  
+  #
   # inject attribute: :session
-  #  
+  #
   def inject attributes
     ::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
       elsif specificator.is_a? Symbol
@@ -28,24 +28,24 @@ def #{name}?
   ::MICON.include? #{specificator}
 end
       RUBY
-  
+
       self.class_eval script, __FILE__, __LINE__
     end
-  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  
+# 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

data/lib/micon/spec.rb

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

data/lib/micon/support.rb

@@ -5,7 +5,7 @@ class Micon::Core
     end
 end
 
-class Hash  
+class Hash
   unless method_defined? :symbolize_keys
     def symbolize_keys
       r = {}

data/readme.md

@@ -1,6 +1,6 @@
 # Micon IoC assembles and manages 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.  
+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.
 
 Concentrate on business logic and interfaces and Micon will provide automatic configuration, life cycle management and dependency resolving.
 
@@ -9,23 +9,20 @@ Technically it's [IoC][ioc] like framework with components, callbacks, scopes an
 Is it usefull, is there any real-life application? - I'm using it as a heart of my [web framework][rad_core], this sites http://robotigra.ru, http://ruby-lang.info for example powered with it.
 
 ## Usage
-  
+
 Let's suppose you are building the Ruby on Rails clone, there are lots of modules let's try to deal with them
 
 ``` ruby
+# Let's suppose that we want to build the Rails clone,
+# there will be lot's of components - logger, controllers, router, ...
+
 require 'micon'
 
-# Here's our Web Framework, let's call it Rad
+# Handy shortcut to access the IoC API (this is optional and You can omit it).
+def micon; MICON end
 
-# Let's define shortcut to access the IoC API (optional
-# but handy step). I don't know how You would like to call it,  
-# so I leave this step to You.
-class ::Object
-  def rad; MICON end
-end
-
-# let's define some components  
-# the :logger is one per application, it's a static component (like singleton)
+# Let's define some components.
+# The :logger is one per application, it's a static component (like singleton).
 class Logger
   register_as :logger
   attr_accessor :log_file_path
@@ -36,29 +33,29 @@ end
 
 # To demostrate basics of working with compnents let's configure our :logger
 # explicitly (in the next example, it will be configured automatically).
-rad.logger.log_file_path = '/tmp/rad.log'  
+micon.logger.log_file_path = '/tmp/web_framework.log'
 
-# The :router requires complex initialization, so we use 
+# The :router requires complex initialization, so we use
 # another form of component registration.
 class Router
   def initialize routes; @routes = routes end
-  def decode request;  
-    class_name, method = @routes[request.url]  
+  def decode request;
+    class_name, method = @routes[request.url]
     return eval(class_name), method # returning actual class
   end
 end
-rad.register :router do
+micon.register :router do
   Router.new '/index' => ['PagesController', :index]
 end
 
-# The :controller component should be created and destroyed dynamically,  
-# for each request, we specifying that component is dynamic  
-# by declaring it's :scope.  
-# And, we don't know beforehead what it actully will be, for different  
-# request there can be different controllers,  
+# The :controller component should be created and destroyed dynamically,
+# for each request, we specifying that component is dynamic
+# by declaring it's :scope.
+# And, we don't know beforehead what it actully will be, for different
+# request there can be different controllers,
 # so, here we just declaring it without any initialization block, it
 # will be created at runtime later.
-rad.register :controller, scope: :request
+micon.register :controller, scope: :request
 
 # Let's define some of our controllers, the PagesController, note - we
 # don't register it as component.
@@ -68,7 +65,7 @@ class PagesController
 
   def index
     # Here we can use injected component
-    logger.info "Application: processing #{request}"  
+    logger.info "Application: processing #{request}"
   end
 end
 
@@ -76,38 +73,38 @@ end
 # We also registering it without initialization, it will be
 # created at runtime later.
 class Request
-  attr_reader :url  
-  def initialize url; @url = url end  
+  attr_reader :url
+  def initialize url; @url = url end
   def to_s; @url end
 end
 # Registering without initialization block.
-rad.register :request, scope: :request
+micon.register :request, scope: :request
 
 # We need to integrate our application with web server, for example with the Rack.
 # When the server receive web request, it calls the :call method of our RackAdapter
 class RackAdapter
   # Injecting components
   inject request: :request, controller: :controller
-  
+
   def call env
     # We need to tell Micon that the :request scope is started, so it will know
-    # that some dynamic components should be created during this scope and  
+    # that some dynamic components should be created during this scope and
     # destroyed at the end of it.
-    rad.activate :request, {} do
+    micon.activate :request, {} do
       # Here we manually creating the Request component
       self.request = Request.new '/index'
-  
+
       # The :router also can be injected via :inject,
       # but we can also use another way to access components,
-      # every component also availiable as rad.<component_name>
-      controller_class, method = rad.router.decode request
-  
+      # every component also availiable as micon.<component_name>
+      controller_class, method = micon.router.decode request
+
       # Let's create and call our controller
       self.controller = controller_class.new
       controller.send method
     end
   end
-end  
+end
 
 # Let's pretend that there's a Web Server and run our application,
 # You should see something like this in the console:
@@ -120,69 +117,78 @@ In real-life scenario You probably will use it in a little different way, as wil
 
 I would like to repeat it one more time - **auto-discovery and auto-configuration is extremelly important features** of the IoC, don't ignore them.
 
-Below are the same example but done with utilizing these features, this is how the Micon IoC is supposed be used in the real-life scenario. As You can see it's almost empty, because all the components are auto-discovered, auto-loaded and auto-configured. Components are located in the [spec/example_spec/lib](https://github.com/alexeypetrushin/micon/blob/master/spec/example_spec/lib) folder.
+Below are the same example but done with utilizing these features, this is how the Micon IoC is supposed be used in the real-life scenario. As You can see it's almost empty, because all the components are auto-discovered, auto-loaded and auto-configured. Components are located in the [examples/web_framework2/lib/components](https://github.com/alexeypetrushin/micon/blob/master/examples/web_framework2/lib/components) folder.
 
-Please note that this time logger convigured automatically, with logger.yml configuration file.
+Note also, that this time logger convigured automatically, with the logger.yml configuration file.
 
 ``` ruby
+# Please examine the 'web_framework1.rb' example before proceeding with this one.
+
+# Let's suppose that we want to build the Rails clone,
+# there will be lot's of components - logger, controllers, router, ...
+
+# In this example we also need another tool that automatically find & load classes.
 require 'micon'
 require 'class_loader'
 
-# Here's our Web Framework, let's call it Rad
-
-# Let's define shortcut to access the IoC API (optional
-# but handy step). I don't know how You would like to call it,  
-# so I leave this step to You.
-class ::Object
-  def rad; MICON end
-end
+# Handy shortcut to access the IoC API (this is optional and You can omit it).
+def micon; MICON end
 
 # Auto-discovering:
-#  
-# All components (:logger, :router, :request, :controller) are  
-# defined in spec/example_spec/lib/components folder.
+#
+# All components (:logger, :router, :request, :controller) are defined in
+# the web_framework2/lib/components folder.
 # All classes (PagesController, RackAdapter) are
-# located in spec/example_spec/lib folder.
-#  
-# Note that there's no any "require 'xxx'" clause, all components and
-# classes are loaded and dependecies are resolved automatically.
+# located in web_framework2/lib folder.
+#
+# Note that there will be no any "require 'xxx'" clause, all components and
+# classes will be loaded and dependecies be resolved automatically.
+
+# Adding libraries to load path (in order to load components automatically).
+lib_dir = "#{File.dirname(__FILE__)}/web_framework2/lib"
+$LOAD_PATH << lib_dir
+
+# Adding libraries to autoload path (in order to load classes automatically).
+autoload_path lib_dir
 
 # Auto-configuring
-#  
-# Remember our manual configuration of "logger.log_file_path" from  
+#
+# Remember our manual configuration of "logger.log_file_path" from
 # the previous example?
 # This time it will be configured automatically, take a look at
-# the spec/example_spec/lib/components/logger.yml file.
-#  
-# Note, that there are also logger.production.yml, configs are smart
-# and are merged in the following order:
+# the web_framework2/lib/components/logger.yml file.
+#
+# Note, that there are also logger.production.yml, Micon is smart
+# and will merge configs in the following order:
 # logger.yml <- logger.<env>.yml <- <runtime_path>/config/logger.yml
 # (If you define :environment and :runtime_path variables).
-  
+
 # Let's pretend that there's a Web Server and run our application,
 # You should see something like this in the console:
 #   Application: processing /index
 RackAdapter.new.call({})
 ```
-  
-For the actual code please look at [spec/example_spec.rb](https://github.com/alexeypetrushin/micon/blob/master/spec/example_spec.rb)
+
+For the actual code please look at [examples](https://github.com/alexeypetrushin/micon/blob/master/examples)
+
+If You are interested in more samples, please look at the [actual components][rad_core_components] used in the Rad Core Framework.
 
 ## 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 easily done.
-  
+Current wersion isn't thread-safe, and I did it intentially. Actually, the first version was implemented 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 really need it for some reason - it can be easily done.
+
 ## Installation
 
 ``` bash
 gem install micon
 ```
-  
+
 ## License
 
 Copyright (c) Alexey Petrushin http://petrush.in, released under the MIT license.
 
 [ioc]: http://en.wikipedia.org/wiki/Inversion_of_control
 [rad_core]: https://github.com/alexeypetrushin/rad_core
+[rad_core_components]: https://github.com/alexeypetrushin/rad_core/tree/master/lib/components
 [article]: http://ruby-lang.info/blog/you-underestimate-the-power-of-ioc-3fh

data/spec/callbacks_spec.rb

@@ -4,21 +4,21 @@ describe "Callbacks" do
   before do
     self.micon = Micon::Core.new
   end
-  
+
   describe "components callbacs" do
     it "basic" do
       micon.register(:the_object){"The Object"}
-  
+
       check = mock
       check.should_receive(:before)
       micon.before :the_object do
         check.before
       end
-  
+
       check.should_receive(:after1).ordered
       check.should_receive(:after2).ordered
       obj = nil
-      micon.after :the_object do |o|  
+      micon.after :the_object do |o|
         check.after1
         obj = o
       end
@@ -26,10 +26,10 @@ describe "Callbacks" do
         check.after2
         obj.object_id.should == o.object_id
       end
-  
+
       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"}
       check = nil
@@ -40,7 +40,7 @@ describe "Callbacks" do
       check.should == "The Object"
     end
   end
-  
+
   describe "custom scope callbacks" do
     it "scope :before and :after callbacks" do
       check = mock
@@ -54,9 +54,9 @@ describe "Callbacks" do
       micon.after_scope(:custom){|container| check.after2 container}
 
       micon.activate(:custom, {}){check.run}
-    end  
-  end  
-  
+    end
+  end
+
   describe "miscellaneous" do
     it "should fire callbacks after assigning component" do
       micon.register(:the_object)
@@ -67,32 +67,32 @@ describe "Callbacks" do
       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  
+      check.should_receive(:first).twice
       micon.after(:the_object, bang: false){check.first}
-  
+
       micon.delete :the_object
       micon[:the_object]
     end
-  end  
+  end
 end

data/spec/config_spec.rb

@@ -2,17 +2,17 @@ require 'spec_helper'
 
 describe "Configuration" do
   before{self.micon = Micon::Core.new}
-  
+
   it "should configure component if config provided" do
-    micon.register(:logger){::OpenStruct.new}  
-    with_load_path "#{spec_dir}/basic/lib" do  
+    micon.register(:logger){::OpenStruct.new}
+    with_load_path "#{spec_dir}/basic/lib" do
       micon[:logger].level.should == :info
     end
   end
-  
+
   it "should merge in order: conf <- conf.mode <- runtime <- runtime.mode" do
     micon.register(:object){::OpenStruct.new}
-    with_load_path "#{spec_dir}/order/lib" do  
+    with_load_path "#{spec_dir}/order/lib" do
       micon.runtime_path = "#{spec_dir}/order/app"
       micon.mode = :production
       micon[:object].tap do |o|