extlib 0.9.2 → 0.9.3

data/.autotest

@@ -0,0 +1,21 @@
+Autotest.add_hook :initialize do |at|
+  ignore = %w[ .git log plugins script tasks bin CHANGELOG FAQ MIT-LICENSE QUICKLINKS README ]
+
+  ignore.each do |exception|
+    at.add_exception(exception)
+  end
+
+  at.clear_mappings
+
+  at.add_mapping(%r{^spec/.+_spec\.rb$}) do |filename,_|
+    filename
+  end
+
+  at.add_mapping(%r{^lib/extlib/(.+)\.rb$}) do |_,match|
+    [ "spec/#{match[1]}_spec.rb" ]
+  end
+
+  at.add_mapping(%r{^spec/spec_helper\.rb$}) do
+    at.files_matching(%r{^spec/.+_spec\.rb$})
+  end
+end

data/History.txt

@@ -0,0 +1 @@
+

data/Manifest.txt

@@ -0,0 +1,29 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/extlib.rb
+lib/extlib/assertions.rb
+lib/extlib/blank.rb
+lib/extlib/hook.rb
+lib/extlib/inflection.rb
+lib/extlib/lazy_array.rb
+lib/extlib/module.rb
+lib/extlib/object.rb
+lib/extlib/pathname.rb
+lib/extlib/pooling.rb
+lib/extlib/string.rb
+lib/extlib/struct.rb
+lib/extlib/version.rb
+spec/blank_spec.rb
+spec/hook_spec.rb
+spec/inflection_spec.rb
+spec/lazy_array_spec.rb
+spec/module_spec.rb
+spec/object_spec.rb
+spec/pooling_spec.rb
+spec/spec_helper.rb
+spec/string_spec.rb
+spec/struct_spec.rb
+tasks/hoe.rb

data/README.txt

@@ -0,0 +1,3 @@
+= extlib
+
+A support library for DataMapper and DataObjects.

data/Rakefile

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+require 'pathname'
+require 'rubygems'
+require 'rake'
+require Pathname('spec/rake/spectask')
+require Pathname('lib/extlib/version')
+
+ROOT = Pathname(__FILE__).dirname.expand_path
+
+AUTHOR = "Sam Smoot"
+EMAIL  = "ssmoot@gmail.com"
+GEM_NAME = "extlib"
+GEM_VERSION = Extlib::VERSION
+GEM_DEPENDENCIES = [["english", ">=0.2.0"]]
+GEM_CLEAN = "*.gem", "**/.DS_Store"
+GEM_EXTRAS = { :has_rdoc => false }
+
+PROJECT_NAME = "extlib"
+PROJECT_URL  = "http://extlib.rubyforge.org"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY = "Support Library for DataMapper and DataObjects"
+
+require ROOT + 'tasks/hoe'
+
+task :default => 'extlib:spec'
+task :spec    => 'extlib:spec'
+
+desc 'Remove all package, docs and spec products'
+task :clobber_all => %w[ clobber_package clobber_doc extlib:clobber_spec ]
+
+namespace :extlib do
+  Spec::Rake::SpecTask.new(:spec) do |t|
+    t.spec_opts << '--format' << 'specdoc' << '--colour'
+    t.spec_opts << '--loadby' << 'random'
+    t.spec_files = Pathname.glob(ENV['FILES'] || 'spec/**/*_spec.rb')
+
+    begin
+      t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+      t.rcov_opts << '--exclude' << 'spec'
+      t.rcov_opts << '--text-summary'
+      t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    rescue Exception
+      # rcov not installed
+    end
+  end
+end
+
+desc "Generate documentation"
+task :doc do
+  begin
+    require 'yard'
+    exec 'yardoc'
+  rescue LoadError
+    puts 'You will need to install the latest version of Yard to generate the
+          documentation for extlib.'
+  end
+end
+
+WINDOWS = (RUBY_PLATFORM =~ /win32|mingw|bccwin|cygwin/) rescue nil
+SUDO    = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+desc "Install #{GEM_NAME}"
+task :install => :package do
+  sh %{#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}
+end
+
+if WINDOWS
+  namespace :dev do
+    desc 'Install for development (for windows)'
+    task :winstall => :gem do
+      system %{gem install --no-rdoc --no-ri -l pkg/#{GEM_NAME}-#{GEM_VERSION}.gem}
+    end
+  end
+end
+
+namespace :ci do
+
+  task :prepare do
+    rm_rf ROOT + "ci"
+    mkdir_p ROOT + "ci"
+    mkdir_p ROOT + "ci/doc"
+    mkdir_p ROOT + "ci/cyclomatic"
+    mkdir_p ROOT + "ci/token"
+  end
+
+  task :publish do
+    out = ENV['CC_BUILD_ARTIFACTS'] || "out"
+    mkdir_p out unless File.directory? out
+
+    mv "ci/unit_rspec_report.html", "#{out}/unit_rspec_report.html"
+    mv "ci/unit_coverage", "#{out}/unit_coverage"
+    mv "ci/integration_rspec_report.html", "#{out}/integration_rspec_report.html"
+    mv "ci/integration_coverage", "#{out}/integration_coverage"
+    mv "ci/doc", "#{out}/doc"
+    mv "ci/cyclomatic", "#{out}/cyclomatic_complexity"
+    mv "ci/token", "#{out}/token_complexity"
+  end
+
+
+  Spec::Rake::SpecTask.new("spec:unit" => :prepare) do |t|
+    t.spec_opts = ["--format", "specdoc", "--format", "html:#{ROOT}/ci/unit_rspec_report.html", "--diff"]
+    t.spec_files = Pathname.glob(ROOT + "spec/unit/**/*_spec.rb")
+    unless ENV['NO_RCOV']
+      t.rcov = true
+      t.rcov_opts << '--exclude' << "spec,gems"
+      t.rcov_opts << '--text-summary'
+      t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+      t.rcov_opts << '--only-uncovered'
+    end
+  end
+
+  Spec::Rake::SpecTask.new("spec:integration" => :prepare) do |t|
+    t.spec_opts = ["--format", "specdoc", "--format", "html:#{ROOT}/ci/integration_rspec_report.html", "--diff"]
+    t.spec_files = Pathname.glob(ROOT + "spec/integration/**/*_spec.rb")
+    unless ENV['NO_RCOV']
+      t.rcov = true
+      t.rcov_opts << '--exclude' << "spec,gems"
+      t.rcov_opts << '--text-summary'
+      t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+      t.rcov_opts << '--only-uncovered'
+    end
+  end
+
+  task :spec do
+    Rake::Task["ci:spec:unit"].invoke
+    mv ROOT + "coverage", ROOT + "ci/unit_coverage"
+
+    Rake::Task["ci:spec:integration"].invoke
+    mv ROOT + "coverage", ROOT + "ci/integration_coverage"
+  end
+
+  task :doc do
+    require 'yardoc'
+    sh 'yardoc'
+  end
+
+  task :saikuro => :prepare do
+    system "saikuro -c -i lib -y 0 -w 10 -e 15 -o ci/cyclomatic"
+    mv 'ci/cyclomatic/index_cyclo.html', 'ci/cyclomatic/index.html'
+
+    system "saikuro -t -i lib -y 0 -w 20 -e 30 -o ci/token"
+    mv 'ci/token/index_token.html', 'ci/token/index.html'
+  end
+end
+
+task :ci => ["ci:spec", "ci:doc", "ci:saikuro", :install, :publish]

data/lib/extlib/hook.rb

@@ -2,18 +2,21 @@ module Extlib
   #
   # TODO: Write more documentation!
   #
-  # Currently, before you can set a before or after hook on a method, you must
-  # register that method as hookable; otherwise, their invocation of the hook
-  # stack is not created.
+  # Overview
+  # ========
   #
-  # This can be done by calling #register_class_hooks to register one or more
-  # class methods as hookable or #register_instance_hooks to register one or
-  # more instance methods as hookable.
+  # The Hook module is a very simple set of AOP helpers. Basically, it
+  # allows the developer to specify a method or block that should run
+  # before or after another method.
   #
-  # Eventually, I'll probably have #before, #after, #before_class_method, and
-  # #after_class_method implicitly call #register_instance_hooks and
-  # #register_class_hooks respectivly. That way, if the exact hook insertion
-  # location does not need to be specified, hooks can be added on the fly.
+  # Usage
+  # =====
+  #
+  # Halting The Hook Stack
+  #
+  # Inheritance
+  #
+  # Other Goodies
   #
   # Please bring up any issues regarding Hooks with carllerche on IRC
   #
@@ -23,6 +26,17 @@ module Extlib
       base.extend(ClassMethods)
       base.const_set("CLASS_HOOKS", {}) unless base.const_defined?("CLASS_HOOKS")
       base.const_set("INSTANCE_HOOKS", {}) unless base.const_defined?("INSTANCE_HOOKS")
+      base.class_eval do
+        class << self
+          def method_added(name)
+            process_method_added(name, :instance)
+          end
+
+          def singleton_method_added(name)
+            process_method_added(name, :class)
+          end
+        end
+      end
     end
 
     module ClassMethods
@@ -120,6 +134,8 @@ module Extlib
 
       # --- Alright kids... the rest is internal stuff ---
 
+      # Returns the correct HOOKS Hash depending on whether we are
+      # working with class methods or instance methods
       def hooks_with_scope(scope)
         case scope
           when :class    then class_hooks
@@ -136,6 +152,15 @@ module Extlib
         self.const_get("INSTANCE_HOOKS")
       end
 
+      # Registers a method as hookable. Registering hooks involves the following
+      # process
+      #
+      # * Create a blank entry in the HOOK Hash for the method.
+      # * Define the methods that execute the before and after hook stack.
+      #   These methods will be no-ops at first, but everytime a new hook is
+      #   defined, the methods will be redefined to incorporate the new hook.
+      # * Redefine the method that is to be hookable so that the hook stacks
+      #   are invoked approprietly.
       def register_hook(target_method, scope)
         if scope == :instance && !method_defined?(target_method)
           raise ArgumentError, "#{target_method} instance method does not exist"
@@ -147,6 +172,10 @@ module Extlib
 
         if hooks[target_method].nil?
           hooks[target_method] = {
+            # We need to keep track of which class in the Inheritance chain the
+            # method was declared hookable in. Every time a child declares a new
+            # hook for the method, the hook stack invocations need to be redefined
+            # in the original Class. See #define_hook_stack_execution_methods
             :before => [], :after => [], :in => self
           }
 
@@ -155,10 +184,14 @@ module Extlib
         end
       end
 
+      # Is the method registered as a hookable in the given scope.
       def registered_as_hook?(target_method, scope)
         ! hooks_with_scope(scope)[target_method].nil?
       end
 
+      # Generates names for the various utility methods. We need to do this because
+      # the various utility methods should not end in = so, while we're at it, we
+      # might as well get rid of all punctuation.
       def hook_method_name(target_method, prefix, suffix)
         target_method = target_method.to_s
 
@@ -166,10 +199,29 @@ module Extlib
           when '?' then "#{prefix}_#{target_method[0..-2]}_ques_#{suffix}"
           when '!' then "#{prefix}_#{target_method[0..-2]}_bang_#{suffix}"
           when '=' then "#{prefix}_#{target_method[0..-2]}_eq_#{suffix}"
-          else "#{prefix}_#{target_method[0..-2]}_nan_#{suffix}"
+          # I add a _nan_ suffix here so that we don't ever encounter
+          # any naming conflicts.
+          else "#{prefix}_#{target_method[0..-1]}_nan_#{suffix}"
         end
       end
 
+      # This will need to be refactored
+      def process_method_added(method_name, scope)
+        hooks_with_scope(scope).each do |target_method, hooks|
+          if hooks[:before].any? { |hook| hook[:name] == method_name }
+            define_hook_stack_execution_methods(target_method, scope)
+          end
+
+          if hooks[:after].any? { |hook| hook[:name] == method_name }
+            define_hook_stack_execution_methods(target_method, scope)
+          end
+        end
+      end
+
+      # Defines two methods. One method executes the before hook stack. The other executes
+      # the after hook stack. This method will be called many times during the Class definition
+      # process. It should be called for each hook that is defined. It will also be called
+      # when a hook is redefined (to make sure that the arity hasn't changed).
       def define_hook_stack_execution_methods(target_method, scope)
         unless registered_as_hook?(target_method, scope)
           raise ArgumentError, "#{target_method} has not be registered as a hookable #{scope} method"
@@ -177,9 +229,6 @@ module Extlib
 
         hooks = hooks_with_scope(scope)
 
-        # before_hook_stack = "execute_before_" + "#{target_method}".sub(/([?!=]?$)/, '_hook_stack\1')
-        # after_hook_stack  = "execute_after_" + "#{target_method}".sub(/([?!=]?$)/, '_hook_stack\1')
-
         before_hooks = hooks[target_method][:before]
         before_hooks = before_hooks.map{ |info| inline_call(info, scope) }.join("\n")
 
@@ -200,14 +249,20 @@ module Extlib
 
         source = %{class << self\n#{source}\nend} if scope == :class
 
-        hooks[target_method][:in].class_eval(source)
+        hooks[target_method][:in].class_eval(source, __FILE__, __LINE__)
       end
 
+      # Returns ruby code that will invoke the hook. It checks the arity of the hook method
+      # and passes arguments accordingly.
       def inline_call(method_info, scope)
+        name = method_info[:name]
+
         if scope == :instance
-          %(#{method_info[:name]}(*args) if self.class <= ObjectSpace._id2ref(#{method_info[:from].object_id}))
+          args = method_defined?(name) && instance_method(name).arity != 0 ? '*args' : ''
+          %(#{name}(#{args}) if self.class <= ObjectSpace._id2ref(#{method_info[:from].object_id}))
         else
-          %(#{method_info[:name]}(*args) if self <= ObjectSpace._id2ref(#{method_info[:from].object_id}))
+          args = respond_to?(name) && method(name).arity != 0 ? '*args' : ''
+          %(#{name}(#{args}) if self <= ObjectSpace._id2ref(#{method_info[:from].object_id}))
         end
       end
 
@@ -215,8 +270,6 @@ module Extlib
         args = args_for(method_with_scope(target_method, scope))
 
         renamed_target = hook_method_name(target_method, 'hookable_', 'before_advised')
-        # before_hook_stack = "execute_before_" + "#{target_method}".sub(/([?!=]?$)/, '_hook_stack\1')
-        # after_hook_stack  = "execute_after_" + "#{target_method}".sub(/([?!=]?$)/, '_hook_stack\1')
 
         source = <<-EOD
           def #{target_method}(#{args})
@@ -224,9 +277,9 @@ module Extlib
             catch(:halt) do
               #{hook_method_name(target_method, 'execute_before', 'hook_stack')}(#{args})
               retval = #{renamed_target}(#{args})
-              #{hook_method_name(target_method, 'execute_after', 'hook_stack')}(#{args})
+              #{hook_method_name(target_method, 'execute_after', 'hook_stack')}(retval, #{args})
+              retval
             end
-            retval
           end
         EOD
 
@@ -234,12 +287,12 @@ module Extlib
           send(:alias_method, renamed_target, target_method)
 
           proxy_module = Module.new
-          proxy_module.class_eval(source)
+          proxy_module.class_eval(source, __FILE__, __LINE__)
           self.send(:include, proxy_module)
         else
           source = %{alias_method :#{renamed_target}, :#{target_method}\n#{source}}
           source = %{class << self\n#{source}\nend} if scope == :class
-          class_eval(source)
+          class_eval(source, __FILE__, __LINE__)
         end
       end
 
@@ -286,13 +339,13 @@ module Extlib
 
       def args_for(method)
         if method.arity == 0
-          ""
+          "&block"
         elsif method.arity > 0
-          "_" << (1 .. method.arity).to_a.join(", _")
+          "_" << (1 .. method.arity).to_a.join(", _") << ", &block"
         elsif (method.arity + 1) < 0
-          "_" << (1 .. (method.arity).abs - 1).to_a.join(", _") << ", *args"
+          "_" << (1 .. (method.arity).abs - 1).to_a.join(", _") << ", *args, &block"
         else
-          "*args"
+          "*args, &block"
         end
       end
 

data/lib/extlib/lazy_array.rb

@@ -1,10 +1,12 @@
 class LazyArray  # borrowed partially from StrokeDB
+  instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ send dup class object_id kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get ].include?(m) }
+
   include Enumerable
 
   # these methods should return self or nil
   RETURN_SELF = [ :<<, :clear, :concat, :collect!, :each, :each_index,
-    :each_with_index, :insert, :map!, :push, :replace, :reject!,
-    :reverse!, :reverse_each, :sort!, :unshift ]
+    :each_with_index, :freeze, :insert, :map!, :push, :replace,
+    :reject!, :reverse!, :reverse_each, :sort!, :unshift ]
 
   RETURN_SELF.each do |method|
     class_eval <<-EOS, __FILE__, __LINE__

data/lib/extlib/module.rb

@@ -1,19 +1,37 @@
 class Module
-  def find_const(nested_name)
-    self.__nested_constants__[nested_name]
-  rescue NameError
-    Object::__nested_constants__[nested_name]
+  def find_const(const_name)
+    if const_name[0..1] == '::'
+      Object.find_const(const_name[2..-1])
+    else
+      nested_const_lookup(const_name)
+    end
   end
 
-  protected  
-  def __nested_constants__
-    @__nested_constants__ ||= Hash.new do |h,k|
-      klass = self
-      k.split('::').each do |c|
-        klass = klass.const_get(c) unless c.empty?
+  private
+
+  # Doesn't do any caching since constants can change with remove_const
+  def nested_const_lookup(const_name)
+    constants = [ Object ]
+
+    unless self == Object
+      self.name.split('::').each do |part|
+        constants.unshift(constants.first.const_get(part))
       end
-      h[k] = klass
     end
+
+    parts = const_name.split('::')
+
+    # from most to least specific constant, use each as a base and try
+    # to find a constant with the name const_name within them
+    constants.each do |const|
+      # return the nested constant if available
+      return const if parts.all? do |part|
+        const = const.const_defined?(part) ? const.const_get(part) : nil
+      end
+    end
+
+    # if we get this far then the nested constant was not found
+    raise NameError, "uninitialized constant #{const_name}"
   end
-  
-end # class Module
+
+end # class Module