autocode 0.9.0

data/doc/rdoc/rdoc-style.css

@@ -0,0 +1,208 @@
+
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+
+/* === Structural elements =================================== */
+
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+
+
+div#index a {
+    margin-left: 0.7em;
+}
+
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+
+
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+
+
+div#fileHeader {
+    background: #057;
+}
+
+div#classHeader {
+    background: #048;
+}
+
+
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+
+
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+
+
+/* === Classes =================================== */
+
+table.header-table {
+    color: white;
+    font-size: small;
+}
+
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+
+
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+
+/* --- Context section classes ----------------------- */
+
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+
+/* --- Source code sections -------------------- */
+
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+
+/* --- Ruby keyword styles --------------------- */
+
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/autocode.rb

@@ -0,0 +1,3 @@
+require 'autocreate'
+require 'autoload'
+require 'reloadable'

data/lib/autocreate.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'metaid'
+
+# Extending a module with Autocreate allows you to specify autocreate rules for that module.
+#
+# Autocreate allows you to automatically created classes or modules based on a given exemplar at the time they are referenced.
+#
+# To use Autocreate, mix it via +extend+ into the class or module within which you want to autocreate referenced constants.
+# 
+# See the README for an example of how to use Autocreate.
+
+module Autocreate
+	
+	def self.extended( mod ) #:nodoc:
+
+		old = mod.method( :const_missing )
+		mod.metaclass.class_eval do
+
+			# Specifies that the constant specified by key should be autocreated using the exemplar. If a block is given, the block is further used to initialize the block once it has been cloned.
+			def autocreate( key, exemplar, &block )
+				( @autocreate ||= [] ) << [ key, exemplar, block ]
+				return self
+			end
+
+			define_method :const_missing do | cname | #:nodoc:
+
+				# first, find an applicable exemplar	
+				key, exemplar, block = ( @autocreate ||= [] ).find do |k,v|
+					case k
+						when true then true
+						when String, Symbol then k.to_s == cname.to_s 
+						when Array then k.find { |k| k.to_s == cname.to_s }
+						else false
+					end
+				end
+
+				# if we found it, set the const and return it
+				if key 
+					object = exemplar.clone
+					object.instance_eval( &block ) if block
+					( @reloadable ||= [] ) << cname; 
+					const_set( cname, object )
+				else
+					old.call(cname)
+				end
+
+			end
+
+		end
+
+	end
+
+end

data/lib/autoload.rb

@@ -0,0 +1,69 @@
+require 'rubygems'
+require 'metaid'
+
+# Autoload allows you to specify which modules or classes to automatically load when they are referenced. This is somewhat more sophisticated than the +autoinclude+ mechanism in the standard library. For one thing, you can cause code to be reloaded by using Reloadable in conjunction with Autoload. For another, you can provide a search path using the directories method, thereby allowing you to "autoinclude" entire directories in one fell swoop.
+#
+# To use Autoload, you must mix it into your module or class via extend. That will provide the autoload and directories methods for you, as described below.
+#
+# A typical use case for Autoload looks like this:
+#
+#   require 'autocode'
+#   
+#   module Models
+#     extend Autoload; extend Reloadable
+#     autoload true; directories :models
+#   end
+
+module Autoload
+	
+	def self.extended( mod ) #:nodoc:
+
+		old = mod.method( :const_missing )
+		
+		mod.metaclass.class_eval do
+
+			# Specifies that you want to autoload each of the constants referenced by keys. A key of true is basically a wild-card, meaning "load anything". 
+			def autoload( *keys )
+				( @autoload ||= [] ).concat(keys)
+				return self
+			end
+			
+			# Provide a list of directories from which a given constant might be loaded.
+			def directories( *dirs )
+				( @directories ||= ['.'] ).concat(dirs)
+				return self
+			end
+			
+			# Is a given constant being autoloaded?
+			def autoload?( cname )
+
+				cname = cname.to_s.gsub(/([a-z\d])([A-Z])/){ "#{$1}_#{$2.downcase}"}
+				
+				# is this name autoloadable?
+				key = ( @autoload ||= [] ).find do |key| 
+					key == true || ( key.to_s == cname )
+				end
+				
+			end
+
+			define_method :const_missing do | cname | #:nodoc:
+				
+				return old.call(cname) unless autoload?( cname )
+				fname = cname.to_s.gsub(/([a-z\d])([A-Z])/){ "#{$1}_#{$2.downcase}"} + '.rb'
+				dir = ( @directories ||= ['.'] ).find do |dir|
+					File.exist?( dir / fname )
+				end
+				
+				if ( dir && load( dir / fname ) && c = const_get( cname ) )
+					( @reloadable ||= [] ) << cname; return c
+				else 
+					old.call( cname )
+				end
+				
+			end
+		
+		end
+		
+	end
+
+end

data/lib/reloadable.rb

@@ -0,0 +1,30 @@
+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

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: autocode
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+date: 2008-01-04 00:00:00 -08:00
+summary: Utility for auto-including, reloading, and generating classes and modules.
+require_paths: 
+- lib
+email: 
+homepage: http://dev.zeraweb.com/
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: []
+
+files: 
+- doc/rdoc
+- doc/rdoc/classes
+- doc/rdoc/classes/Autocreate.html
+- doc/rdoc/classes/Autocreate.src
+- doc/rdoc/classes/Autocreate.src/M000004.html
+- doc/rdoc/classes/Autoload.html
+- doc/rdoc/classes/Autoload.src
+- doc/rdoc/classes/Autoload.src/M000001.html
+- doc/rdoc/classes/Autoload.src/M000002.html
+- doc/rdoc/classes/Autoload.src/M000003.html
+- doc/rdoc/classes/Reloadable.html
+- doc/rdoc/classes/Reloadable.src
+- doc/rdoc/classes/Reloadable.src/M000005.html
+- doc/rdoc/classes/Reloadable.src/M000006.html
+- doc/rdoc/created.rid
+- doc/rdoc/files
+- doc/rdoc/files/lib
+- doc/rdoc/files/lib/autocode_rb.html
+- doc/rdoc/files/lib/autocreate_rb.html
+- doc/rdoc/files/lib/autoload_rb.html
+- doc/rdoc/files/lib/reloadable_rb.html
+- doc/rdoc/files/README.html
+- doc/rdoc/fr_class_index.html
+- doc/rdoc/fr_file_index.html
+- doc/rdoc/fr_method_index.html
+- doc/rdoc/index.html
+- doc/rdoc/rdoc-style.css
+- lib/autocode.rb
+- lib/autocreate.rb
+- lib/autoload.rb
+- lib/reloadable.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: