extlib 0.9.10 → 0.9.11

data/History.txt

@@ -1,3 +1,23 @@
+=== 0.9.11 / not released
+
+* 1 major enhancement:
+
+  * Added LazyModule, providing similar capabilities to traits in
+    Smalltalk
+
+* 5 minor enhancements:
+
+  * Added Array#to_hash and Array#to_mash
+  * Silenced warnings when running in verbose mode
+  * Add ByteArray for representing binary data explicitly
+  * Alias Pathname#to_s to Pathname#to_str when not defined
+  * Added Object#try_call
+
+* 2 bug fixes:
+
+  * Updated Module.find_const to use const_missing if constant not found
+  * Fixed LazyArray#equal? to compare object_ids
+
 === 0.9.10 / 2009-01-19
 
 * 1 major enhancement:
@@ -9,7 +29,7 @@
   * Updated LazyArray#eql? and LazyArray#== to compare without lazy
     loading if possible.
 
-3 bug fixes:
+* 3 bug fixes:
 
   * Fix for inheritance and hooks
   * Fix for Class inheritable accessor to use #try_dup

data/Rakefile

@@ -9,7 +9,10 @@ require "fileutils"
 require Pathname('spec/rake/spectask')
 require Pathname('lib/extlib/version')
 
-ROOT = Pathname(__FILE__).dirname.expand_path
+ROOT    = Pathname(__FILE__).dirname.expand_path
+JRUBY   = RUBY_PLATFORM =~ /java/
+WINDOWS = Gem.win_platform?
+SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
 
 ##############################################################################
 # Package && release
@@ -26,15 +29,7 @@ GEM_NAME    = "extlib"
 PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 GEM_VERSION = Extlib::VERSION + PKG_BUILD
 
-RELEASE_NAME    = "REL #{GEM_VERSION}"
-
-WINDOWS = (RUBY_PLATFORM =~ /win32|mingw|bccwin|cygwin/) rescue nil
-JRUBY   = (RUBY_PLATFORM =~ /java/) rescue nil
-
-# sudo is used by default, except on Windows, or if SUDOLESS env is true
-SUDO = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
-# RCov is run by default, except on the JRuby platform, or if NO_RCOV env is true
-RUN_RCOV = JRUBY ? false : (ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true)
+RELEASE_NAME = "REL #{GEM_VERSION}"
 
 require "lib/extlib/tasks/release"
 
@@ -73,13 +68,12 @@ task :spec    => 'extlib:spec'
 
 namespace :extlib do
   Spec::Rake::SpecTask.new(:spec) do |t|
-    t.spec_opts << '--format' << 'specdoc' << '--colour'
-    t.spec_opts << '--loadby' << 'random'
+    t.spec_opts << '--options' << ROOT + 'spec/spec.opts'
     t.spec_files = Pathname.glob(ENV['FILES'] || 'spec/**/*_spec.rb').map { |f| f.to_s }
 
     begin
       gem 'rcov'
-      t.rcov = RUN_RCOV
+      t.rcov = JRUBY ? false : (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'
@@ -104,9 +98,13 @@ task :doc do
   end
 end
 
+def sudo_gem(cmd)
+  sh "#{SUDO} #{RUBY} -S gem #{cmd}", :verbose => false
+end
+
 desc "Install #{GEM_NAME}"
 task :install => :package do
-  sh %{#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}
+  sudo_gem "install --local pkg/#{GEM_NAME}-#{GEM_VERSION}"
 end
 
 if WINDOWS

data/lib/extlib.rb

@@ -1,30 +1,31 @@
 require 'pathname'
 require 'rubygems'
 
-__DIR__ = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift(__DIR__) unless $LOAD_PATH.include?(__DIR__)
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 
 # for Pathname /
-require File.expand_path(File.join(__DIR__, 'extlib', 'pathname'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'extlib', 'pathname'))
 
 dir = Pathname(__FILE__).dirname.expand_path / 'extlib'
 
-require dir / "class.rb"
-require dir / "object"
-require dir / "object_space"
+require dir / 'class.rb'
+require dir / 'object'
+require dir / 'object_space'
 
-require dir / "string"
-require dir / "symbol"
-require dir / "hash"
-require dir / "mash"
-require dir / "virtual_file"
-require dir / "logger"
-require dir / "time"
-require dir / "datetime"
+require dir / 'array'
+require dir / 'string'
+require dir / 'symbol'
+require dir / 'hash'
+require dir / 'mash'
+require dir / 'virtual_file'
+require dir / 'logger'
+require dir / 'time'
+require dir / 'datetime'
 
 require dir / 'assertions'
 require dir / 'blank'
 require dir / 'boolean'
+require dir / 'byte_array'
 require dir / 'inflection'
 require dir / 'lazy_array'
 require dir / 'module'
@@ -35,13 +36,13 @@ require dir / 'simple_set'
 require dir / 'struct'
 require dir / 'symbol'
 
-Extlib.autoload("Hook", (dir / 'hook').to_s)
-Extlib.autoload("Pooling", (dir / 'pooling').to_s)
+Extlib.autoload('Hook', (dir / 'hook').to_s)
+Extlib.autoload('Pooling', (dir / 'pooling').to_s)
 
 module Extlib
 
   def self.exiting= bool
-    if bool && Extlib.const_defined?("Pooling")
+    if bool && Extlib.const_defined?('Pooling')
       if Extlib::Pooling.scavenger?
         Extlib::Pooling.scavenger.wakeup
       end
@@ -50,7 +51,8 @@ module Extlib
   end
 
   def self.exiting
-    @exiting
+    return @exiting if defined?(@exiting)
+    @exiting = false
   end
 
 end

data/lib/extlib/array.rb

@@ -0,0 +1,36 @@
+class Array
+
+  ##
+  # Transforms an Array of key/value pairs into a Hash
+  #
+  # This is a better idiom than using Hash[*array.flatten] in Ruby 1.8.6
+  # because it is not possible to limit the flattening to a single
+  # level.
+  #
+  # @return [Hash]
+  #   A Hash where each entry in the Array is turned into a key/value
+  #
+  # @api public
+  def to_hash
+    h = {}
+    each { |k,v| h[k] = v }
+    h
+  end
+
+  ##
+  # Transforms an Array of key/value pairs into a Mash
+  #
+  # This is a better idiom than using Mash[*array.flatten] in Ruby 1.8.6
+  # because it is not possible to limit the flattening to a single
+  # level.
+  #
+  # @return [Mash]
+  #   A Hash where each entry in the Array is turned into a key/value
+  #
+  # @api public
+  def to_mash
+    m = Mash.new
+    each { |k,v| m[k] = v }
+    m
+  end
+end # class Array

data/lib/extlib/byte_array.rb

@@ -0,0 +1,4 @@
+# This class has exists to represent binary data. This is mainly
+# used by DataObjects. Binary data sometimes needs to be quoted differently
+# than regular string data (even if the string is just plain ASCII).
+class ByteArray < String; end

data/lib/extlib/class.rb

@@ -115,12 +115,14 @@ class Class
     ivars.each do |ivar|
       self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def self.#{ivar}
-          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+          return @#{ivar} if defined?(@#{ivar})
+          return nil      if self.object_id == #{self.object_id}
           ivar = superclass.#{ivar}
-          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          return nil if ivar.nil?
           @#{ivar} = ivar.try_dup
         end
       RUBY
+
       unless instance_reader == false
         self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{ivar}

data/lib/extlib/datetime.rb

@@ -9,6 +9,7 @@ class DateTime
   # @return [Time] Time object representing the same moment as receiver
   #
   # @api public
+  remove_method :to_time if method_defined?(:to_time) || private_method_defined?(:to_time)
   def to_time
     Time.parse self.to_s
   end
@@ -21,6 +22,7 @@ class DateTime
   # @return [DateTime] Receiver
   #
   # @api public
+  remove_method :to_datetime if method_defined?(:to_datetime) || private_method_defined?(:to_datetime)
   def to_datetime
     self
   end

data/lib/extlib/hash.rb

@@ -131,11 +131,11 @@ class Hash
     end
 
     stack.each do |parent, hash|
-      hash.each do |key, value|
-        if value.is_a?(Hash)
-          stack << ["#{parent}[#{key}]", value]
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
         else
-          param << normalize_param("#{parent}[#{key}]", value)
+          param << normalize_param("#{parent}[#{k}]", v)
         end
       end
     end

data/lib/extlib/hook.rb

@@ -235,21 +235,26 @@ module Extlib
         after_hooks  = hooks[target_method][:after]
         after_hooks  = after_hooks.map{ |info| inline_call(info, scope) }.join("\n")
 
-        source = %{
+        before_hook_name = hook_method_name(target_method, 'execute_before', 'hook_stack')
+        after_hook_name  = hook_method_name(target_method, 'execute_after',  'hook_stack')
+
+        hooks[target_method][:in].class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{scope == :class ? 'class << self' : ''}
+
           private
 
-          def #{hook_method_name(target_method, 'execute_before', 'hook_stack')}(*args)
+          remove_method :#{before_hook_name} if method_defined?(:#{before_hook_name}) || private_method_defined?(:#{before_hook_name})
+          def #{before_hook_name}(*args)
             #{before_hooks}
           end
 
-          def #{hook_method_name(target_method, 'execute_after', 'hook_stack')}(*args)
+          remove_method :#{after_hook_name} if method_defined?(:#{after_hook_name}) || private_method_defined?(:#{after_hook_name})
+          def #{after_hook_name}(*args)
             #{after_hooks}
           end
-        }
 
-        source = %{class << self\n#{source}\nend} if scope == :class
-
-        hooks[target_method][:in].class_eval(source, __FILE__, __LINE__ - 12)
+          #{scope == :class ? 'end' : ''}
+        RUBY
       end
 
       # Returns ruby code that will invoke the hook. It checks the arity of the hook method
@@ -321,14 +326,25 @@ module Extlib
           #if this hook is previously declared in a sibling or cousin we must move the :in class
           #to the common ancestor to get both hooks to run.
           if !(hooks[target_method][:in] <=> self)
-            hooks[target_method][:in].class_eval(
-              %{def #{hook_method_name(target_method, 'execute_before', 'hook_stack')}(*args);super;end\n} +
-              %{def #{hook_method_name(target_method, 'execute_after', 'hook_stack')}(*args);super;end},
-              __FILE__,__LINE__ - 2
-            )
+            before_hook_name = hook_method_name(target_method, 'execute_before', 'hook_stack')
+            after_hook_name  = hook_method_name(target_method, 'execute_after',  'hook_stack')
+
+            hooks[target_method][:in].class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              remove_method :#{before_hook_name} if method_defined?(:#{before_hook_name}) || private_method_defined?(:#{before_hook_name})
+              def #{before_hook_name}(*args)
+                super
+              end
+
+              remove_method :#{after_hook_name} if method_defined?(:#{after_hook_name}) || private_method_defined?(:#{after_hook_name})
+              def #{after_hook_name}(*args)
+                super
+              end
+            RUBY
+
             while !(hooks[target_method][:in] <=> self) do
               hooks[target_method][:in] = hooks[target_method][:in].superclass
             end
+
             define_hook_stack_execution_methods(target_method, scope)
             hooks[target_method][:in].class_eval{define_advised_method(target_method, scope)}
           end

data/lib/extlib/lazy_array.rb

@@ -1,17 +1,6 @@
 class LazyArray  # borrowed partially from StrokeDB
   instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ send class dup object_id kind_of? respond_to? equal? assert_kind_of should should_not instance_variable_set instance_variable_get extend ].include?(m.to_s) }
 
-  # add proxies for all Array and Enumerable methods
-  ((Array.instance_methods(false) | Enumerable.instance_methods(false)).map { |m| m.to_s } - %w[ taguri= ]).each do |method|
-    class_eval <<-EOS, __FILE__, __LINE__
-      def #{method}(*args, &block)
-        lazy_load
-        results = @array.#{method}(*args, &block)
-        results.equal?(@array) ? self : results
-      end
-    EOS
-  end
-
   def first(*args)
     if lazy_possible?(@head, *args)
       @head.first(*args)
@@ -60,7 +49,7 @@ class LazyArray  # borrowed partially from StrokeDB
     lazy_possible = args.all? do |arg|
       index, length = extract_slice_arguments(arg)
 
-      if index >= 0 && lazy_possible?(@head, index + (length || 1))
+      if index >= 0 && lazy_possible?(@head, index + length)
         accumulator.concat(head.values_at(*arg))
       elsif index < 0 && lazy_possible?(@tail, index.abs)
         accumulator.concat(tail.values_at(*arg))
@@ -105,12 +94,10 @@ class LazyArray  # borrowed partially from StrokeDB
   def [](*args)
     index, length = extract_slice_arguments(*args)
 
-    if length.nil?
+    if length == 1 && args.size == 1 && args.first.kind_of?(Integer)
       return at(index)
     end
 
-    length ||= 1
-
     if index >= 0 && lazy_possible?(@head, index + length)
       @head[*args]
     elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
@@ -126,8 +113,6 @@ class LazyArray  # borrowed partially from StrokeDB
   def slice!(*args)
     index, length = extract_slice_arguments(*args)
 
-    length ||= 1
-
     if index >= 0 && lazy_possible?(@head, index + length)
       @head.slice!(*args)
     elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
@@ -141,8 +126,6 @@ class LazyArray  # borrowed partially from StrokeDB
   def []=(*args)
     index, length = extract_slice_arguments(*args[0..-2])
 
-    length ||= 1
-
     if index >= 0 &&  lazy_possible?(@head, index + length)
       @head.[]=(*args)
     elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
@@ -265,7 +248,6 @@ class LazyArray  # borrowed partially from StrokeDB
       lazy_load
       @array.delete_if(&block)
     else
-      @reapers ||= []
       @reapers << block
       @head.delete_if(&block)
       @tail.delete_if(&block)
@@ -326,58 +308,31 @@ class LazyArray  # borrowed partially from StrokeDB
     @frozen == true
   end
 
-  def eql?(other)
-    return true if equal?(other)
-    return false unless other.class.equal?(self.class)
-
-    unless loaded?
-      # compare the head against the beginning of other.  start at index
-      # 0 and incrementally compare each entry. if other is a LazyArray
-      # this has a lesser likelyhood of triggering a lazy load
-      0.upto(@head.size - 1) do |i|
-        return false unless @head[i].eql?(other[i])
-      end
-
-      # compare the tail against the end of other.  start at index
-      # -1 and decrementally compare each entry. if other is a LazyArray
-      # this has a lesser likelyhood of triggering a lazy load
-      -1.downto(@tail.size * -1) do |i|
-        return false unless @tail[i].eql?(other[i])
-      end
-
-      lazy_load
+  def ==(other)
+    if equal?(other)
+      return true
     end
 
-    # convert other to an Array before checking equality
-    @array.eql?(other.to_ary)
-  end
-
-  def ==(other)
-    return true if equal?(other)
-    return false unless other.respond_to?(:to_ary)
+    unless other.respond_to?(:to_ary)
+      return false
+    end
 
     # if necessary, convert to something that can be compared
     other = other.to_ary unless other.respond_to?(:[])
 
-    unless loaded?
-      # compare the head against the beginning of other.  start at index
-      # 0 and incrementally compare each entry. if other is a LazyArray
-      # this has a lesser likelyhood of triggering a lazy load
-      0.upto(@head.size - 1) do |i|
-        return false unless @head[i] == other[i]
-      end
+    cmp?(other, :==)
+  end
 
-      # compare the tail against the end of other.  start at index
-      # -1 and decrementally compare each entry. if other is a LazyArray
-      # this has a lesser likelyhood of triggering a lazy load
-      -1.downto(@tail.size * -1) do |i|
-        return false unless @tail[i] == other[i]
-      end
+  def eql?(other)
+    if equal?(other)
+      return true
+    end
 
-      lazy_load
+    unless other.class.equal?(self.class)
+      return false
     end
 
-    @array == other
+    cmp?(other, :eql?)
   end
 
   protected
@@ -391,10 +346,13 @@ class LazyArray  # borrowed partially from StrokeDB
   private
 
   def initialize
+    @frozen         = false
+    @loaded         = false
     @load_with_proc = lambda { |v| v }
     @head           = []
     @tail           = []
     @array          = []
+    @reapers        = []
   end
 
   def initialize_copy(original)
@@ -441,7 +399,7 @@ class LazyArray  # borrowed partially from StrokeDB
       return first_arg, second_arg
     elsif args.size == 1
       if first_arg.kind_of?(Integer)
-        return first_arg
+        return first_arg, 1
       elsif first_arg.kind_of?(Range)
         index = first_arg.first
         length  = first_arg.last - index
@@ -464,4 +422,46 @@ class LazyArray  # borrowed partially from StrokeDB
       super
     end
   end
+
+  def cmp?(other, operator)
+    unless loaded?
+      # compare the head against the beginning of other.  start at index
+      # 0 and incrementally compare each entry. if other is a LazyArray
+      # this has a lesser likelyhood of triggering a lazy load
+      0.upto(@head.size - 1) do |i|
+        return false unless @head[i].send(operator, other[i])
+      end
+
+      # compare the tail against the end of other.  start at index
+      # -1 and decrementally compare each entry. if other is a LazyArray
+      # this has a lesser likelyhood of triggering a lazy load
+      -1.downto(@tail.size * -1) do |i|
+        return false unless @tail[i].send(operator, other[i])
+      end
+
+      lazy_load
+    end
+
+    @array.send(operator, other.to_ary)
+  end
+
+  # add proxies for all remaining Array and Enumerable methods
+  (Array.public_instance_methods(false) | Enumerable.public_instance_methods(false)).each do |method|
+    next if public_method_defined?(method)
+
+    target = if method.to_s[-1, 1] == '='
+      "send(:#{method}, *args, &block)"
+    else
+      "#{method}(*args, &block)"
+    end
+
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      public
+      def #{method}(*args, &block)                # def []=(*args, &block)
+        lazy_load                                 #   lazy_load
+        results = @array.#{target}                #   results = @array.send(:[]=, *args, &block)
+        results.equal?(@array) ? self : results   #   results.equal?(@array) ? self : results
+      end                                         # end
+    RUBY
+  end
 end

data/lib/extlib/lazy_module.rb

@@ -0,0 +1,18 @@
+class LazyModule < Module
+  def self.new(&blk)
+    # passing no-op block overrides &blk
+    m = super{ }
+    class << m
+      include ClassMethods
+    end
+    m.lazy_evaluated_body = blk
+    m
+  end
+
+  module ClassMethods
+    attr_accessor :lazy_evaluated_body
+    def included(host)
+      host.class_eval(&@lazy_evaluated_body)
+    end
+  end
+end

data/lib/extlib/logger.rb

@@ -1,36 +1,36 @@
 require "time" # httpdate
-# ==== Public Merb Logger API
+# ==== Public Extlib Logger API
 #
 # To replace an existing logger with a new one:
-#  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
+#  Extlib::Logger.set_log(log{String, IO},level{Symbol, String})
 #
 # Available logging levels are
-#   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
+#   Extlib::Logger::{ Fatal, Error, Warn, Info, Debug }
 #
 # Logging via:
-#   Merb.logger.fatal(message<String>,&block)
-#   Merb.logger.error(message<String>,&block)
-#   Merb.logger.warn(message<String>,&block)
-#   Merb.logger.info(message<String>,&block)
-#   Merb.logger.debug(message<String>,&block)
+#   Extlib.logger.fatal(message<String>,&block)
+#   Extlib.logger.error(message<String>,&block)
+#   Extlib.logger.warn(message<String>,&block)
+#   Extlib.logger.info(message<String>,&block)
+#   Extlib.logger.debug(message<String>,&block)
 #
 # Logging with autoflush:
-#   Merb.logger.fatal!(message<String>,&block)
-#   Merb.logger.error!(message<String>,&block)
-#   Merb.logger.warn!(message<String>,&block)
-#   Merb.logger.info!(message<String>,&block)
-#   Merb.logger.debug!(message<String>,&block)
+#   Extlib.logger.fatal!(message<String>,&block)
+#   Extlib.logger.error!(message<String>,&block)
+#   Extlib.logger.warn!(message<String>,&block)
+#   Extlib.logger.info!(message<String>,&block)
+#   Extlib.logger.debug!(message<String>,&block)
 #
 # Flush the buffer to
-#   Merb.logger.flush
+#   Extlib.logger.flush
 #
 # Remove the current log object
-#   Merb.logger.close
+#   Extlib.logger.close
 #
-# ==== Private Merb Logger API
+# ==== Private Extlib Logger API
 #
 # To initialize the logger you create a new object, proxies to set_log.
-#   Merb::Logger.new(log{String, IO},level{Symbol, String})
+#   Extlib::Logger.new(log{String, IO},level{Symbol, String})
 module Extlib
 
   class << self
@@ -110,8 +110,6 @@ module Extlib
     def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
       if log_level && Levels[log_level.to_sym]
         @level = Levels[log_level.to_sym]
-      elsif Merb.environment == "production"
-        @level = Levels[:warn]
       else
         @level = Levels[:debug]
       end
@@ -120,8 +118,6 @@ module Extlib
       @auto_flush = auto_flush
 
       initialize_log(log)
-
-      Merb.logger = self
     end
 
     # Flush the entire buffer to the log object.
@@ -157,7 +153,7 @@ module Extlib
     end
     alias :push :<<
 
-    # Generate the logging methods for Merb.logger for each log level.
+    # Generate the logging methods for Extlib.logger for each log level.
     Levels.each_pair do |name, number|
       class_eval <<-LEVELMETHODS, __FILE__, __LINE__
 

data/lib/extlib/module.rb

@@ -1,7 +1,7 @@
 class Module
   def find_const(const_name)
     if const_name[0..1] == '::'
-      Object.find_const(const_name[2..-1])
+      Object.full_const_get(const_name[2..-1])
     else
       nested_const_lookup(const_name)
     end
@@ -15,31 +15,33 @@ class Module
 
   # Doesn't do any caching since constants can change with remove_const
   def nested_const_lookup(const_name)
-    constants = [ Object ]
+    unless equal?(Object)
+      constants = []
 
-    unless self == Object
-      self.name.split('::').each do |part|
-        constants.unshift(constants.first.const_get(part))
+      name.split('::').each do |part|
+        const = constants.first || Object
+        constants << const.const_get(part)
       end
-    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 = if RUBY_VERSION >= '1.9.0'
-          const.const_defined?(part, false) ? const.const_get(part, false) : nil
-        else
-          const.const_defined?(part) ? const.const_get(part) : nil
+      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.reverse_each do |const|
+        # return the nested constant if available
+        return const if parts.all? do |part|
+          const = if RUBY_VERSION >= '1.9.0'
+            const.const_defined?(part, false) ? const.const_get(part, false) : nil
+          else
+            const.const_defined?(part) ? const.const_get(part) : nil
+          end
         end
       end
     end
 
-    # if we get this far then the nested constant was not found
-    raise NameError, "uninitialized constant #{const_name}"
+    # no relative constant found, fallback to an absolute lookup and
+    # use const_missing if not found
+    Object.full_const_get(const_name)
   end
 
 end # class Module

data/lib/extlib/object.rb

@@ -97,7 +97,7 @@ class Object
     current_module = self
     mod.each do |x|
       unless current_module.const_defined?(x)
-        current_module.class_eval "module #{x}; end"
+        current_module.class_eval "module #{x}; end", __FILE__, __LINE__
       end
       current_module = current_module.const_get(x)
     end
@@ -136,6 +136,19 @@ class Object
     self.dup
   end
 
+  # If receiver is callable, calls it and
+  # returns result. If not, just returns receiver
+  # itself
+  #
+  # @return <Object>
+  def try_call(*args)
+    if self.respond_to?(:call)
+      self.call(*args)
+    else
+      self
+    end
+  end
+
   # @param arrayish<#include?> Container to check, to see if it includes the object.
   # @param *more<Array>:: additional args, will be flattened into arrayish
   #

data/lib/extlib/pathname.rb

@@ -12,4 +12,9 @@ class Pathname
   def /(path)
     (self + path).expand_path
   end
+
+  # alias to_s to to_str when to_str not defined
+  unless public_instance_methods(false).any? { |m| m.to_s == 'to_str' }
+    alias to_str to_s
+  end
 end # class Pathname

data/lib/extlib/pooling.rb

@@ -26,11 +26,11 @@ module Extlib
   module Pooling
 
     def self.scavenger?
-      @scavenger && @scavenger.alive?
+      defined?(@scavenger) && !@scavenger.nil? && @scavenger.alive?
     end
 
     def self.scavenger
-      if @scavenger.nil? || !@scavenger.alive?
+      unless scavenger?
         @scavenger = Thread.new do
           running = true
           while running do
@@ -72,7 +72,7 @@ module Extlib
       lock.synchronize do
         pools << pool
       end
-      Extlib::Pooling::scavenger
+      Extlib::Pooling.scavenger
     end
 
     def self.lock
@@ -118,6 +118,10 @@ module Extlib
       @__pool.release(self) unless @__pool.nil?
     end
 
+    def detach
+      @__pool.delete(self) unless @__pool.nil?
+    end
+
     class Pool
       attr_reader :available
       attr_reader :used
@@ -132,7 +136,7 @@ module Extlib
 
         @available = []
         @used      = {}
-        Extlib::Pooling::append_pool(self)
+        Extlib::Pooling.append_pool(self)
       end
 
       def lock
@@ -209,7 +213,7 @@ module Extlib
       def dispose
         flush!
         @resource.__pools.delete(@args)
-        !Extlib::Pooling::pools.delete?(self).nil?
+        !Extlib::Pooling.pools.delete?(self).nil?
       end
 
       def expired?

data/lib/extlib/time.rb

@@ -23,6 +23,7 @@ class Time
   # @return [Time] Receiver
   #
   # @api public
+  remove_method :to_time if method_defined?(:to_time) || private_method_defined?(:to_time)
   def to_time
     self
   end
@@ -35,6 +36,7 @@ class Time
   # @return [DateTime] DateTime object representing the same moment as receiver
   #
   # @api public
+  remove_method :to_datetime if method_defined?(:to_datetime) || private_method_defined?(:to_datetime)
   def to_datetime
     DateTime.parse self.to_s
   end

data/lib/extlib/version.rb

@@ -1,3 +1,3 @@
 module Extlib
-  VERSION = '0.9.10'
+  VERSION = '0.9.11'
 end

data/spec/array_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe Array do
+  before :all do
+    @array = [ [ :a, [ 1 ] ], [ :b, [ 2 ] ], [ :c, [ 3 ] ] ].freeze
+  end
+
+  it { @array.should respond_to(:to_hash) }
+
+  describe '#to_hash' do
+    before :all do
+      @return = @array.to_hash
+    end
+
+    it 'should return a Hash' do
+      @return.should be_kind_of(Hash)
+    end
+
+    it 'should return expected value' do
+      @return.should == { :a => [ 1 ], :b => [ 2 ], :c => [ 3 ] }
+    end
+  end
+
+  it { @array.should respond_to(:to_mash) }
+
+  describe '#to_mash' do
+    before :all do
+      @return = @array.to_mash
+    end
+
+    it 'should return a Mash' do
+      @return.should be_kind_of(Mash)
+    end
+
+    it 'should return expected value' do
+      @return.should == { 'a' => [ 1 ], 'b' => [ 2 ], 'c' => [ 3 ] }
+    end
+  end
+end

data/spec/byte_array_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe ByteArray do
+  it 'should be a String' do
+    ByteArray.new.should be_kind_of(String)
+  end
+end

data/spec/hook_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 
 describe Extlib::Hook do
 
-  before(:each) do
+  before do
     @module = Module.new do
       def greet; greetings_from_module; end;
     end
@@ -405,7 +405,9 @@ describe Extlib::Hook do
           def self.method_with_args(one, two, three); end;
           def self.before_method_with_args(one, two, three); hi_mom!; end;
           before_class_method(:method_with_args, :before_method_with_args)
+          orig_verbose, $VERBOSE = $VERBOSE, false
           def self.before_method_with_args; hi_dad!; end;
+          $VERBOSE = orig_verbose
         end
 
         @class.should_not_receive(:hi_mom1)
@@ -440,7 +442,9 @@ describe Extlib::Hook do
           def self.method_with_args(word, lol); end;
           def self.before_method_with_args; hi_mom!; end;
           before_class_method(:method_with_args, :before_method_with_args)
+          orig_verbose, $VERBOSE = $VERBOSE, false
           def self.before_method_with_args(word, lol); hi_dad!(word, lol); end;
+          $VERBOSE = orig_verbose
         end
 
         @class.should_not_receive(:hi_mom!)
@@ -541,7 +545,9 @@ describe Extlib::Hook do
           def method_with_args(one, two, three); end;
           def before_method_with_args(one, two, three); hi_mom!; end;
           before(:method_with_args, :before_method_with_args)
+          orig_verbose, $VERBOSE = $VERBOSE, false
           def before_method_with_args; hi_dad!; end;
+          $VERBOSE = orig_verbose
         end
 
         inst = @class.new
@@ -578,7 +584,9 @@ describe Extlib::Hook do
           def method_with_args(word, lol); end;
           def before_method_with_args; hi_mom!; end;
           before(:method_with_args, :before_method_with_args)
+          orig_verbose, $VERBOSE = $VERBOSE, false
           def before_method_with_args(word, lol); hi_dad!(word, lol); end;
+          $VERBOSE = orig_verbose
         end
 
         inst = @class.new

data/spec/lazy_array_spec.rb

@@ -1913,6 +1913,7 @@ end
     describe 'a method mixed into Array' do
       before :all do
         Enumerable.class_eval do
+          remove_method :lazy_spec if method_defined?(:lazy_spec) || private_method_defined?(:lazy_spec)
           def lazy_spec
             true
           end

data/spec/lazy_module_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require 'extlib/lazy_module'
+
+describe LazyModule do
+  describe "instantiated with a block" do
+    it "defers block body evaluation" do
+      lambda do
+        LazyModule.new do
+          raise "Will only be evaluated when mixed in"
+        end
+      end.should_not raise_error
+    end
+  end
+
+
+  describe "included into hosting class" do
+    before :all do
+      KlazzyLazyModule = LazyModule.new do
+        def self.klassy
+          "Klazz"
+        end
+
+        def instancy
+          "Instanzz"
+        end
+      end
+
+      @klass = Class.new do
+        include KlazzyLazyModule
+      end
+    end
+
+    it "class evals block body" do
+      @klass.klassy.should == "Klazz"
+      @klass.new.instancy.should == "Instanzz"
+    end
+  end
+end

data/spec/pooling_spec.rb

@@ -2,8 +2,11 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 require 'timeout'
 
 module Extlib::Pooling
-  def self.scavenger_interval
-    1
+  class << self
+    remove_method :scavenger_interval if method_defined?(:scavenger_interval) || private_method_defined?(:scavenger_interval)
+    def scavenger_interval
+      1
+    end
   end
 end
 
@@ -11,7 +14,7 @@ describe "Extlib::Pooling" do
   before do
 
     Object.send(:remove_const, :Person) if defined?(Person)
-    class Person
+    class ::Person
       include Extlib::Pooling
 
       attr_accessor :name
@@ -26,7 +29,7 @@ describe "Extlib::Pooling" do
     end
 
     Object.send(:remove_const, :Overwriter) if defined?(Overwriter)
-    class Overwriter
+    class ::Overwriter
 
       def self.new(*args)
         instance = allocate
@@ -52,13 +55,16 @@ describe "Extlib::Pooling" do
         @overwritten = value
       end
 
-      def self.pool_size
-        pool_size = if RUBY_PLATFORM =~ /java/
-          20
-        else
-          2
+      class << self
+        remove_method :pool_size if method_defined?(:pool_size) || private_method_defined?(:pool_size)
+        def pool_size
+          pool_size = if RUBY_PLATFORM =~ /java/
+            20
+          else
+            2
+          end
+          pool_size
         end
-        pool_size
       end
 
       def dispose
@@ -146,7 +152,6 @@ describe "Extlib::Pooling" do
   end
 
   it "should wake up the scavenger thread when exiting" do
-    pending 'Fix for JRuby' if RUBY_PLATFORM =~ /java/
     bob = Person.new('Bob')
     bob.release
     Extlib.exiting = true
@@ -154,6 +159,13 @@ describe "Extlib::Pooling" do
     Extlib::Pooling.scavenger?.should be_false
   end
 
+  it "should be able to detach an instance from the pool" do
+    bob = Person.new('Bob')
+    Person.__pools[['Bob']].size.should == 1
+    bob.detach
+    Person.__pools[['Bob']].size.should == 0
+  end
+
 end
 
 # describe Extlib::Pooling::ResourcePool do

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--loadby random
+--backtrace

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
-
 $TESTING=true
 require "rubygems"
 require "spec"
 require "yaml"
 
-require File.join(File.dirname(__FILE__), '..', 'lib', 'extlib')
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'extlib'))

data/spec/try_call_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe "#try_call" do
+  describe "with an Object" do
+    before :all do
+      @receiver = Object.new
+    end
+
+    it "returns receiver itself" do
+      @receiver.try_call.should == @receiver
+    end
+  end
+
+  describe "with a number" do
+    before :all do
+      @receiver = 42
+    end
+
+    it "returns receiver itself" do
+      @receiver.try_call.should == @receiver
+    end
+  end
+
+  describe "with a String" do
+    before :all do
+      @receiver = "Ruby, programmer's best friend"
+    end
+
+    it "returns receiver itself" do
+      @receiver.try_call.should == @receiver
+    end
+  end
+
+  describe "with a hash" do
+    before :all do
+      @receiver = { :functional_programming => "FTW" }
+    end
+
+    it "returns receiver itself" do
+      @receiver.try_call.should == @receiver
+    end
+  end
+
+  describe "with a Proc" do
+    before :all do
+      @receiver = Proc.new { 5 * 7 }
+    end
+
+    it "returns result of calling of a proc" do
+      @receiver.try_call.should == 35
+    end
+  end
+
+  describe "with a Proc that takes 2 arguments" do
+    before :all do
+      @receiver = Proc.new { |one, other| one + other }
+    end
+
+    it "passes arguments to #call, returns result of calling of a proc" do
+      @receiver.try_call(10, 20).should == 30
+    end
+  end
+
+  describe "with a Proc that takes 3 arguments" do
+    before :all do
+      @receiver = Proc.new { |a, b, c| (a + b) * c }
+    end
+
+    it "passes arguments to #call, returns result of calling of a proc" do
+      @receiver.try_call(10, 20, 3).should == 90
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: extlib
 version: !ruby/object:Gem::Version 
-  version: 0.9.10
+  version: 0.9.11
 platform: ruby
 authors: 
 - Sam Smoot
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-19 00:00:00 -08:00
+date: 2009-03-29 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -29,9 +29,11 @@ files:
 - Rakefile
 - History.txt
 - lib/extlib
+- lib/extlib/array.rb
 - lib/extlib/assertions.rb
 - lib/extlib/blank.rb
 - lib/extlib/boolean.rb
+- lib/extlib/byte_array.rb
 - lib/extlib/class.rb
 - lib/extlib/datetime.rb
 - lib/extlib/dictionary.rb
@@ -39,6 +41,7 @@ files:
 - lib/extlib/hook.rb
 - lib/extlib/inflection.rb
 - lib/extlib/lazy_array.rb
+- lib/extlib/lazy_module.rb
 - lib/extlib/logger.rb
 - lib/extlib/mash.rb
 - lib/extlib/module.rb
@@ -59,7 +62,9 @@ files:
 - lib/extlib/version.rb
 - lib/extlib/virtual_file.rb
 - lib/extlib.rb
+- spec/array_spec.rb
 - spec/blank_spec.rb
+- spec/byte_array_spec.rb
 - spec/class_spec.rb
 - spec/datetime_spec.rb
 - spec/hash_spec.rb
@@ -69,17 +74,20 @@ files:
 - spec/inflection/singular_spec.rb
 - spec/inflection_extras_spec.rb
 - spec/lazy_array_spec.rb
+- spec/lazy_module_spec.rb
 - spec/mash_spec.rb
 - spec/module_spec.rb
 - spec/object_space_spec.rb
 - spec/object_spec.rb
 - spec/pooling_spec.rb
 - spec/simple_set_spec.rb
+- spec/spec.opts
 - spec/spec_helper.rb
 - spec/string_spec.rb
 - spec/struct_spec.rb
 - spec/symbol_spec.rb
 - spec/time_spec.rb
+- spec/try_call_spec.rb
 - spec/try_dup_spec.rb
 - spec/virtual_file_spec.rb
 has_rdoc: false