autocode 1.0.0 → 1.0.1

data/lib/autocode.rb

@@ -1,13 +1,20 @@
 module AutoCode
   
+  def self.monitor
+    require 'monitor'
+    @monitor ||= Monitor.new
+  end
+  
   # always make sure we have a camel-cased symbol
   def AutoCode.normalize( cname )
     return cname  unless cname.is_a? Symbol or cname.is_a? String
-    camel_case( cname )
+    camel_case( cname ).intern
   end
   
   def AutoCode.camel_case( cname )  
-    cname.to_s.gsub(/^([a-z])/) { $1.upcase }.gsub(/(_)(\w)/) { $2.upcase }.intern
+    cname.to_s.split('_').map do |word|
+      "#{word.slice(/^\w/).upcase}#{word.slice(/^\w(\w+)/, 1)}"
+    end.join
   end
   
   def AutoCode.snake_case( cname )
@@ -19,23 +26,57 @@ module AutoCode
   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
-      @autocode = { 
-        :constructors => Hash.new { |h,k| h[k] = [] },
-        :initializers => Hash.new { |h,k| h[k] = [] },
-        :loaded => []
-      }
+      AutoCode.monitor.enter
+      begin
+        # First make sure we haven't already done this once
+        return unless @autocode.nil?
+      
+        # Initialize bookkeeping variables needed by AutoCode
+        @autocode = { 
+          :constructors => Hash.new { |h,k| h[k] = [] },
+          :initializers => Hash.new { |h,k| h[k] = [] },
+          :loaded => []
+        }
+      ensure
+        AutoCode.monitor.exit
+      end
+      
+      def auto_constructor( key = true, &block)
+        @autocode[:constructors][ AutoCode.normalize( key ) ] << block
+      end
       
-      # Adds an auto_create block for the given key using the given exemplar if provided
       def auto_create( key = true, options = {}, &block )
-        @autocode[:constructors][ AutoCode.normalize( key ) ] << lambda do | cname |
-          exemplar = ( options[:exemplar] || Module.new ).clone
-          exemplar.module_eval( &block ) if block
-          const_set( cname, exemplar )
+        auto_constructor( key ) do | cname |
+          exemplar = options[:exemplar] || Module.new
+          new_constant = exemplar.clone
+          new_constant.send(:include, AutoCode)
+          ret = const_set( cname, new_constant )
+          new_constant.module_eval( &block ) if block
+          ret
+        end
+      end
+      
+      # Convenience method for auto_creating classes.
+      def auto_create_class( key = true, parent = Object, &block )
+        auto_constructor( key ) do | cname |
+          parent = const_get(parent) unless parent.is_a? Class
+          new_constant = Class.new( parent )
+          new_constant.send(:include, AutoCode)
+          ret = const_set( cname, new_constant )
+          new_constant.module_eval( &block ) if block
+          ret
+        end
+      end
+
+      # Convenience method for auto_creating modules.
+      def auto_create_module( key = true, &block )
+        auto_constructor( key ) do | cname |
+          new_constant = Module.new
+          new_constant.send(:include, AutoCode)
+          ret = const_set( cname, new_constant )
+          new_constant.module_eval( &block ) if block
+          ret
         end
       end
 
@@ -43,54 +84,68 @@ module AutoCode
       def auto_load( key = true, options = {} )
         @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 )
+          options[:directories] ||= '.'
+          path = if target = options[:target]
+            target.call(cname)
           else
-            path = options[:directories].
-              map { |dir| File.join( dir.to_s, filename ) }.
-              find { |path| File.exist?( path ) }
-            Kernel.load( path ) unless path.nil?
+            options[:directories].
+            map { |dir| File.join( dir.to_s, filename ) }.
+            find { |path| File.exist?( path ) }
           end
+          Kernel.load( path ) unless path.nil?
         end
       end
 
       # Adds an arbitrary initializer block for the given key
       def auto_eval( key, &block )
-        @autocode[:initializers][ AutoCode.normalize( key ) ] << lambda do | mod |
-          mod.module_eval( &block )
+        if key.is_a?( Symbol) && const_defined?( AutoCode.normalize( key ) )
+          const_get( key ).module_eval( &block)
+        else
+          @autocode[:initializers][ AutoCode.normalize( key ) ] << lambda do | mod |
+            mod.module_eval( &block )
+          end
         end
       end
-
-      # Convenience method for auto_create.
-      def auto_create_class( key = true, superclass = Object, &block )
-        auto_create( key,{ :exemplar => Class.new( superclass ) }, &block )
-      end
-
-      # Convenience method for auto_create.
-      def auto_create_module( key = true, &block )
-        auto_create( key,{ :exemplar => Module.new }, &block )
+      
+      def auto_const?(cname)
+        true unless @autocode[:constructors][ AutoCode.normalize( cname ) ].empty?
       end
 
       # Returns the list of constants that would be reloaded upon a call to reload.
       def reloadable ; @autocode[:loaded] ; 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
+      def reload
+        Autocode.monitor.synchronize do
+          @autocode[:loaded].each { |name| remove_const( name ) } ; @autocode[:loaded] = []
+        end
+      end
 
       private
 
       old = method( :const_missing )
       (class << self ; self ; end ).instance_eval do
         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.shift.call( mod ) until initializers.empty?
-          @autocode[:loaded] << cname ; const_get( cname )
+
+          Autocode.monitor.synchronize do
+            # check to see if some other thread loaded the constant before
+            # we entered the lock.
+            return const_get( cname ) if const_defined?( cname )
+            actions = []
+            @autocode[:constructors].each do |matcher,action|
+              actions.concat action if (matcher == true || matcher == cname || matcher === cname.to_s )
+            end
+            actions.reverse!.find { | c | c.call( cname ) and const_defined?( cname ) }
+            return old.call( cname ) unless const_defined?( cname )          
+            initializers = @autocode[:initializers][true] + @autocode[:initializers][cname]
+            mod = const_get( cname ); initializers.each { |init| init.call( mod ) }
+            @autocode[:loaded] << cname
+            mod
+          end
         end
       end
     end
   end
 end
-Autocode = AutoCode
+Autocode = AutoCode
+

data/lib/rack/reload.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rack'
+module Rack
+  class Reload
+    
+    def initialize(app, *reloadable)
+      @app = app
+      @reloadable = reloadable
+    end
+
+    def call(env)
+      @reloadable.each { |mod| mod.reload }
+      @app.call(env)
+    end
+    
+  end
+end

data/test/auto_create.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helpers.rb')
+require "#{File.dirname(__FILE__)}/helpers"
 
 describe "auto_create" do
 
@@ -7,22 +7,62 @@ describe "auto_create" do
     module A
       include AutoCode
       auto_create_module :B do
-        include AutoCode
-        auto_create_class
+        
+        def self.smurf; "blue" ; end
+        
+        auto_create_module true do
+          def self.pixie; "brown" ; end
+        end
+        
       end
     end
   end
   
-  specify "allows you to create and initialize a given const name" do
-    A::B.class.should == Module
+  it "allows you create and initialize a given const name" do
+    A::B.smurf.should == "blue"
   end
   
-  specify "allows you to create and initialize const using a wildcard" do
-    A::B::C.class.should === Class
+  it "allows you create and initialize const using a wildcard" do
+    A::B::C.pixie.should == "brown"
   end
   
-  specify "raises a NameError if a const doesn't match" do
-    lambda{ A::C }.should.raise NameError
+  it "allows you to refer to auto-constructed constants using symbols" do
+    module K
+      include AutoCode
+      auto_create_class true, :C
+      auto_create_class :C
+    end
+    K::C
+    K::D.superclass.should == K::C
+  end
+  
+  it "lets you use Module.name in the init block" do
+    module L
+      include AutoCode
+      auto_create_class true do
+        auto_create_class self.name.split("::").last.upcase.reverse do
+          def self.foo; "bar" ; end
+        end
+      end
+    end
+    L::WONK::KNOW.foo.should == "bar"
+  end
+  
+  it "raises a NameError if a const doesn't match" do
+    lambda{ A::C }.should raise_error( NameError)
+  end
+  
+  it "can take a Regexp as a key" do
+    module M
+      include AutoCode
+      auto_create_module(/V\d+/) do
+        def self.thing
+          name.split("::").last.reverse
+        end
+      end
+    end
+    M::V2.thing.should == "2V"
+    M::V3.thing.should == "3V"
   end
   
 end

data/test/auto_eval.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helpers.rb')
+require "#{File.dirname(__FILE__)}/helpers"
 
 describe "auto_eval" do
 
@@ -27,5 +27,6 @@ describe "auto_eval" do
   specify "allows you to define nested auto_eval declarations" do
     A::B::C::D.should == true
   end
+  
 
 end

data/test/auto_load.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helpers.rb')
+require "#{File.dirname(__FILE__)}/helpers"
 require 'extensions/io'
 
 
@@ -15,12 +15,6 @@ describe "auto_load" do
       end
     EOF
     File.write( @path, content )
-    module A
-      include AutoCode
-      auto_create_class :B
-      auto_load :B, :directories => ['tmp']
-    end
-    
   end
   
   after do
@@ -29,15 +23,39 @@ describe "auto_load" do
   end
   
   specify "allows you to load a file to define a const" do
+    module A
+      include AutoCode
+      auto_create_class :B
+      auto_load :B, :directories => ['tmp']
+    end
     A::B.class.should == Module
   end
   
   specify "should implement LIFO semantics" do
+    module A
+      include AutoCode
+      auto_create_class :B
+      auto_load :B, :directories => ['tmp']
+    end
     A::B.class.should == Module
   end
 
   specify "raises a NameError if a const doesn't match" do
-    lambda{ A::C }.should.raise NameError
+    module A
+      include AutoCode
+      auto_create_class :B
+      auto_load :B, :directories => ['tmp']
+    end
+    lambda{ A::C }.should raise_error( NameError )
+  end
+
+  it "can use a lambda to specify the target file" do
+    module A
+      include AutoCode
+      auto_create_class :B
+      auto_load :B, :target => lambda {|cname| "tmp/#{cname.to_s.downcase}.rb" }
+    end
+    A::B.class.should == Module 
   end
 
-end
+end

data/test/helpers.rb

@@ -1,15 +1,3 @@
-require 'rubygems'
-%w{ bacon }.each { |dep| require dep }
-# Bacon.extend Bacon::TestUnitOutput
-Bacon.summary_on_exit
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
 
-module Kernel
-  private
-  def specification(name, &block)  Bacon::Context.new(name, &block) end
-end
-
-Bacon::Context.instance_eval do
-  alias_method :specify, :it
-end
-
-require "#{File.dirname(__FILE__)}/../lib/autocode"
+require 'autocode'

data/test/introspection.rb

@@ -0,0 +1,15 @@
+require "#{File.dirname(__FILE__)}/helpers"
+
+describe "A module that has included AutoCode" do
+  
+  it "can tell you whether a subconstant has an auto-constructor" do
+    module A
+      include AutoCode
+      auto_create_module :B
+    end
+    
+    A.auto_const?(:B).should be_true
+    A.auto_const?(:C).should_not be_true
+  end
+  
+end

data/test/least_surprise.rb

@@ -0,0 +1,61 @@
+require "#{File.dirname(__FILE__)}/helpers"
+
+describe "An auto_created module" do
+
+  before do
+    Object.instance_eval { remove_const(:A) if const_defined?(:A) }
+    module A
+      module Foo; end
+      include AutoCode
+      auto_create_class :B do
+        def kobold
+          "koboldy"
+        end
+      end
+    end
+  end
+  
+  it "automatically includes AutoCode" do
+    A::B.included_modules.should include( AutoCode )
+  end
+  
+  it "can be initialized by later auto_eval declarations" do
+    A.auto_eval(:B) { def smurf; "smurfy" ; end }
+    A::B.new.kobold.should == "koboldy"
+    A::B.new.smurf.should == "smurfy"
+  end
+  
+  it "can be referenced in auto_* declarations without getting born" do
+    A.auto_create_class :C, :B
+    A.const_defined?(:B).should == false
+    A::C.new.kobold.should == "koboldy"
+  end
+  
+end
+
+describe "auto_eval" do
+  
+  it "does a module_eval for constants that are already defined" do
+    A.auto_eval :Foo do
+      def self.yell; "Brick!" ; end
+    end
+    A::Foo.yell.should == "Brick!"
+  end
+  
+end
+
+
+from_waves = lambda do
+  app.auto_create_module( :Views ) do
+    include AutoCode
+    auto_create_class :Default, Waves::Views::Base
+    auto_load :Default, :directories => [ :views ]
+    auto_create_class true, :Default
+    auto_load true, :directories => [ :views ]
+  end
+  app.auto_eval :Views do
+    auto_eval :Default do
+      include ViewMethods
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: autocode
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Dan Yoder
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-09 00:00:00 -05:00
+date: 2009-08-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,10 +25,14 @@ extra_rdoc_files: []
 
 files: 
 - lib/autocode.rb
+- lib/rack
+- lib/rack/reload.rb
 - test/auto_create.rb
 - test/auto_eval.rb
 - test/auto_load.rb
 - test/helpers.rb
+- test/introspection.rb
+- test/least_surprise.rb
 - test/normalize.rb
 has_rdoc: true
 homepage: http://dev.zeraweb.com/
@@ -52,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: autocode
-rubygems_version: 1.0.1
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Utility for auto-including, reloading, and generating classes and modules.