micon 0.1.16 → 0.1.17

data/spec/example_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe "Micon Overview" do
+  before do  
+    self.micon = Micon::Core.new
+  end
+  after do  
+    remove_constants :Logger, :Router, :PagesController, :Request, :RackAdapter
+  end
+  
+  it "example" do
+    require 'micon'
+  
+    # 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
+  
+    # 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
+      def info msg
+        puts "#{msg} (writen to #{log_file_path})" unless defined?(RSpec)
+      end
+    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'  
+  
+    # 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]  
+        return eval(class_name), method # returning actual class
+      end
+    end
+    rad.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,  
+    # so, here we just declaring it without any initialization block, it
+    # will be created at runtime later.
+    rad.register :controller, scope: :request
+
+    # Let's define some of our controllers, the PagesController, note - we
+    # don't register it as component.
+    class PagesController
+      # We need access to :logger and :request, let's inject them
+      inject logger: :logger, request: :request
+
+      def index
+        # Here we can use injected component
+        logger.info "Application: processing #{request}"  
+      end
+    end
+  
+    # Request is also dynamic, and it also can't be created beforehead.
+    # We also registering it without initialization, it will be
+    # created at runtime later.
+    class Request
+      attr_reader :url  
+      def initialize url; @url = url end  
+      def to_s; @url end
+    end
+    # Registering without initialization block.
+    rad.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  
+        # destroyed at the end of it.
+        rad.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
+  
+          # Let's create and call our controller
+          self.controller = controller_class.new
+          controller.send method
+        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:
+    #   Application: processing /index
+    RackAdapter.new.call({})
+  end
+  
+  describe 'real-life' do
+    class_loader_available = begin  
+      require 'class_loader'
+      require 'class_loader/spec'
+      true
+    rescue LoadError  
+      false
+    end
+  
+    if class_loader_available  
+      with_load_path     "#{spec_dir}/lib"
+      with_autoload_path "#{spec_dir}/lib"
+  
+      it "example" do
+        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
+  
+        # Auto-discovering:
+        #  
+        # All components (:logger, :router, :request, :controller) are  
+        # defined in spec/example_spec/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.
+  
+        # Auto-configuring
+        #  
+        # 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:
+        # 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({})
+      end
+    else
+      warn "The 'real-life example' requires 'class_loader' gem, please install it"
+    end
+  end
+end

data/spec/initialization_spec.rb

@@ -8,10 +8,10 @@ describe "Initialization" do
   it "clone" do
     m = Micon::Core.new
     m.initialize!
-    
+  
     m.register(:the_value){'the_value'}
     m[:the_value]
-    
+  
     another = m.clone
     another.metadata.should include(:the_value)
     another.instance_variable_get('@registry').should include(:the_value)
@@ -30,40 +30,40 @@ describe "Initialization" do
   it "should support isolation" do
     m1 = Micon::Core.new
     m1.initialize!
-    
+  
     m1.register(:first){'first'}
     m1.first.should == 'first'
-    
+  
     m1.deinitialize!
-    
+  
     # m2
     m2 = m1.clone
     m2.initialize!
-    
+  
     m2.first.should == 'first'
     m2.register(:second){'second'}
     m2.second.should == 'second'
     m2.deinitialize!
-    
+  
     # m1 shouldn't have any of m2 stuff
     m1.initialize!
     m1.first.should == 'first'
     m1.metadata.should_not include(:second)
     m1.include? :second
-    m1.should_not include(:second)    
+    m1.should_not include(:second)  
   end
   
   # describe "constants" do
   #   it "deinitialize! should delete all defined constants" do
   #     m = Micon::Core.new
   #     m.initialize!
-  #     
+  #  
   #     m.register(:TheRouter, constant: true){'TheRouter'}
   #     ::TheRouter.should == 'TheRouter'
-  #     
+  #  
   #     m.deinitialize!
   #     Object.const_defined?(:TheRouter).should be_false
-  #     
+  #  
   #     m.initialize!
   #     ::TheRouter.should == 'TheRouter'
   #   end

data/spec/managed_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe "Managed" do
   before :all do
     self.micon = Micon::Core.new
-    
-    class ManagedObject      
+  
+    class ManagedObject  
       register_as :managed_object
       inject object: :object_key
 
-      class << self        
+      class << self  
         inject object: :object_key
       end
     end

data/spec/miscellaneous_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "Miscellaneous" do
-  with_load_path "#{spec_dir}/autoload/lib"    
+  with_load_path "#{spec_dir}/autoload/lib"  
   
   before{self.micon = Micon::Core.new}  
   after{remove_constants :TheRouter, :TheRad}
@@ -11,14 +11,14 @@ describe "Miscellaneous" do
       micon[:some_value].should == "some_value"
     end
   
-    # it 'should autoload component - constants (and nested constants)' do      
+    # it 'should autoload component - constants (and nested constants)' do  
     #   TheRouter.should == "TheRouter"
     #   module ::TheRad; end
     #   TheRad::TheView.should == "TheView"
     # end
   end
   
-  describe "complex circullar dependencies" do        
+  describe "complex circullar dependencies" do  
     it "should not initialize twice (from error)" do
       micon.register :kit do
         micon[:kit]
@@ -26,7 +26,7 @@ describe "Miscellaneous" do
       end
       lambda{micon[:kit]}.should raise_error(/component :kit used before it's initialization is finished/)
     end
-    
+  
     it "should not initialize twice if called from dependency (from error)" do
       micon.register :environment do
         micon[:router]
@@ -39,7 +39,7 @@ describe "Miscellaneous" do
 
       -> {micon[:router]}.should raise_error(/component .* used before it's initialization is finished/)
     end
-    
+  
     it "should allow to use circullar dependency in :after callback" do
       check = mock
       check.should_receive(:initialized).once
@@ -52,27 +52,27 @@ describe "Miscellaneous" do
       end
       micon[:kit].should == 'kit'
     end
-    
+  
     it "should allow circullar dependencies in :after callback" do
       micon.register :environment do
         'environment'
       end
-    
+  
       micon.register :router, depends_on: :environment do
         'router'
       end
-    
+  
       micon.after :environment do
         micon[:router]
       end
-    
-      micon[:router]                  
+  
+      micon[:router]  
     end
   end  
   
   it "helper method generation" do
     micon.register :router
-    
+  
     micon.router?.should be_false
     micon.router = 'router'
     micon.router?.should be_true

data/spec/nested_custom_scope_spec.rb

@@ -7,18 +7,18 @@ describe "Nested custom scope" do
   
   it "with block" do
     micon.register :value, scope: :custom
-    
+  
     custom_a = {}
     micon.activate :custom, custom_a do
       micon[:value] = 'value a'
-      
+  
       custom_b = {}
       micon.activate :custom, custom_b do
         micon.should_not include(:value)
         micon[:value] = 'value b'
         micon[:value].should == 'value b'
       end
-      
+  
       micon[:value].should == 'value a'
     end
   end

data/spec/static_scope_spec.rb

@@ -3,23 +3,23 @@ require 'spec_helper'
 describe "Application and Instance scopes" do  
   before{self.micon = Micon::Core.new}
   
-  it "dependencies" do        
+  it "dependencies" do  
     micon.register(:another_object, depends_on: :the_object){"another_object"}
     -> {micon[:another_object]}.should raise_error(/the_object.*not managed/)
     micon.register(:the_object){"the_object"}
     micon[:another_object]
   end
   
-  it "instance scope" do    
+  it "instance scope" do  
     micon.register(:value, scope: :instance){"The Object"}
-    
+  
     micon[:value].should == "The Object"
     micon[:value].object_id.should_not == micon[:value].object_id
   end
   
   it "application scope" do
     micon.register(:value){"The Object"}
-    
+  
     micon[:value].should == "The Object"
     micon[:value].object_id.should == micon[:value].object_id
   end
@@ -53,26 +53,26 @@ describe "Application and Instance scopes" do
   it "cycle reference" do
     class CycleB; end
   
-    class CycleA      
+    class CycleA  
       register_as :cycle_a
       inject b: :cycle_b
     end
   
-    class CycleB      
+    class CycleB  
       register_as :cycle_b
       inject a: :cycle_a
     end
-    
+  
     a = micon[:cycle_a]
     b = micon[:cycle_b]
     a.b.equal?(b).should be_true
     b.a.equal?(a).should be_true
-  end        
-    
-  it "unregister" do      
+  end  
+  
+  it "unregister" do  
     micon.register(:value){"The Object"}
     micon[:value].should == "The Object"
-    
+  
     micon.unregister :value
     -> {micon[:value]}.should raise_error(/component not managed/)
   end

metadata

@@ -1,28 +1,22 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: micon
-version: !ruby/object:Gem::Version 
-  version: 0.1.16
+version: !ruby/object:Gem::Version
+  version: 0.1.17
   prerelease: 
 platform: ruby
-authors: 
+authors:
 - Alexey Petrushin
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-08 00:00:00 +04:00
-default_executable: 
+date: 2011-08-15 00:00:00.000000000Z
 dependencies: []
-
 description: 
 email: 
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - Rakefile
 - readme.md
 - lib/micon/class.rb
@@ -45,6 +39,16 @@ files:
 - spec/constants_spec/get_constant_component/lib/components/TheController.rb
 - spec/constants_spec.rb
 - spec/custom_scope_spec.rb
+- spec/example_spec/lib/components/controller.rb
+- spec/example_spec/lib/components/logger.production.yml
+- spec/example_spec/lib/components/logger.rb
+- spec/example_spec/lib/components/logger.yml
+- spec/example_spec/lib/components/request.rb
+- spec/example_spec/lib/components/router.rb
+- spec/example_spec/lib/pages_controller.rb
+- spec/example_spec/lib/rack_adapter.rb
+- spec/example_spec/lib/request.rb
+- spec/example_spec.rb
 - spec/initialization_spec.rb
 - spec/managed_spec.rb
 - spec/miscellaneous_spec/autoload/lib/components/some_value.rb
@@ -52,36 +56,30 @@ files:
 - spec/miscellaneous_spec/autoload/lib/components/TheRouter.rb
 - spec/miscellaneous_spec.rb
 - spec/nested_custom_scope_spec.rb
-- spec/overview_spec.rb
 - spec/spec_helper.rb
 - spec/static_scope_spec.rb
-has_rdoc: true
 homepage: http://github.com/alexeypetrushin/micon
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.1
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: Assembles and Manages Components of Your Application
+summary: Micon IoC assembles and manages Your Application
 test_files: []
-

data/spec/overview_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe "Micon Overview" do
-  before do
-    self.micon = Micon::Core.new
-  end
-  
-  it "sample" do
-    class Object
-      def app; MICON end
-    end
-    
-  	# static (singleton) components
-  	class Environment
-  		register_as :environment
-  	end
-
-  	class Logger
-  		register_as :logger
-
-  		def info msg; end
-  	end	
-
-  	class Router
-  		register_as :router
-
-  		def parse rote_filename
-  		  # do something
-  		end
-  	end
-
-  	# callbacks, we need to parse routes right after environment is initialized
-  	app.after :environment do
-  		app[:router].parse '/config/routes.rb'
-  	end
-
-  	# dynamic components, will be created and destroyed for every request
-  	class Request
-  		register_as :request, scope: :request
-  	end
-
-  	class Application
-  		# injecting components into attributes
-  		inject request: :request, logger: :logger
-
-  		def do_business
-  			# now we can use injected component
-  			do_something_with request
-  			logger.info 'done'
-  		end
-
-  		def do_something_with request; end
-  	end
-
-  	# Web Server / Rack Adapter
-  	class RackAdapter
-  		def call env		
-  			# activating new request scope, the session component will be created and destroyed automatically
-  			app.activate :request, {} do
-  				Application.new.do_business
-  			end
-  		end
-  	end    
-
-  	RackAdapter.new.call({})
-  end
-end