micon 0.1.1

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+Dir.chdir File.dirname(__FILE__)  
+
+# Specs
+task :default => :spec
+
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"].select{|f| f !~ /\/_/}
+  t.libs = ['lib'].collect{|f| "#{File.dirname __FILE__}/#{f}"}
+end
+
+# Gem
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'fileutils'
+
+spec = Gem::Specification.new do |s|
+  s.name = "micon"
+  s.version = "0.1.1" 
+  s.summary = "Micro Container assembles and manages pieces of your application"
+  s.description = "Micro Container assembles and manages pieces of your application"
+  s.author = "Alexey Petrushin"
+  s.homepage = "http://github.com/alexeypetrushin/micon"
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.files = (%w{Rakefile readme.md} + Dir.glob("{lib,spec}/**/*"))
+  # s.add_dependency "ruby-ext"  
+  s.require_path = "lib"
+end
+
+PACKAGE_DIR = "#{File.expand_path File.dirname(__FILE__)}/build"
+
+Rake::GemPackageTask.new(spec) do |p|
+  package_dir = PACKAGE_DIR
+#  FileUtils.mkdir package_dir unless File.exist? package_dir  
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+  p.need_zip = true
+  p.package_dir = package_dir
+end
+
+# CLEAN.include [ 'pkg', '*.gem']
+
+task :push do
+  dir = Dir.chdir PACKAGE_DIR do
+    gem_file = Dir.glob("micon*.gem").first
+    system "gem push #{gem_file}"
+  end
+end
+
+task :clean do
+  system "rm -r #{PACKAGE_DIR}"
+end
+
+task :release => [:gem, :push, :clean]

data/lib/micon.rb

@@ -0,0 +1,9 @@
+%w{
+  support
+  
+  metadata
+  micon
+  
+  module
+  class
+}.each{|f| require "micon/#{f}"}

data/lib/micon/class.rb

@@ -0,0 +1,7 @@
+class Class
+  # register_as :session, :scope => :request
+  # register_as :loggger
+  def register_as *args
+    ::Micon.register(*args){self.new}
+  end
+end

data/lib/micon/metadata.rb

@@ -0,0 +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
+      end
+    end
+    
+    def delete key
+      @sync.synchronize do
+        @registry.delete key
+        @initializers.delete key
+        @before.delete key
+        @after.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
+    end
+    
+    def call_before key
+      if callbacks = @before[key]
+        callbacks.each{|c| c.call} 
+      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
+      if callbacks = @before_scope[key]
+        callbacks.each{|c| c.call}
+      end
+    end
+    
+    def call_after_scope key
+      if callbacks = @after_scope[key]
+        callbacks.each{|c| c.call}
+      end
+    end
+    
+    def with_scope_callbacks key, &block
+      call_before_scope key
+      result = block.call
+      call_after_scope key
+      result
+    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
+end

data/lib/micon/micon.rb

@@ -0,0 +1,250 @@
+# Predefined scopes are: :application | :session | :thread | :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!.
+
+module Micon
+  SYNC, MSYNC = Monitor.new, Monitor.new
+    
+  # quick access to Metadata inner variable.
+  # I intentially broke the Metadata incapsulation to provide better performance, don't refactor it.
+  @_r = {} 
+    
+  @application, @metadata = {}, Metadata.new(@_r, MSYNC)
+  
+  class << self
+    attr_accessor :metadata
+    
+    #
+    # Scope Management
+    #
+    def activate scope, container, &block
+      raise_without_self "Only custom scopes can be activated!" if scope == :application or scope == :instance  
+      raise "container should have type of Hash but has #{container.class.name}" unless container.is_a? Hash
+      
+      scope_with_prefix = add_prefix(scope)
+      raise_without_self "Scope '#{remove_prefix(scope)}' already active!" if !block and Thread.current[scope_with_prefix]
+      
+      if block
+        begin
+          outer_container_or_nil = Thread.current[scope_with_prefix]
+          Thread.current[scope_with_prefix] = container
+          @metadata.with_scope_callbacks scope, &block
+        ensure
+          Thread.current[scope_with_prefix] = outer_container_or_nil
+        end
+      else        
+        # not support nested scopes without block
+        Thread.current[scope_with_prefix] = container
+        @metadata.call_before_scope scope
+      end
+    end
+    
+    def deactivate scope
+      raise_without_self "Only custom scopes can be deactivated!" if scope == :application or scope == :instance
+      
+      scope_with_prefix = add_prefix(scope)      
+      raise_without_self "Scope '#{scope}' not active!" unless container = Thread.current[scope_with_prefix]
+      
+      @metadata.call_after_scope scope
+      Thread.current[scope_with_prefix] = nil
+      container
+    end
+    
+    def active? scope
+      if scope == :application or scope == :instance
+        true
+      else
+        Thread.current.key?(add_prefix(scope))
+      end      
+    end
+    
+    def clear      
+      SYNC.synchronize{@application.clear}
+      Thread.current.keys.each do |key|
+        Thread.current[key] = nil if key.to_s =~ /^mc_/
+      end
+    end
+    
+    def empty?
+      return false unless SYNC.synchronize{@application.empty?}
+      Thread.current.keys.each do |key|
+        return false if key.to_s =~ /^mc_/
+      end
+      return true
+    end
+    
+    
+    # 
+    # Object Management
+    # 
+    def include? key
+      scope = MSYNC.synchronize{@_r[key]}
+      
+      case scope
+      when nil
+        raise_without_self "'#{key}' component not managed!"
+      when :instance
+        true
+      when :application
+        SYNC.synchronize do
+          @application.include? key
+        end
+      else # custom
+        container = Thread.current[scope]
+        return false unless container
+        container.include? key
+      end
+    end
+    
+    def [] key
+      scope = MSYNC.synchronize{@_r[key]}
+
+      case scope
+      when nil
+        raise_without_self "'#{key}' component not managed!"
+      when :instance        
+        return create_object(key)
+      when :application
+        SYNC.synchronize do
+          o = @application[key]          
+          unless o
+            return create_object(key, @application)
+          else
+            return o
+          end
+        end
+      else # custom        
+        container = Thread.current[scope]
+        raise_without_self "Scope '#{remove_prefix(scope)}' not started!" unless container
+        o = container[key]
+        unless o
+          return create_object(key, container) 
+        else
+          return o
+        end
+      end
+    end
+    
+    def []= key, value
+      scope = MSYNC.synchronize{@_r[key]}
+      
+      case scope
+      when nil
+        raise_without_self "'#{key}' component not managed!"
+      when :instance
+        raise_without_self "You can't outject variable with the 'instance' scope!"
+      when :application
+        SYNC.synchronize{@application[key] = value}
+      else # Custom
+        container = Thread.current[scope]
+        raise_without_self "Scope '#{remove_prefix(scope)}' not started!" unless container
+        container[key] = value
+      end
+    end    
+    
+    
+    # 
+    # Metadata
+    # 
+    def register key, options = {}, &initializer
+      raise "key should not be nil or false value!" unless key
+      options = options.symbolize_keys      
+      
+      scope = options.delete(:scope) || :application
+      scope = Micon.add_prefix(scope) unless scope == :application or scope == :instance
+      dependencies = Array(options.delete(:require) || options.delete(:depends_on))
+      
+      options.each{|key| raise "Unknown option :#{key}!"}
+      
+      MSYNC.synchronize do
+        unless @_r.object_id == @metadata.registry.object_id
+          raise "internal error, reference to registry aren't equal to actual registry!" 
+        end
+        @metadata.registry[key] = scope
+        @metadata.initializers[key] = [(initializer || lambda{nil}), dependencies]
+      end
+    end
+    
+    def unregister key
+      @metadata.delete key
+    end
+    
+    def before component, &block
+      @metadata.register_before component, &block
+    end
+    
+    def after component, &block
+      @metadata.register_after component, &block
+    end
+    
+    def before_scope scope, &block
+      @metadata.register_before_scope scope, &block
+    end
+    
+    def after_scope scope, &block
+      @metadata.register_after_scope scope, &block
+    end
+    
+    # handy method, usually for test purposes
+    def swap_metadata metadata = nil
+      metadata ||= Metadata.new({}, MSYNC)
+      old = self.metadata
+      
+      self.metadata = metadata
+      @_r = metadata.registry
+      
+      old
+    end
+        
+    protected    
+      def create_object key, container = nil
+        initializer, dependencies = MSYNC.synchronize{@metadata.initializers[key]}
+        dependencies.each{|d| Micon[d]}
+        @metadata.call_before key            
+        
+        if container
+          unless o = container[key]
+            o = initializer.call          
+            container[key] = o 
+          else
+            # complex case, there's an circular dependency, and the 'o' already has been 
+            # initialized in dependecies or callbacks
+            # here's the sample case:
+            # 
+            # Micon.register :environment, :application do
+            #   p :environment
+            #   'environment'
+            # end
+            # 
+            # Micon.register :conveyors, :application, :depends_on => :environment do
+            #   p :conveyors
+            #   'conveyors'
+            # end
+            # 
+            # Micon.after :environment do
+            #   Micon[:conveyors]
+            # end
+            # 
+            # Micon[:conveyors]            
+                        
+            o = container[key]
+          end
+        else
+          o = initializer.call
+        end
+                
+        @metadata.call_after key, o
+        o
+      end
+    
+      def add_prefix scope
+        :"mc_#{scope}"
+      end
+    
+      def remove_prefix scope
+        scope.to_s.gsub(/^mc_/, '')
+      end
+  end
+end

data/lib/micon/module.rb

@@ -0,0 +1,27 @@
+class Module  
+  # 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        
+  
+      if [Class, Module].include? specificator.class
+        specificator = specificator.name
+      elsif specificator.is_a? Symbol
+        specificator = ":#{specificator}"
+      else
+        specificator = "\"#{specificator}\""
+      end
+
+      script = %{\
+def #{name}
+::Micon[#{specificator}]
+end
+
+def #{name}= value
+::Micon[#{specificator}] = value
+end}
+      self.class_eval script, __FILE__, __LINE__
+    end
+  end 
+end

data/lib/micon/support.rb

@@ -0,0 +1,17 @@
+require 'monitor'
+
+module Micon
+  def self.raise_without_self message
+    raise RuntimeError, message, caller.select{|path| path !~ /\/lib\/micon\//}
+  end
+end
+
+unless {}.respond_to? :symbolize_keys
+  class Hash  
+    def symbolize_keys
+      r = {}
+      each{|k, v| r[k.to_sym] = v}
+      r
+    end
+  end
+end

data/readme.md

@@ -0,0 +1,79 @@
+# Micro Container - 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. 
+
+Concentrate on business logic and interfaces and Micon will provide automatic configuration, life cycle management and dependency resolving.
+
+Technically it's like [IoC][ioc] container managing components, callbacks, scopes and bijections, inspired by Spring and JBoss Seam.
+
+## Usage
+	
+Let's suppose you are building the Ruby on Rails clone, there are lots of modules let's try to deal with them
+
+	require 'micon'
+	def app; Micon 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 will be 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
+			logger.info "routes parsed"
+			do_something_with request
+			logger.info 'well 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({})
+	
+For actual code go to spec/overview_spec.rb
+	
+## Installation
+
+	$ sudo gem install micon
+
+Copyright (c) 2009 Alexey Petrushin [http://bos-tec.com](http://bos-tec.com), released under the MIT license.
+
+[ioc]: http://en.wikipedia.org/wiki/Inversion_of_control

data/spec/callbacks_spec.rb

@@ -0,0 +1,56 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/helper"
+
+describe "Callbacks" do
+  before :each do
+    Micon.clear
+    Micon.metadata.clear
+  end
+  
+  describe "components callbacs" do
+    it "basic" do
+      Micon.register(:the_object){"The Object"}
+    
+      check = mock
+      check.should_receive(:done)
+      Micon.before :the_object do
+        check.done
+      end
+    
+      Micon.after :the_object do |o|
+        o << " updated"
+      end
+      Micon.after :the_object do |o|
+        o << " even more updated"
+      end
+    
+      Micon[:the_object].should == "The Object updated even more updated"
+    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
+      Micon.after :the_object do
+        check = Micon[:the_object]
+      end
+      Micon[:the_object]
+      check.should == "The Object"
+    end
+  end
+  
+  describe "custom scope callbacks" do
+    it "scope :before and :after callbacks" do
+      check = mock
+      check.should_receive(:before).ordered
+      check.should_receive(:run).ordered
+      check.should_receive(:after).ordered
+      check.should_receive(:after2).ordered
+
+      Micon.before_scope(:custom){check.before}
+      Micon.after_scope(:custom){check.after}
+      Micon.after_scope(:custom){check.after2}
+
+      Micon.activate(:custom, {}){check.run}
+    end    
+  end  
+end

data/spec/custom_scope_spec.rb

@@ -0,0 +1,76 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/helper"
+
+describe "Micon custom scope" do
+  before :each do
+    Micon.clear
+    Micon.metadata.clear
+  end
+  
+  it "activate" do
+    container = {}    
+    Micon.should_not be_active(:custom)
+    Micon.activate :custom, container
+    Micon.should be_active(:custom)
+
+    lambda{Micon.activate :custom, container}.should raise_error(/active/)
+
+    Micon.deactivate :custom
+    lambda{Micon.deactivate :custom}.should raise_error(/not active/)
+    
+    Micon.should_not be_active(:custom)
+    Micon.activate :custom, container do
+      Micon.should be_active(:custom)
+    end
+  end
+  
+  it "check" do
+    Micon.register(:value, :scope => :custom){"The Object"}
+    lambda{Micon[:value]}.should raise_error(/not started/)
+    lambda{Micon[:value] = nil}.should raise_error(/not started/)
+  end
+  
+  it "get" do
+    Micon.register(:value, :scope => :custom){"The Object"}
+    container, the_object = {}, nil
+    
+    Micon.activate :custom, container do
+      Micon[:value].should == "The Object"
+      the_object = Micon[:value]
+    end
+    
+    Micon.activate :custom, {} do
+      Micon[:value].object_id.should_not == the_object.object_id
+    end
+    
+    Micon.activate :custom, container do
+      Micon[:value].object_id.should == the_object.object_id
+    end
+    
+    container.size.should == 1
+    container[:value].should == the_object
+  end
+  
+  it "set" do
+    Micon.register(:value, :scope => :custom){"The Object"}
+    container = {}
+    
+    Micon.activate :custom, container do
+      Micon[:value].should == "The Object"
+      Micon[:value] = "Another Object"
+      the_object = Micon[:value]
+    end
+    
+    Micon.activate :custom, {} do
+      Micon[:value].should == "The Object"
+    end
+    
+    Micon.activate :custom, container do
+      Micon[:value].should == "Another Object"
+    end
+  end
+  
+  it "scope should return block value (from error)" do
+    Micon.activate(:custom, {}){'value'}.should == 'value'
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,6 @@
+lib_dir = "#{File.expand_path("#{File.dirname(__FILE__)}/..")}/lib"
+$LOAD_PATH << lib_dir if lib_dir
+
+require "micon"
+
+require 'spec'

data/spec/managed_spec.rb

@@ -0,0 +1,52 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/helper"
+
+describe "Micon Managed" do
+  before :all do
+    Micon.metadata.clear
+    
+    class ManagedObject      
+      register_as :managed_object
+      inject :object => :object_key
+
+      class << self        
+        inject :object => :object_key
+      end
+    end
+  end
+  
+  before :each do
+    Micon.clear
+  end
+
+  it "scope" do
+    scope = Micon.metadata[:managed_object]
+    initializer, dependencies = Micon.metadata.initializers[:managed_object]
+    scope.should == :application
+    initializer.call.should be_a(ManagedObject)
+  end
+
+  it "injection" do
+    the_object = "The Object"
+    Micon.register(:object_key){the_object}
+
+    ManagedObject.object.should == the_object
+    o = ManagedObject.new
+    o.object.should == the_object
+  end
+  
+  it "outjection" do
+    the_object = "The Object"
+    Micon.register(:object_key)
+
+    ManagedObject.object.should be_nil    
+    ManagedObject.object = the_object
+    ManagedObject.object.should == the_object
+  end
+  
+  it "empty?" do
+    Micon.should be_empty
+    Micon[:managed_object]
+    Micon.should_not be_empty
+  end
+end

data/spec/micelaneous_spec.rb

@@ -0,0 +1,53 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/helper"
+
+describe "Micelaneous" do  
+  before :each do
+    Micon.clear
+    Micon.metadata.clear
+  end
+  
+  it "swap_metadata" do
+    Micon.register :the_object
+    Micon.metadata[:the_object].should_not be_nil
+    Micon.instance_variable_get("@_r").should include(:the_object)
+    
+    old_metadat = Micon.swap_metadata
+    
+    Micon.metadata[:the_object].should be_nil
+    Micon.instance_variable_get("@_r").should_not include(:the_object)
+    
+    Micon.swap_metadata old_metadat
+    Micon.metadata[:the_object].should_not be_nil
+    Micon.instance_variable_get("@_r").should include(:the_object)
+  end  
+  
+  it "dependencies" do        
+    Micon.register :another_object, :depends_on => :the_object
+    lambda{Micon[:another_object]}.should raise_error(/the_object/)
+    Micon.register :the_object
+    Micon[:another_object]
+  end
+  
+  it "should not initialize twice (from error)" do
+    check = mock
+    check.should_receive(:environment).once.ordered
+    check.should_receive(:router).once.ordered
+    
+    Micon.register :environment do
+      check.environment
+      'environment'
+    end
+    
+    Micon.register :router, :depends_on => :environment do
+      check.router
+      'router'
+    end
+    Micon.after :environment do
+      # some code that needs :router
+      Micon[:router]
+    end    
+    
+    Micon[:router]
+  end  
+end

data/spec/nested_custom_scope_spec.rb

@@ -0,0 +1,32 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/helper"
+
+describe "Micon nested custom scope" do
+  before :each do
+    Micon.clear
+    Micon.metadata.clear
+  end
+  
+  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[:value].should be_nil
+        Micon[:value] = 'value b'
+        Micon[:value].should == 'value b'
+      end
+      
+      Micon[:value].should == 'value a'
+    end
+  end
+  
+  it "should not support nested scopes without block" do
+    Micon.activate :custom, {}
+    lambda{Micon.activate :custom, {}}.should raise_error(/active/)
+  end
+end

data/spec/overview_spec.rb

@@ -0,0 +1,65 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/helper"
+
+describe "Micon Overview" do
+  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 will be 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
+  			logger.info "routes parsed"
+  			do_something_with request
+  			logger.info 'well 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

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--reverse

data/spec/static_scope_spec.rb

@@ -0,0 +1,59 @@
+dir = File.expand_path(File.dirname(__FILE__))
+require "#{dir}/helper"
+
+describe "Application and Instance scopes" do  
+  before :each do
+    Micon.clear
+    Micon.metadata.clear
+  end
+  
+  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
+
+  it "application scope, outjection" do
+    the_object = "The Object"
+    Micon.register :value
+    
+    Micon[:value].should be_nil
+    Micon[:value] = the_object
+    Micon[:value].object_id.should == the_object.object_id
+  end
+  
+  it "cycle reference" do
+    class CycleB; end
+  
+    class CycleA      
+      register_as :cycle_a
+      inject :b => :cycle_b
+    end
+  
+    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      
+    Micon.register(:value){"The Object"}
+    Micon[:value].should == "The Object"
+    
+    Micon.unregister :value
+    lambda{Micon[:value]}.should raise_error(/component not managed/)
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: micon
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Alexey Petrushin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-11 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: Micro Container assembles and manages pieces of your application
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- readme.md
+- lib/micon/class.rb
+- lib/micon/metadata.rb
+- lib/micon/micon.rb
+- lib/micon/module.rb
+- lib/micon/support.rb
+- lib/micon.rb
+- spec/callbacks_spec.rb
+- spec/custom_scope_spec.rb
+- spec/helper.rb
+- spec/managed_spec.rb
+- spec/micelaneous_spec.rb
+- spec/nested_custom_scope_spec.rb
+- spec/overview_spec.rb
+- spec/spec.opts
+- spec/static_scope_spec.rb
+has_rdoc: true
+homepage: http://github.com/alexeypetrushin/micon
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Micro Container assembles and manages pieces of your application
+test_files: []
+