extlib 0.9.8 → 0.9.9

data/lib/extlib/mash.rb

@@ -9,12 +9,12 @@ class Mash < Hash
   #   If constructor is a Hash, a new mash will be created based on the keys of
   #   the hash and no default value will be set.
   def initialize(constructor = {})
-    if constructor.is_a?(Hash) 
-      super() 
-      update(constructor) 
-    else 
-      super(constructor) 
-    end 
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
   end
 
   # @param key<Object> The default value for the mash. Defaults to nil.
@@ -22,15 +22,15 @@ class Mash < Hash
   # @details [Alternatives]
   #   If key is a Symbol and it is a key in the mash, then the default value will
   #   be set to the value matching the key.
-  def default(key = nil) 
-    if key.is_a?(Symbol) && include?(key = key.to_s) 
-      self[key] 
-    else 
-      super 
-    end 
-  end 
- 
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) 
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
   alias_method :regular_update, :update unless method_defined?(:regular_update)
 
   # @param key<Object> The key to set.
@@ -39,8 +39,8 @@ class Mash < Hash
   #
   # @see Mash#convert_key
   # @see Mash#convert_value
-  def []=(key, value) 
-    regular_writer(convert_key(key), convert_value(value)) 
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
   end
 
   # @param other_hash<Hash>
@@ -48,19 +48,19 @@ class Mash < Hash
   #   converted to Mash format.
   #
   # @return <Mash> The updated mash.
-  def update(other_hash) 
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } 
-    self 
-  end 
- 
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
   alias_method :merge!, :update
 
   # @param key<Object> The key to check for. This will be run through convert_key.
   #
   # @return <TrueClass, FalseClass> True if the key exists in the mash.
-  def key?(key) 
-    super(convert_key(key)) 
-  end 
+  def key?(key)
+    super(convert_key(key))
+  end
 
   # def include? def has_key? def member?
   alias_method :include?, :key?
@@ -71,29 +71,29 @@ class Mash < Hash
   # @param *extras<Array> Default value.
   #
   # @return <Object> The value at key or the default value.
-  def fetch(key, *extras) 
-    super(convert_key(key), *extras) 
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
   end
 
   # @param *indices<Array>
   #   The keys to retrieve values for. These will be run through +convert_key+.
   #
   # @return <Array> The values at each of the provided keys
-  def values_at(*indices) 
-    indices.collect {|key| self[convert_key(key)]} 
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
   end
 
   # @param hash<Hash> The hash to merge with the mash.
   #
   # @return <Mash> A new mash with the hash values merged in.
-  def merge(hash) 
-    self.dup.update(hash) 
+  def merge(hash)
+    self.dup.update(hash)
   end
 
   # @param key<Object>
   #   The key to delete from the mash.\
-  def delete(key) 
-    super(convert_key(key)) 
+  def delete(key)
+    super(convert_key(key))
   end
 
   # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
@@ -111,12 +111,12 @@ class Mash < Hash
   #
   # @return <Mash> This mash unchanged.
   def stringify_keys!; self end
- 
+
   # @return <Hash> The mash as a Hash with string keys.
-  def to_hash 
-    Hash.new(default).merge(self) 
-  end 
- 
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
   protected
   # @param key<Object> The key to convert.
   #
@@ -125,8 +125,8 @@ class Mash < Hash
   #   string.
   #
   # @api private
-  def convert_key(key) 
-    key.kind_of?(Symbol) ? key.to_s : key 
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
   end
 
   # @param value<Object> The value to convert.
@@ -136,13 +136,13 @@ class Mash < Hash
   #   their Mash equivalents.
   #
   # @api private
-  def convert_value(value) 
+  def convert_value(value)
     if value.class == Hash
-      value.to_mash 
+      value.to_mash
     elsif value.is_a?(Array)
-      value.collect { |e| convert_value(e) } 
+      value.collect { |e| convert_value(e) }
     else
       value
-    end 
+    end
   end
-end
+end

data/lib/extlib/module.rb

@@ -6,7 +6,7 @@ class Module
       nested_const_lookup(const_name)
     end
   end
-  
+
   def try_dup
     self
   end

data/lib/extlib/nil.rb

@@ -2,4 +2,4 @@ class NilClass
   def try_dup
     self
   end
-end
+end

data/lib/extlib/numeric.rb

@@ -2,4 +2,4 @@ class Numeric
   def try_dup
     self
   end
-end
+end

data/lib/extlib/object.rb

@@ -34,10 +34,10 @@ class Object
   # @example
   #   MyString.foo
   #     #=> NoMethodError: undefined method `foo' for MyString:Class
-  # @example  
+  # @example
   #   MyString.bar
   #     #=> MyString
-  # @example  
+  # @example
   #   String.bar
   #     #=> NoMethodError: undefined method `bar' for String:Class
   # @example
@@ -65,19 +65,19 @@ class Object
     list = name.split("::")
     list.shift if list.first.blank?
     obj = self
-    list.each do |x| 
-      # This is required because const_get tries to look for constants in the 
+    list.each do |x|
+      # This is required because const_get tries to look for constants in the
       # ancestor chain, but we only want constants that are HERE
       obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
     end
     obj
   end
-  
+
   # @param name<String> The name of the constant to get, e.g. "Merb::Router".
   # @param value<Object> The value to assign to the constant.
   #
   # @return <Object> The constant corresponding to the name.
-  def full_const_set(name, value)    
+  def full_const_set(name, value)
     list = name.split("::")
     toplevel = list.first.blank?
     list.shift if toplevel
@@ -128,14 +128,14 @@ class Object
       false
     end
   end
-  
+
   # Override this in a child if it cannot be dup'ed
   #
   # @return <Object>
   def try_dup
     self.dup
   end
-  
+
   # @param arrayish<#include?> Container to check, to see if it includes the object.
   # @param *more<Array>:: additional args, will be flattened into arrayish
   #
@@ -148,19 +148,6 @@ class Object
     arrayish = more.unshift(arrayish) unless more.empty?
     arrayish.include?(self)
   end
-  
-  # @note
-  #   For instances of objects that don't override the #inspect method, there
-  #   is an encoded hash to uniquely identify the object. This method
-  #   reproduces this to be used in #inspect in order to keep the same look
-  #   as well as provide this information.
-  #   This is inessential, but may be useful.
-  # 
-  # @return <String>
-  #   Returns the 16-byte encoded hash for the object
-  def encoded_hash
-    (self.hash * 2).to_s(16)
-  end
 
   # Add instance_variable_defined? for backward compatibility
   # @param variable<Symbol, String>

data/lib/extlib/object_space.rb

@@ -1,5 +1,5 @@
 module ObjectSpace
-  
+
   class << self
 
     # @return <Array[Class]> All the classes in the object space.
@@ -9,5 +9,5 @@ module ObjectSpace
       klasses
     end
   end
-  
-end
+
+end

data/lib/extlib/pathname.rb

@@ -1,4 +1,14 @@
 class Pathname
+  # Append path segments and expand to absolute path
+  #
+  #   file = Pathname(Dir.pwd) / "subdir1" / :subdir2 / "filename.ext"
+  #
+  # @param [Pathname, String, #to_s] path path segment to concatenate with receiver
+  #
+  # @return [Pathname]
+  #   receiver with _path_ appended and expanded to an absolute path
+  #
+  # @api public
   def /(path)
     (self + path).expand_path
   end

data/lib/extlib/pooling.rb

@@ -82,9 +82,6 @@ module Extlib
     class InvalidResourceError < StandardError
     end
 
-    class ThreadStopError < StandardError
-    end
-
     def self.included(target)
       target.class_eval do
         class << self
@@ -165,17 +162,12 @@ module Extlib
               instance.instance_variable_set(:@__allocated_in_pool, Time.now)
               @used[instance.object_id] = instance
             else
-              # Let's see whether we have multiple threads
-              # If we do, there is a chance we might be released
-              # at some point in the future and thus we wait.
-              # If there are no other threads, we exhaust the pool
-              # here and there is no more hope... So we throw an
-              # exception.
-              if ThreadGroup::Default.list.size <= 2
-                raise ThreadStopError.new(size)
-              else
-                wait.wait(lock)
-              end
+              # Wait for another thread to release an instance.
+              # If we exhaust the pool and don't release the active instance,
+              # we'll wait here forever, so it's *very* important to always
+              # release your services and *never* exhaust the pool within
+              # a single thread.
+              wait.wait(lock)
             end
           end
         end until instance
@@ -183,8 +175,8 @@ module Extlib
       end
 
       def release(instance)
-        instance.instance_variable_set(:@__allocated_in_pool, Time.now)
         lock.synchronize do
+          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
           @used.delete(instance.object_id)
           @available.push(instance)
           wait.signal
@@ -196,6 +188,7 @@ module Extlib
         lock.synchronize do
           instance.instance_variable_set(:@__pool, nil)
           @used.delete(instance.object_id)
+          wait.signal
         end
         nil
       end
@@ -221,12 +214,11 @@ module Extlib
 
       def expired?
         @available.each do |instance|
-          if Extlib.exiting || instance.instance_variable_get(:@__allocated_in_pool) + Extlib::Pooling.scavenger_interval <= Time.now
+          if Extlib.exiting || instance.instance_variable_get(:@__allocated_in_pool) + Extlib::Pooling.scavenger_interval <= (Time.now + 0.02)
             instance.dispose
             @available.delete(instance)
           end
         end
-
         size == 0
       end
 

data/lib/extlib/rubygems.rb

@@ -2,26 +2,26 @@
 require 'rubygems'
 module Gem
   class SourceIndex
-    
+
     # This is resolved in 1.1
     if Version.new(RubyGemsVersion) < Version.new("1.1")
-      
+
       # Overwrite this so that a gem of the same name and version won't push one
       # from the gems directory out entirely.
       #
       # @param gem_spec<Gem::Specification> The specification of the gem to add.
       def add_spec(gem_spec)
         unless gem_spec.instance_variable_get("@loaded_from") &&
-          @gems[gem_spec.full_name].is_a?(Gem::Specification) && 
-          @gems[gem_spec.full_name].installation_path == 
+          @gems[gem_spec.full_name].is_a?(Gem::Specification) &&
+          @gems[gem_spec.full_name].installation_path ==
             File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems")
-            
+
           @gems[gem_spec.full_name] = gem_spec
         end
       end
-      
+
     end
-    
+
   end
 
   class Specification

data/lib/extlib/simple_set.rb

@@ -6,28 +6,55 @@ module Extlib
   # a set of callable actions of controller.
   class SimpleSet < Hash
 
-    # @param arr<Array> Initial set values.
+    ##
+    # Create a new SimpleSet containing the unique members of _arr_
     #
-    # @return <Array> The array the Set was initialized with
+    # @param [Array] arr Initial set values.
+    #
+    # @return [Array] The array the Set was initialized with
+    #
+    # @api public
     def initialize(arr = [])
-      arr.each {|x| self[x] = true}
+      Array(arr).each {|x| self[x] = true}
     end
 
-    # @param value<Object> Value to add to set.
+    ##
+    # Add a value to the set, and return it
+    #
+    # @param [Object] value Value to add to set.
     #
-    # @return <TrueClass>
+    # @return [SimpleSet] Receiver
+    #
+    # @api public
     def <<(value)
       self[value] = true
+      self
     end
 
-    # @param arr<Array> Values to merge with set.
+    ##
+    # Merge _arr_ with receiver, producing the union of receiver & _arr_
+    #
+    #   s = Extlib::SimpleSet.new([:a, :b, :c])
+    #   s.merge([:c, :d, :e, f])  #=> #<SimpleSet: {:e, :c, :f, :a, :d, :b}>
     #
-    # @return <SimpleSet> The set after the Array was merged in.
+    # @param [Array] arr Values to merge with set.
+    #
+    # @return [SimpleSet] The set after the Array was merged in.
+    #
+    # @api public
     def merge(arr)
       super(arr.inject({}) {|s,x| s[x] = true; s })
     end
 
-    # @return <String> A human readable version of the set.
+    ##
+    # Get a human readable version of the set.
+    #
+    #   s = SimpleSet.new([:a, :b, :c])
+    #   s.inspect                 #=> "#<SimpleSet: {:c, :a, :b}>"
+    #
+    # @return [String] A human readable version of the set.
+    #
+    # @api public
     def inspect
       "#<SimpleSet: {#{keys.map {|x| x.inspect}.join(", ")}}>"
     end