autoloader 0.0.2

data/README

@@ -0,0 +1,46 @@
+A couple of handy features to enhance Kernel#autoload.
+
+
+Features
+========
+
+ * Fire Kernel#autoload at an entire directory
+ * Fire it again at a subdirectory, for namespace'd models
+
+
+Motivation/Examples
+===================
+
+I was using Ramaze as a web framework, and discovered that the standard Ramaze way of loading a directory of files is to slurp them all (with 'acquire'). I decided I'd rather use autoload, and not load things I'm not using. But I wasn't really looking forward to this:
+
+autoload :User, 'model/user'
+autoload :Clan, 'model/clan'
+autoload :Item, 'model/item'
+
+...ad nauseum. So, the first feature is a shallow, directory-based autoload:
+
+AutoLoader << 'model'
+
+Of course, being a pedant, I like to namespace my models. I don't want to slurp the entire directory tree. Instead, you can do this:
+
+class User < MyFavoriteORM::Model
+  include AutoLoader
+  ...
+end
+
+Now, all AutoLoaded paths will be searched for a subdirectory called 'user', and all files within will be autoloaded. Just as if you'd done:
+
+User.autoload :Anonymous, 'model/user/anonymous'
+User.autoload :Registered, 'model/user/registered'
+
+Of course, there's no requirement that you have a base class, or anything of the sort. If you just want a namespace, you can always do:
+
+module MyNamespace; include AutoLoader; end
+
+And you're done.
+
+
+Compatibility
+=============
+
+Currently, Merb's extlib and Rails' activesupport are supported. It should be trivial to interface with other libraries.

data/lib/autoloader.rb

@@ -0,0 +1,105 @@
+autoload :Set, 'set'
+autoload :Pathname, 'pathname'
+
+module AutoLoader
+  
+  EXTENSIONS = %w{rb o}.map(&:freeze).freeze
+  
+  # We need some sort of inflection library.
+  # Note: Sequel provides its own inflector, too...
+  # This should be done in a more extensible way.
+  def self.own_dependencies
+    require 'extlib/string'
+  rescue LoadError
+    begin
+      require 'active_support/inflector'
+    rescue LoadError
+      require 'rubygems'
+      gem 'activesupport'
+      require 'active_support/inflector'
+    end
+  end
+  
+  # Find a method that the object responds to, and execute that.
+  # If no methods match, load dependencies and try again.
+  def self._try_methods object, *methods
+    method = methods.find {|m| object.respond_to? m}
+    if method
+      object.send method
+    else
+      nil
+    end
+  end
+  def self.try_methods object, *methods
+    self._try_methods(object, *methods) || (
+      self.own_dependencies
+      self._try_methods(object, *methods) || raise(NoMethodError, methods.first.to_s)
+    )
+  end
+  
+  # Semi-agnostic inflections.
+  # Send patches, feel free to monkeypatch it, or
+  # define your own camelize/underscore methods.
+  def self.to_file_name string
+    self.try_methods string, :to_const_path, :camelize
+  end
+  def self.to_const_name string
+    self.try_methods string, :to_const_string, :underscore
+  end
+  
+  
+  def self.paths
+    @paths ||= Set.new
+  end
+  
+  def self.push *args
+    args.each do
+      self << args
+    end
+  end
+  
+  def self.<< path
+    unless self.paths.include? path
+      self.paths << path
+      unless $:.include? path
+        $: << path
+      end
+      
+      self.update(:path => path)
+    end
+  end
+  
+  def self.update(options)
+    if !options[:path]
+      self.paths.each {|p| self.update(options.merge(:path => p))}
+    else
+      
+      path = Pathname.new options[:path]
+      parent = options[:parent]
+      
+      glob_path = parent.nil? ? path : path.join(self.to_file_name parent.name)
+      
+      EXTENSIONS.each do |ext|
+        Pathname.glob(glob_path.join("*.#{ext}").to_s).each do |file|
+          basename = file.basename(file.extname)
+          
+          camelized = self.to_const_name basename.to_s
+          next unless camelized =~ /^[A-Z]\w*/
+          
+          req_path = file.parent.relative_path_from(path).join(basename).to_s
+          
+          if parent.nil?
+            Object.autoload camelized, req_path
+          else
+            parent.autoload camelized, req_path
+          end
+        end
+      end
+    end
+  end
+  
+  # Some syntactic sugar
+  def self.included mod
+    self.update(:parent => mod)
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: autoloader
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- David Masover
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-07 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ninja@slaphack.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/autoloader.rb
+has_rdoc: true
+homepage: http://github.com/masover/autoloader
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Crawl a directory at a time, adding files via Kernel#autoload
+test_files: []
+