micon 0.1.6 → 0.1.7

data/spec/constants_spec.rb

@@ -0,0 +1,75 @@
+# 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    
+#     
+#     module ::TheRad
+#       TheRouter.should == 'TheRouter'
+#     end
+#     ::TheRouter.should == 'TheRouter'
+#     micon[:TheRouter].should == 'TheRouter'
+#   end
+#   
+#   it "should support nested constants" do
+#     module ::TheRad; end    
+#     -> {::TheRad::TheView}.should raise_error(/uninitialized constant/)
+#     
+#     micon.register 'TheRad::TheView'.to_sym, constant: true do
+#       'TheRad::TheView'
+#     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
+#       'TheRouter'
+#     end
+#     -> {::TheRouter}.should raise_error(/redefine/)
+#   end
+# end

data/spec/constants_spec/get_constant_component/lib/components/TheController.rb

@@ -0,0 +1,3 @@
+micon.register :TheController, constant: true do
+  "TheController"
+end

data/spec/custom_scope_spec.rb

@@ -1,49 +1,48 @@
 require 'spec_helper'
 
-describe "Micon custom scope" do
-  before :each do
-    Micon.clear
-    Micon.metadata.clear
+describe "Custom Scope" do
+  before do
+    self.micon = Micon::Core.new
   end
   
   it "activate" do
     container = {}    
-    Micon.should_not be_active(:custom)
-    Micon.activate :custom, container
-    Micon.should be_active(:custom)
+    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.activate :custom, container}.should raise_error(/active/)
 
-    Micon.deactivate :custom
-    lambda{Micon.deactivate :custom}.should raise_error(/not active/)
+    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)
+    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/)
+    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"}
+    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]
+    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
+    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
+    micon.activate :custom, container do
+      micon[:value].object_id.should == the_object.object_id
     end
     
     container.size.should == 1
@@ -51,25 +50,25 @@ describe "Micon custom scope" do
   end
   
   it "set" do
-    Micon.register(:value, :scope => :custom){"The Object"}
+    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]
+    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"
+    micon.activate :custom, {} do
+      micon[:value].should == "The Object"
     end
     
-    Micon.activate :custom, container do
-      Micon[:value].should == "Another Object"
+    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'
+    micon.activate(:custom, {}){'value'}.should == 'value'
   end
 end

data/spec/initialization_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+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!
+
+    ::MICON.object_id.should == m.object_id
+    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)    
+  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
+  # end
+end

data/spec/managed_spec.rb

@@ -1,33 +1,33 @@
 require 'spec_helper'
 
-describe "Micon Managed" do
+describe "Managed" do
   before :all do
-    Micon.metadata.clear
+    self.micon = Micon::Core.new
     
     class ManagedObject      
       register_as :managed_object
-      inject :object => :object_key
+      inject object: :object_key
 
       class << self        
-        inject :object => :object_key
+        inject object: :object_key
       end
     end
   end
   
-  before :each do
-    Micon.clear
+  before do
+    micon.clear
   end
 
   it "scope" do
-    scope = Micon.metadata[:managed_object]
-    initializer, dependencies = Micon.metadata.initializers[:managed_object]
+    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}
+    micon.register(:object_key){the_object}
 
     ManagedObject.object.should == the_object
     o = ManagedObject.new
@@ -36,16 +36,16 @@ describe "Micon Managed" do
   
   it "outjection" do
     the_object = "The Object"
-    Micon.register(:object_key)
+    micon.register(:object_key)
 
-    ManagedObject.object.should be_nil    
+    -> {ManagedObject.object}.should raise_error(/no initializer/)
     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
+    micon.should be_empty
+    micon[:managed_object]
+    micon.should_not be_empty
   end
 end

data/spec/micelaneous_spec.rb

@@ -1,52 +1,56 @@
 require 'spec_helper'
 
-describe "Micelaneous" do  
-  before :each do
-    Micon.clear
-    Micon.metadata.clear
-  end
+describe "Micelaneous" do
+  with_load_path "#{spec_dir}/autoload/lib"    
   
-  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  
+  before do
+    self.micon = Micon::Core.new
+  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]
+  after do
+    remove_constants :TheRouter, :TheRad
   end
   
+  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      
+    #   TheRouter.should == "TheRouter"
+    #   module ::TheRad; end
+    #   TheRad::TheView.should == "TheView"
+    # end
+  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
+    micon.register :environment do
       check.environment
       'environment'
     end
     
-    Micon.register :router, :depends_on => :environment do
+    micon.register :router, depends_on: :environment do
       check.router
       'router'
     end
-    Micon.after :environment do
+    micon.after :environment do
       # some code that needs :router
-      Micon[:router]
+      micon[:router]
     end    
     
-    Micon[:router]
+    micon[:router]
   end  
+  
+  it "helper method generation" do
+    micon.register :router
+    
+    micon.router?.should be_false
+    micon.router = 'router'
+    micon.router?.should be_true
+    micon.router.should == 'router'
+  end
 end

data/spec/micelaneous_spec/autoload/lib/components/TheRad/TheView.rb

@@ -0,0 +1,3 @@
+micon.register :TheView, constant: true do
+  "TheView"
+end

data/spec/micelaneous_spec/autoload/lib/components/TheRouter.rb

@@ -0,0 +1,3 @@
+micon.register :TheRouter, constant: true do
+  "TheRouter"
+end

data/spec/micelaneous_spec/autoload/lib/components/some_value.rb

@@ -0,0 +1,3 @@
+micon.register :some_value do
+  "some_value"
+end

data/spec/nested_custom_scope_spec.rb

@@ -1,31 +1,30 @@
 require 'spec_helper'
 
-describe "Micon nested custom scope" do
-  before :each do
-    Micon.clear
-    Micon.metadata.clear
+describe "Nested custom scope" do
+  before do
+    self.micon = Micon::Core.new
   end
   
   it "with block" do
-    Micon.register :value, :scope => :custom
+    micon.register :value, scope: :custom
     
     custom_a = {}
-    Micon.activate :custom, custom_a do
-      Micon[:value] = 'value 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'
+      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'
+      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/)
+    micon.activate :custom, {}
+    -> {micon.activate :custom, {}}.should raise_error(/active/)
   end
 end