micon 0.1.17 → 0.1.18

data/spec/constants_spec.rb

@@ -1,70 +1,70 @@
 # require 'spec_helper'
-#  
+#
 # describe "Autoloading" do
 #   with_load_path "#{spec_dir}/get_constant_component/lib"
-#  
+#
 #   before do
 #     self.micon = Micon::Core.new
 #   end
-#  
+#
 #   after do
 #     remove_constants :TheRouter, :TheRad, :TheController, :SomeModule
 #   end
-#  
+#
 #   describe "get_constant_component" do
 #     it "should autoload components" do
 #       micon.get_constant_component(:TheController).should == "TheController"
 #     end
-#  
+#
 #     it "should not raise error if component not defined" do
 #       micon.get_constant_component(:TheValue).should == nil
 #       micon.register(:TheValue, constant: true){"TheValue"}
 #       micon.get_constant_component(:TheValue).should == "TheValue"
 #     end
-#  
+#
 #     it "should get constants only" do
 #       micon.register(:TheController){"TheController"}
 #       micon.get_constant_component(:TheController).should == nil
-#  
+#
 #       micon.register(:TheController, constant: true){"TheController"}
 #       micon.get_constant_component(:TheController).should == "TheController"
 #     end
 #   end
-#  
+#
 #   it 'validation' do
 #     -> {micon.register 'TheController', constant: true}.should raise_error(/symbol/)
 #     -> {micon.register 'TheController'.to_sym, constant: true, scope: :custom}.should raise_error(/scope/)
 #   end
-#  
+#
 #   it "should use constants as components" do
 #     -> {::TheRouter}.should raise_error(/uninitialized constant/)
-#  
+#
 #     micon.register :TheRouter, constant: true do
 #       "TheRouter"
-#     end  
-#  
+#     end
+#
 #     module ::TheRad
 #       TheRouter.should == 'TheRouter'
 #     end
 #     ::TheRouter.should == 'TheRouter'
 #     micon[:TheRouter].should == 'TheRouter'
 #   end
-#  
+#
 #   it "should support nested constants" do
-#     module ::TheRad; end  
+#     module ::TheRad; end
 #     -> {::TheRad::TheView}.should raise_error(/uninitialized constant/)
-#  
+#
 #     micon.register 'TheRad::TheView'.to_sym, constant: true do
 #       'TheRad::TheView'
-#     end  
-#  
+#     end
+#
 #     module ::SomeModule
 #       ::TheRad::TheView.should == 'TheRad::TheView'
 #     end
 #     ::TheRad::TheView.should == 'TheRad::TheView'
 #     micon['TheRad::TheView'.to_sym].should == 'TheRad::TheView'
 #   end
-#  
+#
 #   it "should check if constant is already defined" do
 #     micon.register :TheRouter, constant: true do
 #       class ::TheRouter; end

data/spec/custom_scope_spec.rb

@@ -4,9 +4,9 @@ describe "Custom Scope" do
   before do
     self.micon = Micon::Core.new
   end
-  
+
   it "activate" do
-    container = {}  
+    container = {}
     micon.should_not be_active(:custom)
     micon.activate :custom, container
     micon.should be_active(:custom)
@@ -15,59 +15,59 @@ describe "Custom Scope" do
 
     micon.deactivate :custom
     -> {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"}
     -> {micon[:value]}.should raise_error(/not started/)
     -> {micon[:value] = 'value'}.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

data/spec/initialization_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
-describe "Initialization" do  
+describe "Initialization" do
   after do
     remove_constants :TheRouter
   end
-  
+
   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)
     another.instance_variable_get('@application').should include(:the_value)
   end
-  
+
   it "initialize! should set caller as global, deinitialize! should remove it" do
     m = Micon::Core.new
     m.initialize!
@@ -26,44 +26,44 @@ describe "Initialization" do
     m.deinitialize!
     Object.const_defined?(:MICON).should be_false
   end
-  
+
   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,17 +3,17 @@ 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
   end
-  
+
   before do
     micon.clear
   end
@@ -33,7 +33,7 @@ describe "Managed" do
     o = ManagedObject.new
     o.object.should == the_object
   end
-  
+
   it "outjection" do
     the_object = "The Object"
     micon.register(:object_key)
@@ -42,7 +42,7 @@ describe "Managed" do
     ManagedObject.object = the_object
     ManagedObject.object.should == the_object
   end
-  
+
   it "empty?" do
     micon.should be_empty
     micon[:managed_object]

data/spec/miscellaneous_spec.rb

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
 describe "Miscellaneous" do
-  with_load_path "#{spec_dir}/autoload/lib"  
-  
-  before{self.micon = Micon::Core.new}  
+  with_load_path "#{spec_dir}/autoload/lib"
+
+  before{self.micon = Micon::Core.new}
   after{remove_constants :TheRouter, :TheRad}
-  
-  describe "autoloading" do  
+
+  describe "autoloading" do
     it "should autoload component definition" 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  
-  
+  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

@@ -4,25 +4,25 @@ describe "Nested custom scope" do
   before do
     self.micon = Micon::Core.new
   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.should_not include(:value)
         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, {}
     -> {micon.activate :custom, {}}.should raise_error(/active/)

data/spec/spec_helper.rb

@@ -6,9 +6,9 @@ require "micon"
 Micon::Core.send :include, Micon::Helper
 
 def micon; $micon end
-def micon= value  
+def micon= value
   $micon = value
   $micon.initialize!
-  
+
   $micon
 end

data/spec/static_scope_spec.rb

@@ -1,39 +1,39 @@
 require 'spec_helper'
 
-describe "Application and Instance scopes" do  
+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
-  
+
   it "should not allow to return nill in initializer" do
     micon.register(:value){nil}
     -> {micon[:value]}.should raise_error(/returns nill/)
   end
-  
+
   it "should not allow to register component without initializer but shouldn't allow to instantiate it" do
     micon.register :value
     -> {micon[:value]}.should raise_error(/no initializer/)
   end
-  
+
   it "should not allow to assign nill as component" do
     micon.register :value
     -> {micon[:value] = nil}.should raise_error(/can't assign nill/)
@@ -49,33 +49,33 @@ describe "Application and Instance scopes" do
     micon[:value] = the_object
     micon[:value].object_id.should == the_object.object_id
   end
-  
+
   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
-  
+
   it 'delete'
 end