dyoder-autocode 0.9.3 → 0.9.4

data/lib/autocode.rb

@@ -1,8 +1,10 @@
-require 'reloadable'
-
 module Autocode
+  
+  def self.extended( mod )
+    included(mod)
+  end
 	
-	def self.extended( mod ) #:nodoc:
+	def self.included( mod )
 
 		old = mod.method( :const_missing )
 		mod.metaclass.class_eval do
@@ -23,6 +25,14 @@ module Autocode
 				return self
 			end
 			
+			def autocreate_class( key = true, superclass = nil )
+			  autocreate key, Class.new( superclass )
+			end
+			
+			def autocreate_module( key = true )
+			  autocreate key, Module.new
+			end
+			
 			def autoinit( key, &block )
   		  # See whether we're dealing with a namespaced constant,
   		  # The match groupings for,  e.g. "X::Y::Z", would be
@@ -41,34 +51,55 @@ module Autocode
   			return self
   		end
 		  
-		  def autoload( key, options )
+		  def autoload(key = true, options = {})
+		    snake_case = lambda {|name| name.gsub(/([a-z\d])([A-Z])/){"#{$1}_#{$2}"}.tr("-", "_").downcase }
 		    # look for load_files in either a specified directory, or in the directory
 		    # with the snakecase name of the enclosing module
-		    directories = [options[:directories] || default_directory(self.name)].flatten
+		    directories = [options[:directories] || snake_case.call(self.name.match( /^.*::([\w\d_]+)$/)[1])].flatten
         # create a lambda that looks for a file to load
         file_finder = lambda do |cname|
-          filename = default_file_name(cname)
-          dirname = directories.find do |dir|
-  			    File.exist?(File.join(dir.to_s, filename))
-  			  end
-  			  dirname ? File.join(dirname.to_s, filename) : nil
+          filename = snake_case.call(cname.to_s << ".rb")
+          path = directories.map { |dir| File.join(dir.to_s, filename) }.find { |path| File.exist?( path ) }
         end
         # if no exemplar is given, assume Module.new
 			  @load_files ||= Hash.new
-        @load_files[key] = [file_finder, options[:exemplar]]
+        @load_files[key] = [file_finder, options[:exemplar] || Module.new]
 				return self
 		  end
 		  
-		  def autoload_class(key, superclass=nil, options={})
+		  def autoload_class(key = true, superclass = nil, options = {})
 		    options[:exemplar] = Class.new(superclass)
 		    autoload key, options
 		  end
 		  
-		  def autoload_module(key, options={})
+		  def autoload_module(key = true, options = {})
 		    options[:exemplar] = Module.new
 		    autoload key, options
 		  end
-		  
+
+			# Returns the list of constants that would be reloaded upon a call to reload.
+			def reloadable( *names ) 
+				( @reloadable ||= [] ).concat(names)
+				return self
+			end
+			
+			# Reloads all the constants that were loaded via autocode. 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 ) } if @reloadable
+				@reloadable = nil
+				return self
+			end		  
+			
+      # Unloads all the constants that were loaded and removes all auto* definitions.
+			def unload
+				reload
+        @exemplars = @init_blocks = @load_files = nil
+				return self
+			end
+			
+			private		
 		  
 		  define_method :const_missing do | cname | #:nodoc:
         cname = cname.to_sym
@@ -97,16 +128,7 @@ module Autocode
         load(filename) if filename
 				return object
 			end
-			
-			def default_file_name(cname)
-			 ( cname.to_s.gsub(/([a-z\d])([A-Z\d])/){ "#{$1}_#{$2}"} << ".rb" ).downcase
-			end
-			
-			def default_directory(module_name)
-			  m = self.name.match( /^.*::([\w\d_]+)$/)
-			  m[1].snake_case
-			end
-		  
+					  
 	  end
   end
 end

data/test/autocreate.rb

@@ -14,6 +14,10 @@ describe "A module where autocreate has been called" do
     end
   end
   
+  after do
+    Thingy.unload
+  end
+
   it "should autocreate some constants" do
     Thingy::Tom.peeps.should == true
     Thingy::Dick.peeps.should == false
@@ -33,6 +37,7 @@ describe "A module where autocreate has been called" do
     end
     
     Duffel::AnyThing.universal.should == true
+    Duffel.unload
   end
   
 end

data/test/autoinit.rb

@@ -37,6 +37,13 @@ describe "thingy" do
     end
   end
   
+  after do
+    Thingy::Whatsit.unload    
+    Thingy::Big::Bad.unload
+    Thingy::Big.unload
+    Thingy.unload    
+  end  
+  
   it "fdfdsf" do
     Thingy::Whatsit.in_scope.should.be.true
     Thingy::Whatsit::Critter.outside_scope.should.be.true

data/test/autoload.rb

@@ -10,15 +10,45 @@ describe "A module where autoload has been called" do
         autoload_module :Humbug, :directories => [File.join(File.dirname(__FILE__), "test_lib")]
       end
     end
+    module Waves
+      module TestLib
+        extend Autocode
+        autoload true, :exemplar => Module.new
+      end
+    end
+    module Whatever
+      module TestLib
+        extend Autocode
+        autoload
+      end
+    end
   end
   
+  after do
+    Thingy::Mabob.unload
+    Waves::TestLib.unload
+    Whatever::TestLib.unload
+  end
+
   it "should autoload where files match" do  
     Thingy::Mabob::DooDad.should.respond_to :gizmo
     Thingy::Mabob::Humbug.should.respond_to :full_of_it?
   end
   
+  it "should not autoload where it matches a file but is out of scope" do
+    lambda { Thingy::Whatsit::Critter }.should.raise NameError
+  end
+  
   it "should not autocreate those unmentioned and fileable" do
     lambda { Thingy::Mabob::MooCow }.should.raise NameError
   end
   
+  it "should autoload using default directories" do
+    Waves::TestLib::TheHelperModule.should.respond_to :help
+  end
+
+  it "should allow default options" do
+    Whatever::TestLib::TheOneAndOnly.should.respond_to :help
+  end
+  
 end

data/test/helpers.rb

@@ -1,8 +1,7 @@
-%w{ rubygems bacon}.each { |dep| require dep }
+%w{ rubygems bacon metaid }.each { |dep| require dep }
 Bacon.extend Bacon::TestUnitOutput
 Bacon.summary_on_exit
 
-$:.unshift File.join(File.dirname(__FILE__) , "lib")
+$:.unshift File.join(File.dirname(__FILE__) , "../lib")
 require 'autocode'
 
-# Dir.chdir(File.dirname(__FILE__))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dyoder-autocode
 version: !ruby/object:Gem::Version 
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors: 
 - Dan Yoder

data/lib/reloadable.rb

@@ -1,30 +0,0 @@
-require 'rubygems'
-require 'metaid'
-
-# Reloadable simply makes it possible for a module's code to be reloaded. *Important*: Only code loaded via Autoload or Autocreate will be reloaded. Also, the module itself is not reloaded, only the modules and classes within it that were loaded via *Autocode*.
-#
-# To use Reloadable, simply extend a given module with Reloadable. This will add two methods to the module: reloadable and reload. These are described below.
-
-module Reloadable
-	
-	def self.extended( mod ) #:nodoc:
-
-		mod.metaclass.class_eval do
-			
-			# Returns the list of constants that would be reloaded upon a call to reload.
-			def reloadable( *names ) 
-				( @reloadable ||= [] ).concat(names)
-				return self
-			end
-			
-			# Reloads all the constants that were loaded via *Autocode*. 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 = []; return self
-			end
-	
-		end
-		
-	end
-	
-end