dyoder-auto_code 0.9.8

data/lib/auto_code.rb

@@ -0,0 +1,104 @@
+module AutoCode
+  
+  # always make sure we have a camel-cased symbol
+  def AutoCode.normalize( cname )  
+    return cname unless cname.is_a? String
+    cname.gsub(/(_)(\w)/) { $2.upcase }.gsub(/^([a-z])/) { $1.upcase }.intern
+  end
+  
+  class Loader
+    def initialize(options={}); @directories = options[:directories] ; end
+    def call(cname)
+      if @directories.nil?
+        Kernel.load( Loader.snake_case( cname.to_s ) << '.rb' )
+      else
+        filename = Loader.snake_case( cname.to_s ) << '.rb'
+        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.gsub(/([a-z\d])([A-Z])/){"#{$1}_#{$2}"}.tr("-", "_").downcase
+    end
+  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.included( mod )
+    
+    mod.instance_eval do
+
+      # Initialize bookkeeping variables needed by AutoCode
+      @initializers = Hash.new { |h,k| h[k] = [] }; @reloadable = []
+      
+      # 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
+      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
+      end
+
+      # Adds an arbitrary initializer block for the given key
+      def auto_eval( key, &block )
+        @initializers[ AutoCode.normalize( key ) ] << Initializer.new( &block ); self
+      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 )
+      end
+
+      # Reloading stuff ...
+      
+      # Returns the list of constants that would be reloaded upon a call to reload.
+      def reloadable( *names ) ; @reloadable + names ; 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 = nil ; self; end
+
+      # Unloads all the constants that were loaded and removes all auto* definitions.
+      def unload ; reload ; @initializers = nil ; self ; 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 )
+        end
+      end
+    end
+  end
+end

data/test/auto_create.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'helpers.rb')
+
+describe "auto_create should" do
+
+  before do
+    A.reload if defined? A and A.respond_to? :reload
+    module A
+      include AutoCode
+      auto_create_module :B do
+        include AutoCode
+        auto_create_class
+      end
+    end
+  end
+  
+  specify "allow you create and initialize a given const name" do
+    A::B.class.should == Module
+  end
+  
+  specify "allow you create and initialize const using a wildcard" do
+    A::B::C.class.should === Class
+  end
+  
+  specify "should raise a NameError if a const doesn't match" do
+    lambda{ A::C }.should.raise NameError
+  end
+  
+end

data/test/auto_eval.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'helpers.rb')
+
+describe "auto_eval should" do
+
+  before do
+    A.reload if defined? A and A.respond_to? :reload
+    module A
+      include AutoCode
+      auto_create_module :B 
+      auto_eval :B do
+        include AutoCode
+        auto_create_class
+      end
+    end
+  end
+  
+  specify "allow you to run blocks after an object is first created" do
+    A::B::C.class.should == Class
+  end
+
+end

data/test/auto_load.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'helpers.rb')
+require 'extensions/io'
+
+
+describe "auto_load should" do
+
+  before do
+    A.reload if defined? A and A.respond_to? :reload
+    @path = File.join( 'auto_load', 'b.rb' ) 
+    content =<<-EOF
+module A
+  module B
+  end
+end
+EOF
+    File.write( @path, content )
+    module A
+      include AutoCode
+      auto_create_class :B
+      auto_load :B, :directories => [ 'auto_load' ]
+      auto_create_class :B
+    end
+    
+  end
+  
+  after do
+    FileUtils.rm( File.join( @path ) )
+  end
+  
+  specify "allow you to load a file to define a const" 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
+
+end

data/test/helpers.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+%w{ bacon metaid }.each { |dep| require dep }
+# Bacon.extend Bacon::TestUnitOutput
+Bacon.summary_on_exit
+
+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 '../lib/auto_code'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: dyoder-auto_code
+version: !ruby/object:Gem::Version 
+  version: 0.9.8
+platform: ruby
+authors: 
+- Dan Yoder
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-11 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/auto_code.rb
+- test/auto_create.rb
+- test/auto_eval.rb
+- test/auto_load
+- test/auto_load.rb
+- test/helpers.rb
+has_rdoc: true
+homepage: http://dev.zeraweb.com/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Utility for auto-including, reloading, and generating classes and modules.
+test_files: []
+