impromptu 1.0.0

data/test/test_integration.rb

@@ -0,0 +1,312 @@
+require 'helper'
+require 'yaml'
+
+class TestIntegration < Test::Unit::TestCase
+  context "Loading the test.components file" do
+    setup do
+      Impromptu.reset
+      Impromptu.define_components do
+        parse_file 'test/framework/test.components'
+      end
+    end
+    
+    # ----------------------------------------
+    # Loading component definitions
+    # ----------------------------------------
+    should "01 create four components" do
+      assert_equal 4, Impromptu.components.size
+    end
+    
+    should "02 have a single folder per component" do
+      assert_equal 1, Impromptu.components['framework'].folders.size
+      assert_equal 1, Impromptu.components['framework.extensions'].folders.size
+      assert_equal 1, Impromptu.components['other'].folders.size
+    end
+    
+    should "03 have a single require in the framework component" do
+      assert_equal 1, Impromptu.components['framework'].requirements.size
+    end
+    
+    should "04 have a namespace for the framework components" do
+      assert_equal :Framework, Impromptu.components['framework'].namespace
+      assert_equal :Framework, Impromptu.components['framework.extensions'].namespace
+      assert_equal nil, Impromptu.components['other'].namespace
+    end
+    
+    should "05 start tracking 8 files" do
+      assert_equal 2, Impromptu.components['framework'].folders.first.files.size
+      assert_equal 2, Impromptu.components['framework.extensions'].folders.first.files.size
+      assert_equal 3, Impromptu.components['other'].folders.first.files.size
+      assert_equal 1, Impromptu.components['private'].folders.first.files.size
+    end
+    
+    should "06 load definitions for 9 resources" do
+      assert Impromptu.root_resource.child?(:Framework)
+      assert Impromptu.root_resource.child(:Framework).child?(:Extensions)
+      assert Impromptu.root_resource.child(:Framework).child(:Extensions).child?(:Blog)
+      assert Impromptu.root_resource.child(:Framework).child?(:Klass)
+      assert Impromptu.root_resource.child(:Framework).child?(:Klass2)
+      assert Impromptu.root_resource.child?(:Load)
+      assert Impromptu.root_resource.child?(:OtherName)
+      assert Impromptu.root_resource.child?(:ModOne)
+      assert Impromptu.root_resource.child?(:ModTwo)
+    end
+    
+    should "07 correctly mark namespace resources" do
+      assert_equal true,  Impromptu.root_resource.child(:Framework).namespace?
+      assert_equal false, Impromptu.root_resource.child(:Framework).child(:Extensions).namespace?
+      assert_equal false, Impromptu.root_resource.child(:Framework).child(:Extensions).child(:Blog).namespace?
+      assert_equal false, Impromptu.root_resource.child(:Framework).child(:Klass).namespace?
+      assert_equal false, Impromptu.root_resource.child(:Framework).child(:Klass2).namespace?
+      assert_equal false, Impromptu.root_resource.child(:Load).namespace?
+      assert_equal false, Impromptu.root_resource.child(:OtherName).namespace?
+      assert_equal false, Impromptu.root_resource.child(:ModOne).namespace?
+      assert_equal false, Impromptu.root_resource.child(:ModTwo).namespace?
+    end
+    
+    should "08 keep all resources unloaded to start with" do
+      assert_equal false, Impromptu.root_resource.child(:'Framework').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Extensions').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Extensions::Blog').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Klass').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Klass2').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'Load').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'OtherName').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'ModOne').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'ModTwo').loaded?
+    end
+    
+    should "09 have all resources specified by the correct number of files" do
+      assert_equal 0, Impromptu.root_resource.child(:'Framework').files.size
+      assert_equal 1, Impromptu.root_resource.child(:'Framework::Extensions').files.size
+      assert_equal 1, Impromptu.root_resource.child(:'Framework::Extensions::Blog').files.size
+      assert_equal 2, Impromptu.root_resource.child(:'Framework::Klass').files.size
+      assert_equal 1, Impromptu.root_resource.child(:'Framework::Klass2').files.size
+      assert_equal 1, Impromptu.root_resource.child(:'Framework::Klass2').files.size
+      assert_equal 1, Impromptu.root_resource.child(:'Load').files.size
+      assert_equal 2, Impromptu.root_resource.child(:'OtherName').files.size
+      assert_equal 1, Impromptu.root_resource.child(:'ModOne').files.size
+      assert_equal 1, Impromptu.root_resource.child(:'ModTwo').files.size
+      assert_equal true, Impromptu.root_resource.child(:'Framework').implicitly_defined?
+    end
+    
+    
+    # ----------------------------------------
+    # Loading/unloading
+    # ----------------------------------------
+    should "10 allow loading the implicitly defined framework module" do
+      assert_equal false, Impromptu.root_resource.child(:'Framework').loaded?
+      Impromptu.root_resource.child(:'Framework').reload
+      assert_equal true, Impromptu.root_resource.child(:'Framework').loaded?
+      assert_nothing_raised do
+        Framework
+      end
+    end
+    
+    should "11 load resources using associated files when required" do
+      # ext
+      Impromptu.root_resource.child(:'Framework::Extensions::Blog').reload
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Extensions').loaded?
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Extensions::Blog').loaded?
+      assert_nothing_raised do
+        Framework::Extensions
+      end
+      assert_nothing_raised do
+        Framework::Extensions::Blog
+      end
+      
+      # lib
+      Impromptu.root_resource.child(:'Framework::Klass').reload
+      Impromptu.root_resource.child(:'Framework::Klass2').reload
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Klass').loaded?
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Klass2').loaded?
+      assert_nothing_raised do
+        Framework::Klass
+      end
+      assert_nothing_raised do
+        Framework::Klass2
+      end
+      
+      # other
+      Impromptu.root_resource.child(:Load).reload
+      Impromptu.root_resource.child(:OtherName).reload
+      Impromptu.root_resource.child(:ModOne).reload
+      Impromptu.root_resource.child(:ModTwo).reload
+      assert_equal true, Impromptu.root_resource.child(:Load).loaded?
+      assert_equal true, Impromptu.root_resource.child(:OtherName).loaded?
+      assert_equal true, Impromptu.root_resource.child(:ModOne).loaded?
+      assert_equal true, Impromptu.root_resource.child(:ModTwo).loaded?
+      assert_nothing_raised do
+        Load
+      end
+      assert_nothing_raised do
+        OtherName
+      end
+      assert_nothing_raised do
+        ModOne
+      end
+      assert_nothing_raised do
+        ModTwo
+      end
+    end
+    
+    should "12 load multiple files for a resource when required" do
+      # Klass
+      Impromptu.root_resource.child(:'Framework::Klass').reload
+      assert_respond_to Framework::Klass, :standard_method
+      assert_respond_to Framework::Klass, :overriden_method
+      assert_respond_to Framework::Klass, :extension_method
+      assert_equal 2, Framework::Klass.overriden_method
+      
+      # OtherName
+      Impromptu.root_resource.child(:OtherName).reload
+      assert_respond_to OtherName, :one
+      assert_respond_to OtherName, :overriden_method
+      assert_respond_to OtherName, :two
+      assert_equal 4, OtherName.overriden_method
+    end
+    
+    should "13 be able to unload implicit and explicit resources" do
+      # explicit
+      Impromptu.root_resource.child(:'Framework::Extensions::Blog').reload
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Extensions').loaded?
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Extensions::Blog').loaded?
+      Impromptu.root_resource.child(:'Framework::Extensions').unload
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Extensions').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Extensions::Blog').loaded?
+      
+      # implicit
+      Impromptu.root_resource.child(:'Framework').reload
+      assert_equal true, Impromptu.root_resource.child(:'Framework').loaded?
+      Impromptu.root_resource.child(:'Framework').unload
+      assert_equal false, Impromptu.root_resource.child(:'Framework').loaded?
+    end
+    
+    should "14 be able to reload previously unloaded resources" do
+      # implicit
+      Impromptu.root_resource.child(:'Framework').reload
+      Impromptu.root_resource.child(:'Framework').unload
+      assert_equal false, Impromptu.root_resource.child(:'Framework').loaded?
+      Impromptu.root_resource.child(:'Framework').reload
+      assert_equal true, Impromptu.root_resource.child(:'Framework').loaded?
+      
+      # explicit
+      Impromptu.root_resource.child(:'Framework::Extensions::Blog').reload
+      Impromptu.root_resource.child(:'Framework::Extensions').unload
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Extensions').loaded?
+      assert_equal false, Impromptu.root_resource.child(:'Framework::Extensions::Blog').loaded?
+      Impromptu.root_resource.child(:'Framework::Extensions::Blog').reload
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Extensions').loaded?
+      assert_equal true, Impromptu.root_resource.child(:'Framework::Extensions::Blog').loaded?
+    end
+    
+    
+    # ----------------------------------------
+    # Updating files
+    # ----------------------------------------
+    context "and changing the definition of klass" do
+      setup do
+        Impromptu.root_resource.child(:'Framework::Klass').reload
+        new_klass = File.open('test/framework/copies/new_klass.rb').read
+        File.open('test/framework/lib/klass.rb', 'w') do |file|
+          file.write new_klass
+        end
+      end
+      
+      teardown do
+        old_klass = File.open('test/framework/copies/original_klass.rb').read
+        File.open('test/framework/lib/klass.rb', 'w') do |file|
+          file.write old_klass
+        end
+      end
+      
+      should "reload a class definition correctly when a file is changed" do        
+        # update impromptu and test the new klass is loaded
+        assert_respond_to Framework::Klass, :standard_method
+        assert_equal 2, Framework::Klass.overriden_method
+        Impromptu.update
+        assert_respond_to Framework::Klass, :new_method
+        assert_equal false, Framework::Klass.respond_to?(:standard_method)
+        assert_equal 2, Framework::Klass.overriden_method
+      end
+    end
+    
+    
+    # ----------------------------------------
+    # Adding files
+    # ----------------------------------------
+    context "and adding a new file to a reloadable folder" do
+      setup do
+        FileUtils.mv 'test/framework/copies/new_unseen.rb', 'test/framework/private/unseen.rb'
+      end
+      
+      teardown do
+        FileUtils.mv 'test/framework/private/unseen.rb', 'test/framework/copies/new_unseen.rb'
+      end
+      
+      should "make the resource from the new file available for loading" do
+        assert_equal false, Impromptu.root_resource.child?(:'Framework::Unseen')
+        Impromptu.update
+        assert_equal true, Impromptu.root_resource.child?(:'Framework::Unseen')
+        Impromptu.root_resource.child(:'Framework::Unseen').reload
+        assert Framework::Unseen.test_method
+      end
+    end
+    
+    
+    # ----------------------------------------
+    # Removing files
+    # ----------------------------------------
+    context "and removing a file from a reloadable folder" do
+      teardown do
+        FileUtils.mv 'test/framework/copies/klass2.rb', 'test/framework/lib/group/klass2.rb'
+      end
+      
+      should "make the resource from the old unavailable since its definition has been removed" do
+        # ensure the resource exists and load it
+        assert_equal true, Impromptu.root_resource.child?(:'Framework::Klass2')
+        Impromptu.root_resource.child(:'Framework::Klass2').reload
+        assert_nothing_raised do
+          Framework::Klass2
+        end
+        
+        # update and see the missing file
+        FileUtils.mv 'test/framework/lib/group/klass2.rb', 'test/framework/copies/klass2.rb'
+        Impromptu.update
+        assert_equal false, Impromptu.root_resource.child?(:'Framework::Klass2')
+        assert_raise NameError do
+          Framework::Klass2
+        end
+      end
+    end
+    
+    
+    # ----------------------------------------
+    # Adding a file to a previously defined
+    # resource
+    # ----------------------------------------
+    context "and adding a file to a previously defined resource" do
+      setup do
+        Impromptu.root_resource.child(:'Framework::Klass2').reload
+        FileUtils.mv 'test/framework/copies/extra_klass2.rb', 'test/framework/private/klass2.rb'
+      end
+      
+      teardown do
+        FileUtils.mv 'test/framework/private/klass2.rb', 'test/framework/copies/extra_klass2.rb'
+      end
+      
+      should "extend the definition and the list of files implementing the resource" do
+        # existing definition
+        assert Impromptu.root_resource.child?(:'Framework::Klass2')
+        assert_equal 1, Impromptu.root_resource.child(:'Framework::Klass2').files.size
+        assert_equal false, Framework::Klass2.respond_to?(:new_method)
+        
+        # extend with new definition
+        Impromptu.update
+        assert_equal 2, Impromptu.root_resource.child(:'Framework::Klass2').files.size
+        assert Framework::Klass2.respond_to?(:new_method)
+        assert Framework::Klass2.new_method
+      end
+    end
+  end
+end

data/test/test_ordered_set.rb

@@ -0,0 +1,93 @@
+require 'helper'
+
+class TestOrderedSet < Test::Unit::TestCase
+  context "An ordered set" do
+    setup { @set = Impromptu::OrderedSet.new }
+    
+    # ----------------------------------------
+    # API
+    # ----------------------------------------
+    should "respond to push" do
+      assert_respond_to @set, :push
+    end
+    
+    should "respond to <<" do
+      assert_respond_to @set, :<<
+    end
+    
+    should "respond to merge" do
+      assert_respond_to @set, :merge
+    end
+    
+    should "respond to delete" do
+      assert_respond_to @set, :delete
+    end
+    
+    should "respond to to_a" do
+      assert_respond_to @set, :to_a
+    end
+    
+    should "respond to each" do
+      assert_respond_to @set, :each
+    end
+    
+    should "respond to size" do
+      assert_respond_to @set, :size
+    end
+    
+    should "respond to empty?" do
+      assert_respond_to @set, :empty?
+    end
+    
+    # ----------------------------------------
+    # Core usage
+    # ----------------------------------------
+    should "be able to have items added" do
+      assert_equal 1, @set << 1
+      assert_equal 2, @set.push(2)
+      assert_equal 2, @set.size
+    end
+    
+    should "only allow an item to be added once" do
+      assert_equal 1, @set << 1
+      assert_equal 1, @set.push(1)
+      assert_equal 1, @set.size
+    end
+    
+    should "store items in order" do
+      @set << 1
+      @set << 2
+      assert_equal [1,2], @set.to_a
+    end
+    
+    should "be able to delete items" do
+      @set << 1
+      assert_equal 1, @set.size
+      @set.delete(1)
+      assert_equal 0, @set.size
+      assert_equal true, @set.empty?
+    end
+    
+    should "correctly implement empty?" do
+      assert_equal true, @set.empty?
+      @set << 1
+      assert_equal false, @set.empty?
+    end
+    
+    should "correctly implement include?" do
+      @set << 1
+      assert_equal true, @set.include?(1)
+      assert_equal false, @set.include?(2)
+    end
+    
+    should "be able to be iterated over, in order of insertion" do
+      items = []
+      @set << 1
+      @set << 2
+      @set.each do |item|
+        items << item
+      end
+      assert_equal [1,2], items
+    end
+  end
+end

data/test/test_resource.rb

@@ -0,0 +1,186 @@
+require 'helper'
+
+class TestResource < Test::Unit::TestCase
+  # ----------------------------------------
+  # Root resource and API
+  # ----------------------------------------
+  context "The root resource" do
+    should "exist" do
+      assert_not_nil Impromptu.root_resource
+    end
+    
+    should "respond to children?" do
+      assert_respond_to Impromptu.root_resource, :children?
+    end
+    
+    should "respond to child?" do
+      assert_respond_to Impromptu.root_resource, :child?
+    end
+    
+    should "respond to child" do
+      assert_respond_to Impromptu.root_resource, :child
+    end
+    
+    should "respond to reference" do
+      assert_respond_to Impromptu.root_resource, :reference
+    end
+    
+    should "respond to get_or_create_child" do
+      assert_respond_to Impromptu.root_resource, :get_or_create_child
+    end
+    
+    should "respond to namespace?" do
+      assert_respond_to Impromptu.root_resource, :namespace?
+    end
+    
+    should "be a root resource" do
+      assert Impromptu.root_resource.root?
+    end
+    
+    should "reference Object" do
+      assert_equal Object, Impromptu.root_resource.reference
+    end
+  end
+  
+  # ----------------------------------------
+  # Hash and equality
+  # ----------------------------------------
+  context "Two resources" do
+    setup { @one = Impromptu::Resource.new(:Object, nil) }
+    context "which refer to the same symbol" do
+      setup { @two = Impromptu::Resource.new(:Object, nil) }
+      should "be equal" do
+        assert @one.eql?(@two)
+        assert @two.eql?(@one)
+      end
+      
+      should "have equal hashes" do
+        assert @one.hash == @two.hash
+      end
+    end
+    
+    context "which refer to different symbols" do
+      setup { @two = Impromptu::Resource.new(:Test, @one) }
+      should "not be equal" do
+        assert_equal false, @one.eql?(@two)
+        assert_equal false, @two.eql?(@one)
+      end
+      
+      should "have different hashes if their symbols have different hashes" do
+        assert_equal false, @one.hash == @two.hash
+      end
+    end
+  end
+  
+  # ----------------------------------------
+  # Creating and retrieving resources
+  # ----------------------------------------
+  context "A root resource" do
+    setup { @root = Impromptu::Resource.new(:Object, nil) }
+    context "with a child resource" do
+      setup { @child = @root.get_or_create_child(:Klass) }
+      should "have children" do
+        assert @root.children?
+      end
+      
+      should "have a child with the name just created" do
+        assert @root.child?(:Klass)
+      end
+      
+      should "be able to retrieve a reference to the child resource" do
+        assert_not_nil @root.child(:Klass)
+        assert_instance_of Impromptu::Resource, @root.child(:Klass)
+      end
+    end
+    
+    context "with a deep chain of child resources" do
+      setup { @base = @root.get_or_create_child(:'One::Two::Three::Four') }
+      should "have children" do
+        assert @root.children?
+      end
+      
+      should "be able to retrieve a reference to each resource just created" do
+        # One
+        assert_not_nil @root.child(:'One')
+        assert_instance_of Impromptu::Resource, @root.child(:'One')
+        
+        # One::Two
+        assert_not_nil @root.child(:'One::Two')
+        assert_instance_of Impromptu::Resource, @root.child(:'One::Two')
+        
+        # One::Two::Three
+        assert_not_nil @root.child(:'One::Two::Three')
+        assert_instance_of Impromptu::Resource, @root.child(:'One::Two::Three')
+        
+        # One::Two::Three::Four
+        assert_not_nil @root.child(:'One::Two::Three::Four')
+        assert_instance_of Impromptu::Resource, @root.child(:'One::Two::Three::Four')
+      end
+    end
+  end
+  
+  # ----------------------------------------
+  # Adding/removing references
+  # ----------------------------------------
+  context "A new blank resource" do
+    setup { @resource = Impromptu::Resource.new(:Object, nil) }
+    should "have no files" do
+      assert_equal 0, @resource.files.size
+    end
+    
+    should "have no children" do
+      assert_equal 0, @resource.children.size
+    end
+    
+    should "be implicitly defined" do
+      assert @resource.implicitly_defined?
+    end
+    
+    context "with an added child" do
+      setup do
+        @child = Impromptu::Resource.new(:Test, @resource)
+        @resource.add_child(@child)
+      end
+      
+      should "have an added child" do
+        assert_equal 1, @resource.children.size
+      end
+      
+      should "be able to remove the child" do
+        @resource.remove_child(@child)
+        assert_equal 0, @resource.children.size
+      end
+    end
+    
+    context "with an added file" do
+      setup do
+        @file = Impromptu::File.new(nil, nil, [:blank])
+        @resource.add_file(@file)
+      end
+      
+      should "have an added file" do
+        assert_equal 1, @resource.files.size
+      end
+      
+      should "not be implicitly defined" do
+        assert_equal false, @resource.implicitly_defined?
+      end
+      
+      should "be able to remove the file" do
+        @resource.remove_file(@file)
+        assert_equal 0, @resource.files.size
+      end
+      
+      should "not be implicitly defined after all files are removed" do
+        @resource.remove_file(@file)
+        assert_equal false, @resource.implicitly_defined?
+      end
+      
+      should "be implicitly defined after all files are removed if it is a namespace" do
+        @resource.namespace!
+        @resource.remove_file(@file)
+        assert_equal true, @resource.implicitly_defined?
+      end
+    end
+  end
+end

data/test/test_symbol.rb

@@ -0,0 +1,99 @@
+require 'helper'
+
+class TestResource < Test::Unit::TestCase
+  context "A symbol" do
+    setup { @symbol = :ASymbolWhichDoesntNormallyExist }
+    
+    # ----------------------------------------
+    # API
+    # ----------------------------------------
+    should "respond to nested?" do
+      assert_respond_to @symbol, :nested?
+    end
+    
+    should "respond to unnested?" do
+      assert_respond_to @symbol, :unnested?
+    end
+    
+    should "respond to nested_symbols" do
+      assert_respond_to @symbol, :nested_symbols
+    end
+    
+    should "respond to base_symbol" do
+      assert_respond_to @symbol, :base_symbol
+    end
+    
+    should "respond to root_symbol" do
+      assert_respond_to @symbol, :root_symbol
+    end
+    
+    should "respond to each_namespaced_symbol" do
+      assert_respond_to @symbol, :each_namespaced_symbol
+    end
+    
+    # ----------------------------------------
+    # Unnested symbol
+    # ----------------------------------------
+    context "which isn't nested" do
+      should "return false for nested?" do
+        assert_equal false, @symbol.nested?
+      end
+      
+      should "return true for unnested?" do
+        assert @symbol.unnested?
+      end
+      
+      should "return an array of a single symbol from nested_symbols" do
+        assert_instance_of Array, @symbol.nested_symbols
+        assert_equal 1, @symbol.nested_symbols.size
+        assert_instance_of Symbol, @symbol.nested_symbols.first
+      end
+      
+      should "return itself for base_symbol" do
+        assert_equal @symbol, @symbol.base_symbol
+      end
+      
+      should "return itself for root_symbol" do
+        assert_equal @symbol, @symbol.root_symbol
+      end
+    end
+    
+    # ----------------------------------------
+    # Nested symbol
+    # ----------------------------------------
+    context "which is nested" do
+      setup { @symbol = :'TopLevel::BottomLevel' }
+      should "return true for nested?" do
+        assert @symbol.nested?
+      end
+      
+      should "return false for unnested?" do
+        assert_equal false, @symbol.unnested?
+      end
+      
+      should "return an array of multiple symbols from nested_symbols" do
+        assert_instance_of Array, @symbol.nested_symbols
+        assert_equal 2, @symbol.nested_symbols.size
+        assert_instance_of Symbol, @symbol.nested_symbols[0]
+        assert_instance_of Symbol, @symbol.nested_symbols[1]
+      end
+      
+      should "return the first nested name for root_symbol" do
+        assert_equal :TopLevel, @symbol.root_symbol
+      end
+      
+      should "return the last nested name for base_symbol" do
+        assert_equal :BottomLevel, @symbol.base_symbol
+      end
+      
+      should "return consecutive namespaced symbols when calling each_namespaced_symbol" do
+        symbols = []
+        @symbol.each_namespaced_symbol do |symbol|
+          symbols << symbol
+        end
+        
+        assert_equal [:TopLevel, :'TopLevel::BottomLevel'], symbols
+      end
+    end
+  end  
+end