micon 0.1.21 → 0.1.22

data/Rakefile

@@ -6,5 +6,5 @@ project(
   summary: "Silent killer of dependencies and configs",
 
   author: "Alexey Petrushin",
-  homepage: "http://github.com/alexeypetrushin/micon"
+  homepage: "http://alexeypetrushin.github.com/micon"
 )

data/readme.md

@@ -1,179 +1,91 @@
-# Micon - silent killer of dependencies and configs
-
-Micon allows You easilly and transparently eliminate dependencies and configs. Usually, when You are building complex system there are following tasks should be solved:
-
-- where the component's code is located
-- in what order should it be loaded
-- what configs does the component needs to be properly initialized
-- where those configs are stored
-- how to change configs in different environments
-- where are dependencies for component and how they should be initialized
-- how to replace some components with custom implementation
-- how to assembly parts of application for specs/tests
-- how to restore state after each spec/test (isolate it from each other)
-- how to control life-cycle of dynamically created components
-- connecting components to assemble an application
+**Documentation:** http://alexeypetrushin.github.com/micon
+
+Silent killer of dependencies and configs
+
+Micon allows You easilly and transparently eliminate dependencies and configs. Usually, when You are building complex system following tasks should be solved:
+
+- where the component's code is located.
+- in what order should it be loaded.
+- what configs does the component needs to be properly initialized.
+- where those configs are stored.
+- how to change configs in different environments.
+- where are dependencies for component and how they should be initialized.
+- how to replace some components with custom implementation.
+- how to assembly parts of application for specs/tests.
+- how to restore state after each spec/test (isolate it from each other).
+- how to control life-cycle of dynamically created components.
+- connecting components to assemble an application.
 
 *By component I mean any parts of code logically grouped together.*
 
 Micon **solves all these tasks automatically**, and has the following **price** - You has to:
 
-- use the *register(component_name, &initialization_block)* method for component initialization
-- use the *inject(component_name)* to whire components toghether
-- place component definitions to the "lib/components" folder
+- use the `register(component_name, &initialization_block)` method for component initialization.
+- use the `inject(component_name)` to whire components toghether.
+- place component definitions in the `lib/components` folder.
 
-That's all the price, not a big one, compared to the value, eh? 
-That all You need to know to use 95% of it, there are also 2-3 more specific methods, but they are needed very rarelly.
+That's all the price, not a big one, compared to the value, eh? It's all You need to know about it to use 95% of it, there are also 2-3 more specific methods, but they are needed very rarelly.
 
 Techincally Micon is sort of Dependency Injector, but because of its simplicity and invisibility it looks like an alien compared to its complex and bloated IoC / DI cousins.
 
-## Basic example
+Install Micon with Rubygems:
+
+    gem install micon
+
+Once installed, You can proceed with the examples below.
+
+The project hosted on [GitHub][project]. You can report bugs and discuss features on the [issues page][issues].
+
+### Basic example
 
 ``` ruby
 require 'micon'
-require 'logger' # standard ruby logger
+require 'logger'
 
+# Registering `:logger` component.
 micon.register(:logger){Logger.new STDOUT}
 
 class Application
+  # Whiring the `:logger` component and application together.
   inject logger: :logger
-  
+
+  # Now You can use `:logger` as if it's an usual class member.
   def run
     logger.info 'running ...'
   end
 end
 
+# Running our application, type:
+#
+#     ruby docs/basics.rb
+#
+# And You should see in the console something like this:
+#
+#     [2011-08-16T19:09:05.921238 #24944]  INFO -- : running ...
+#
 Application.new.run
-# You should see something like this in the console:
-# [2011-08-16T19:09:05.921238 #24944]  INFO -- : running ...
-```
-
-Code in examples/basics.rb
-
-## Advanced example: let's build Web Framework
-
-This example is more complicated and requires about 3-7 minutes. 
-
-Let's pretend that we are building an Ultimate Framework, the RoR Killer. There will be lot's of modules and dependencies, let's see how Micon can eliminate them. There will be only two components: router, request.
-Let's build it in two steps, at the first we'll build it as usual, and at the second refactor it using Micon.
-
-First step, building our framework **without Micon**.
-
-``` ruby
-# setting load paths
-dir = File.dirname __FILE__
-$LOAD_PATH << "#{dir}/lib"
-
-
-# Assembling Ultima Framework
-module Ultima
-  class << self
-    attr_accessor :router, :config
-    
-    def run url
-      request = Request.new url
-      
-      controller_class, method = router.decode url
-      
-      controller = controller_class.new      
-      controller.request = request
-      controller.send method
-    end
-  end
-end
-
-# reading application config
-require 'yaml'
-Ultima.config = YAML.load_file "#{dir}/config/config.yml"
-
-# initializing router
-require 'router'
-router = Router.new
-router.url_root = Ultima.config['url_root']
-Ultima.router = router
-
-# loading request and controller
-require 'request'
-require 'controller'
-
-
-# Assemblilng Application
-require 'pages_controller'
-
-Ultima.router.add_route '/index', PagesController, :index
-
-
-# Let's run it
-Ultima.run '/index'
-# You should see something like this in the console:
-# PagesController: displaying the :index page.
 ```
 
-Code in examples/ultima1/run.rb
-
-Below are the same example but refactored **with using Micon**. As You can see there's no any assembling or configuration code, because all the components are auto-discovered, auto-loaded and auto-configured.
-
-``` ruby
-# Assembling Ultima Framework
-# All components: router, request, controller will be automatically loaded & configured.
-class Ultima
-  inject router: :router
-  
-  def run url
-    # we need to tell Micon about the :request scope, so the Request will be
-    # created & destroyed during this scope automatically.
-    micon.activate :request, {} do
-      request = Request.new url
-    
-      controller_class, method = router.decode url
-    
-      controller = controller_class.new
-      # no need to explicitly set request, it will be automatically injected
-      controller.send method
-    end
-  end
-end
-micon.register(:ultima){Ultima.new}
-
-# No need for 'requre', all classes will be discowered & laoded automatically
+### Advanced example
 
-# No need for config, Micon will automatically discower config/router.yml
+It's hard to see advantages of Dependency Injection using trivial example, so this example is
+more complicated.
 
-# No need for manual router configuring, router.yml config will be applied automatically
+Let's pretend that we are building the Ultimate Web Framework, RoR Killer. There will be lot's
+of modules and dependencies, let's see how Micon can eliminate them.
 
+We build our framework in two steps:
 
-# Assemblilng Application
-# Controller will be loaded automatically
-micon.router.add_route '/index', PagesController, :index
+- the first version [ultima1.rb][ultima1] build **without Micon**.
+- second version [ultima2.rb][ultima2] refactored **using Micon**.
 
+You can compare these two examples and see advantages of using Dependency Injection.
 
-# Let's run it
-micon.ultima.run '/index'
-# You should see something like this in the console:
-# PagesController: displaying the :index page.
-```
-
-Code in examples/ultima2/run.rb
-
-## More samples
-
-If You are interested in more samples, please take a look at the [actual components][rad_core_components] used in the Rad Core Web Framework.
-
-## Note
-
-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
+If You are interested in more samples, please take a look at the [Rad SBS][rad_sbs] it's build using Micon.
 
-Copyright (c) Alexey Petrushin http://petrush.in, released under the MIT license.
+[ultima1]: http://alexeypetrushin.github.com/micon/ultima1.html
+[ultima2]: http://alexeypetrushin.github.com/micon/ultima3.html
 
-[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
+[project]: https://github.com/alexeypetrushin/micon
+[issues]:  https://github.com/alexeypetrushin/micon/issues
+[rad_sbs]: http://sbs.4ire.net

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: micon
 version: !ruby/object:Gem::Version
-  version: 0.1.21
+  version: 0.1.22
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-22 00:00:00.000000000Z
+date: 2011-09-24 00:00:00.000000000Z
 dependencies: []
 description: 
 email: 
@@ -47,7 +47,7 @@ files:
 - spec/nested_custom_scope_spec.rb
 - spec/spec_helper.rb
 - spec/static_scope_spec.rb
-homepage: http://github.com/alexeypetrushin/micon
+homepage: http://alexeypetrushin.github.com/micon
 licenses: []
 post_install_message: 
 rdoc_options: []