dyoder-autocode 0.9.8 → 0.9.9

data/lib/autocode.rb

@@ -6,56 +6,55 @@ module AutoCode
     cname.gsub(/(_)(\w)/) { $2.upcase }.gsub(/^([a-z])/) { $1.upcase }.intern
   end
   
-  class Loader
-    def initialize(options={}); @directories = options[:directories] ; end
-    def call(cname)
-      filename = Loader.snake_case( cname ) << '.rb'
-      if @directories.nil?
-        Kernel.load( filename )
-      else
-        path = @directories.map { |dir| File.join( dir.to_s, filename ) }.find { |path| File.exist?( path ) }
-        Kernel.load( path ) rescue nil unless path.nil?
-      end
-    end
-    def Loader.snake_case(cname)
-      cname.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
-    end
+  def AutoCode.snake_case( cname )
+    cname.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
   end
-  
-  class Creator
-    def initialize( options, &block )
-      @exemplar = (options[:exemplar]||Module.new).clone; @block = block
-    end
-    def call ; @exemplar.module_eval( &@block ) if @block ; @exemplar ; end
-  end
-  
-  class Initializer
-    def initialize( &block ) ;@block = block ; end
-    def call( mod ) ; mod.module_eval( &@block ) ; end 
-  end
-      
-  def self.extended( mod ) ; included(mod) ; end
+        
+  def self.extended( mod ) ; included( mod ) ; end
 
   def self.included( mod )
     
     mod.instance_eval do
 
+      # First make sure we haven't already done this once
+      return unless @autocode.nil?
+      
       # Initialize bookkeeping variables needed by AutoCode
-      @initializers ||= Hash.new { |h,k| h[k] = [] }; @reloadable ||= []
+      @autocode = { 
+        :constructors => Hash.new { |h,k| h[k] = [] },
+        :initializers => Hash.new { |h,k| h[k] = [] },
+        :loaded => []
+      }
       
       # Adds an auto_create block for the given key using the given exemplar if provided
       def auto_create( key = true, options = {}, &block )
-        @initializers[ AutoCode.normalize( key ) ] << Creator.new( options, &block ); self
+        @autocode[:constructors][ AutoCode.normalize( key ) ] << lambda do | cname |
+          exemplar = ( options[:exemplar] || Module.new ).clone
+          exemplar.module_eval( &block ) if block
+          const_set( cname, exemplar )
+        end
       end
 
       # Adds an auto_load block for the given key and directories
       def auto_load( key = true, options = {} )
-        @initializers[ AutoCode.normalize( key ) ].unshift( Loader.new( options ) ); self
+        @autocode[:constructors][ AutoCode.normalize( key ) ] << lambda do | cname |
+          filename = AutoCode.snake_case( cname ) << '.rb'
+          if options[:directories].nil?
+            Kernel.load( filename ) if File.exist?( filename )
+          else
+            path = options[:directories].
+              map { |dir| File.join( dir.to_s, filename ) }.
+              find { |path| File.exist?( path ) }
+            Kernel.load( path ) unless path.nil?
+          end
+        end
       end
 
       # Adds an arbitrary initializer block for the given key
       def auto_eval( key, &block )
-        @initializers[ AutoCode.normalize( key ) ] << Initializer.new( &block ); self
+        @autocode[:initializers][ AutoCode.normalize( key ) ] << lambda do | mod |
+          mod.module_eval( &block )
+        end
       end
 
       # Convenience method for auto_create.
@@ -68,37 +67,26 @@ module AutoCode
         auto_create( key,{ :exemplar => Module.new }, &block )
       end
 
-      # Reloading stuff ...
-      
       # Returns the list of constants that would be reloaded upon a call to reload.
-      def reloadable( *names ) ; @reloadable + names ; end
+      def reloadable ; @autocode[:loaded] ; end
 
-      # Reloads all the constants that were loaded via auto_code. Technically, all reload
-      # is doing is undefining them (by calling +remove_const+ on each in turn); they won't get
-      # reloaded until they are referenced.
-      def reload ; @reloadable.each { |name| remove_const( name ) } ; @reloadable = [] ; self; end
-
-      # Unloads all the constants that were loaded and removes all auto* definitions.
-      def unload ; reload ; @initializers = Hash.new { |h,k| h[k] = [] } ; self ; end
+      # Reloads (via #remove_const) all the constants that were loaded via auto_code.
+      def reload ; @autocode[:loaded].each { |name| remove_const( name ) } ; @autocode[:loaded] = [] ; end
 
       private
 
       old = method( :const_missing )
       (class << self ; self ; end ).instance_eval do
-        define_method :const_missing do | cname |
-          ( @initializers[cname] + @initializers[true] ).each do |initializer|
-            case initializer 
-            when Loader then initializer.call( cname ) unless const_defined?(cname)
-            when Creator then const_set( cname, initializer.call ) unless const_defined?(cname)
-            else
-              return old.call(cname) unless const_defined?( cname )
-              initializer.call( const_get( cname ) ) if const_defined?( cname )
-            end
-          end
-          return old.call(cname) unless const_defined?( cname )
-          @reloadable << cname ; const_get( cname )
+        define_method( :const_missing ) do | cname |
+          constructors = @autocode[:constructors][true] + @autocode[:constructors][cname]
+          constructors.pop.call( cname ) until ( const_defined?( cname ) or constructors.empty? )
+          return old.call( cname ) unless const_defined?( cname )
+          initializers = @autocode[:initializers][true] + @autocode[:initializers][cname]
+          mod = const_get( cname ) ; initializers.pop.call( mod ) until initializers.empty?
+          @autocode[:loaded] << cname ; const_get( cname )
         end
       end
     end
   end
-end
+end
+Autocode = AutoCode

data/test/auto_create.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'helpers.rb')
 describe "auto_create should" do
 
   before do
-    A.unload if defined? A and A.respond_to? :unload
+    Object.instance_eval { remove_const(:A) if const_defined?(:A) }
     module A
       include AutoCode
       auto_create_module :B do

data/test/auto_eval.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'helpers.rb')
 describe "auto_eval should" do
 
   before do
-    A.unload if defined? A and A.respond_to? :unload
+    Object.instance_eval { remove_const(:A) if const_defined?(:A) }
     module A
       include AutoCode
       auto_create_module :B
@@ -14,8 +14,8 @@ describe "auto_eval should" do
     end
     A.auto_eval :B do
       include AutoCode
-      auto_eval :R do
-        def self.foo; end
+      auto_eval :C do
+        self::D = true
       end
     end
   end
@@ -24,8 +24,8 @@ describe "auto_eval should" do
     A::B::C.class.should == Class
   end
   
-  specify "work inside an auto_* block" do
-    A::B::R.class.should == Class
+  specify "allow you to define nested auto_eval declarations" do
+    A::B::C::D.should == true
   end
 
 end

data/test/auto_load.rb

@@ -5,8 +5,8 @@ require 'extensions/io'
 describe "auto_load should" do
 
   before do
-    A.unload if defined? A and A.respond_to? :unload
-    FileUtils.mkdir('tmp')
+    Object.instance_eval { remove_const(:A) if const_defined?(:A) }
+    FileUtils.mkdir('tmp') rescue nil
     @path = File.join( 'tmp', 'b.rb' )
     content =<<-EOF
       module A
@@ -19,7 +19,6 @@ describe "auto_load should" do
       include AutoCode
       auto_create_class :B
       auto_load :B, :directories => ['tmp']
-      auto_create_class :B
     end
     
   end
@@ -33,20 +32,20 @@ describe "auto_load should" do
     A::B.class.should == Module
   end
   
+  specify "should implement LIFO semantics" do
+    A::B.class.should == Module
+  end
+
   specify "should raise a NameError if a const doesn't match" do
     lambda{ A::C }.should.raise NameError
   end
-  
-  specify "always take precedence over auto_create" do
-    A::B.class.should == Module
-  end
-  
+    
   specify "snake case the constant name which is used to map a constant to a filename" do
-    AutoCode::Loader.snake_case(:Post).should == "post"
-    AutoCode::Loader.snake_case(:GitHub).should == "git_hub"
-    AutoCode::Loader.snake_case(:GITRepository).should == "git_repository"
-    AutoCode::Loader.snake_case(:Git42Repository).should == "git42_repository"
-    AutoCode::Loader.snake_case(:GIT42Repository).should == "git42_repository"
+    AutoCode.snake_case(:Post).should == "post"
+    AutoCode.snake_case(:GitHub).should == "git_hub"
+    AutoCode.snake_case(:GITRepository).should == "git_repository"
+    AutoCode.snake_case(:Git42Repository).should == "git42_repository"
+    AutoCode.snake_case(:GIT42Repository).should == "git42_repository"
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dyoder-autocode
 version: !ruby/object:Gem::Version 
-  version: 0.9.8
+  version: 0.9.9
 platform: ruby
 authors: 
 - Dan Yoder
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-14 00:00:00 -07:00
+date: 2008-05-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency