extlib 0.9.6 → 0.9.7

data/Rakefile

@@ -46,7 +46,7 @@ spec = Gem::Specification.new do |s|
   s.extra_rdoc_files = ["LICENSE", "README.txt"]
 
   # Dependencies
-  s.add_dependency "english", ">=0.2.0"
+  # s.add_dependency "english", ">=0.2.0"
 end
 
 Rake::GemPackageTask.new(spec) do |package|
@@ -126,63 +126,37 @@ namespace :ci 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/rspec_report.html", "#{out}/rspec_report.html"
+    mv "ci/coverage", "#{out}/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"
+  task :spec => :prepare do
+    Rake::Task[:spec].invoke
+    mv ROOT + "coverage", ROOT + "ci/coverage"
   end
 
   task :doc do
-    require 'yardoc'
+    require 'yard'
     sh 'yardoc'
   end
 
-  task :saikuro => :prepare do
+  task :saikuro 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]
+task :ci => ["ci:spec"]
+
+desc 'Default: run spec examples'
+task :default => 'spec'
 
 ##############################################################################
 # Benchmarks
@@ -197,4 +171,4 @@ namespace :benchmark do
       system "ruby #{f}"
     end
   end  
-end
+end

data/lib/extlib.rb

@@ -31,8 +31,26 @@ require dir / 'module'
 require dir / 'nil'
 require dir / 'numeric'
 require dir / 'blank'
-require dir / 'pooling'
 require dir / 'simple_set'
 require dir / 'struct'
-require dir / 'hook'
 require dir / 'symbol'
+
+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 Extlib::Pooling.scavenger?
+        Extlib::Pooling.scavenger.wakeup
+      end
+    end
+    @exiting = true
+  end
+
+  def self.exiting
+    @exiting
+  end
+
+end

data/lib/extlib/dictionary.rb

@@ -0,0 +1,433 @@
+# TITLE:
+#
+#   Dictionary
+#
+# AUTHORS:
+#
+#   - Jan Molic
+#   - Thomas Sawyer
+#
+# CREDIT:
+#
+#   - Andrew Johnson (merge, to_a, inspect, shift and Hash[])
+#   - Jeff Sharpe    (reverse and reverse!)
+#   - Thomas Leitner (has_key? and key?)
+#
+# LICENSE:
+#
+#   Copyright (c) 2005 Jan Molic, Thomas Sawyer
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+#   Originally ported from OrderHash 2.0, Copyright (c) 2005 jan molic
+#
+# LOG:
+#
+#   - 2007.10.31 trans
+#     Fixed initialize so the constructor blocks correctly effected dictionary
+#     rather then just the internal hash.
+
+# = Dictionary
+#
+# The Dictionary class is a Hash that preserves order.
+# So it has some array-like extensions also. By defualt
+# a Dictionary object preserves insertion order, but any
+# order can be specified including alphabetical key order.
+#
+# == Usage
+#
+# Just require this file and use Dictionary instead of Hash.
+#
+#   # You can do simply
+#   hsh = Dictionary.new
+#   hsh['z'] = 1
+#   hsh['a'] = 2
+#   hsh['c'] = 3
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # or using Dictionary[] method
+#   hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # but this doesn't preserve order
+#   hsh = Dictionary['z'=>1, 'a'=>2, 'c'=>3]
+#   p hsh.keys     #=> ['a','c','z']
+#
+#   # Dictionary has useful extensions: push, pop and unshift
+#   p hsh.push('to_end', 15)       #=> true, key added
+#   p hsh.push('to_end', 30)       #=> false, already - nothing happen
+#   p hsh.unshift('to_begin', 50)  #=> true, key added
+#   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
+#   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
+#   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
+#
+# == Usage Notes
+#
+# * You can use #order_by to set internal sort order.
+# * #<< takes a two element [k,v] array and inserts.
+# * Use ::auto which creates Dictionay sub-entries as needed.
+# * And ::alpha which creates a new Dictionary sorted by key.
+
+class Dictionary
+
+  include Enumerable
+
+  class << self
+    #--
+    # TODO is this needed? Doesn't the super class do this?
+    #++
+    def [](*args)
+      hsh = new
+      if Hash === args[0]
+        hsh.replace(args[0])
+      elsif (args.size % 2) != 0
+        raise ArgumentError, "odd number of elements for Hash"
+      else
+        while !args.empty?
+          hsh[args.shift] = args.shift
+        end
+      end
+      hsh
+    end
+
+    # Like #new but the block sets the order.
+    #
+    def new_by(*args, &blk)
+      new(*args).order_by(&blk)
+    end
+
+    # Alternate to #new which creates a dictionary sorted by key.
+    #
+    #   d = Dictionary.alpha
+    #   d["z"] = 1
+    #   d["y"] = 2
+    #   d["x"] = 3
+    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+    #
+    # This is equivalent to:
+    #
+    #   Dictionary.new.order_by { |key,value| key }
+    def alpha(*args, &block)
+      new(*args, &block).order_by_key
+    end
+
+    # Alternate to #new which auto-creates sub-dictionaries as needed.
+    #
+    #   d = Dictionary.auto
+    #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
+    #
+    def auto(*args)
+      #AutoDictionary.new(*args)
+      leet = lambda { |hsh, key| hsh[key] = new(&leet) }
+      new(*args, &leet)
+    end
+  end
+
+   # New Dictiionary.
+  def initialize(*args, &blk)
+    @order = []
+    @order_by = nil
+    if blk
+      dict = self                                  # This ensure autmatic key entry effect the
+      oblk = lambda{ |hsh, key| blk[dict,key] }    # dictionary rather then just the interal hash.
+      @hash = Hash.new(*args, &oblk)
+    else
+      @hash = Hash.new(*args)
+    end
+  end
+
+  def order
+    reorder if @order_by
+    @order
+  end
+
+  # Keep dictionary sorted by a specific sort order.
+  def order_by( &block )
+    @order_by = block
+    order
+    self
+  end
+
+  # Keep dictionary sorted by key.
+  #
+  #   d = Dictionary.new.order_by_key
+  #   d["z"] = 1
+  #   d["y"] = 2
+  #   d["x"] = 3
+  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+  #
+  # This is equivalent to:
+  #
+  #   Dictionary.new.order_by { |key,value| key }
+  #
+  # The initializer Dictionary#alpha also provides this.
+  def order_by_key
+    @order_by = lambda { |k,v| k }
+    order
+    self
+  end
+
+  # Keep dictionary sorted by value.
+  #
+  #   d = Dictionary.new.order_by_value
+  #   d["z"] = 1
+  #   d["y"] = 2
+  #   d["x"] = 3
+  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+  #
+  # This is equivalent to:
+  #
+  #   Dictionary.new.order_by { |key,value| value }
+  def order_by_value
+    @order_by = lambda { |k,v| v }
+    order
+    self
+  end
+
+  #
+  def reorder
+    if @order_by
+      assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by(&@order_by)
+      @order = assoc.collect{ |k,v| k }
+    end
+    @order
+  end
+
+  def ==(hsh2)
+    if hsh2.is_a?( Dictionary )
+      @order == hsh2.order &&
+      @hash  == hsh2.instance_variable_get("@hash")
+    else
+      false
+    end
+  end
+
+  def [] k
+    @hash[ k ]
+  end
+
+  def fetch(k, *a, &b)
+    @hash.fetch(k, *a, &b)
+  end
+
+  # Store operator.
+  #
+  #   h[key] = value
+  #
+  # Or with additional index.
+  #
+  #  h[key,index] = value
+  def []=(k, i=nil, v=nil)
+    if v
+      insert(i,k,v)
+    else
+      store(k,i)
+    end
+  end
+
+  def insert( i,k,v )
+    @order.insert( i,k )
+    @hash.store( k,v )
+  end
+
+  def store( a,b )
+    @order.push( a ) unless @hash.has_key?( a )
+    @hash.store( a,b )
+  end
+
+  def clear
+    @order = []
+    @hash.clear
+  end
+
+  def delete( key )
+    @order.delete( key )
+    @hash.delete( key )
+  end
+
+  def each_key
+    order.each { |k| yield( k ) }
+    self
+  end
+
+  def each_value
+    order.each { |k| yield( @hash[k] ) }
+    self
+  end
+
+  def each
+    order.each { |k| yield( k,@hash[k] ) }
+    self
+  end
+  alias each_pair each
+
+  def delete_if
+    order.clone.each { |k| delete k if yield(k,@hash[k]) }
+    self
+  end
+
+  def values
+    ary = []
+    order.each { |k| ary.push @hash[k] }
+    ary
+  end
+
+  def keys
+    order
+  end
+
+  def invert
+    hsh2 = self.class.new
+    order.each { |k| hsh2[@hash[k]] = k }
+    hsh2
+  end
+
+  def reject( &block )
+    self.dup.delete_if(&block)
+  end
+
+  def reject!( &block )
+    hsh2 = reject(&block)
+    self == hsh2 ? nil : hsh2
+  end
+
+  def replace( hsh2 )
+    @order = hsh2.order
+    @hash = hsh2.hash
+  end
+
+  def shift
+    key = order.first
+    key ? [key,delete(key)] : super
+  end
+
+  def unshift( k,v )
+    unless @hash.include?( k )
+      @order.unshift( k )
+      @hash.store( k,v )
+      true
+    else
+      false
+    end
+  end
+
+  def <<(kv)
+    push( *kv )
+  end
+
+  def push( k,v )
+    unless @hash.include?( k )
+      @order.push( k )
+      @hash.store( k,v )
+      true
+    else
+      false
+    end
+  end
+
+  def pop
+    key = order.last
+    key ? [key,delete(key)] : nil
+  end
+
+  def inspect
+    ary = []
+    each {|k,v| ary << k.inspect + "=>" + v.inspect}
+    '{' + ary.join(", ") + '}'
+  end
+
+  def dup
+    a = []
+    each{ |k,v| a << k; a << v }
+    self.class[*a]
+  end
+
+  def update( hsh2 )
+    hsh2.each { |k,v| self[k] = v }
+    reorder
+    self
+  end
+  alias :merge! update
+
+  def merge( hsh2 )
+    self.dup.update(hsh2)
+  end
+
+  def select
+    ary = []
+    each { |k,v| ary << [k,v] if yield k,v }
+    ary
+  end
+
+  def reverse!
+    @order.reverse!
+    self
+  end
+
+  def reverse
+    dup.reverse!
+  end
+
+  def first
+    @hash[order.first]
+  end
+
+  def last
+    @hash[order.last]
+  end
+
+  def length
+    @order.length
+  end
+  alias :size :length
+
+  def empty?
+    @hash.empty?
+  end
+
+  def has_key?(key)
+    @hash.has_key?(key)
+  end
+
+  def key?(key)
+    @hash.key?(key)
+  end
+
+  def to_a
+    ary = []
+    each { |k,v| ary << [k,v] }
+    ary
+  end
+  
+  def to_json
+    buf = "["
+    map do |k,v|
+      buf << k.to_json
+      buf << ", "
+      buf << v.to_json
+    end.join(", ")
+    buf << "]"
+    buf
+  end
+
+  def to_s
+    self.to_a.to_s
+  end
+
+  def to_hash
+    @hash.dup
+  end
+
+  def to_h
+    @hash.dup
+  end
+end

data/lib/extlib/hash.rb

@@ -1,5 +1,3 @@
-require 'base64'
-
 class Hash
   class << self
     # Converts valid XML into a Ruby Hash structure.
@@ -162,7 +160,7 @@ class Hash
   #     #=> 'one="1" two="TWO"'
   def to_xml_attributes
     map do |k,v|
-      %{#{k.to_s.camel_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+      %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
     end.join(' ')
   end
 
@@ -253,7 +251,7 @@ class REXMLUtilityNode
   self.typecasts["symbol"]        = lambda{|v| v.to_sym}
   self.typecasts["string"]        = lambda{|v| v.to_s}
   self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
-  self.typecasts["base64Binary"]  = lambda{|v| Base64.decode64(v)}
+  self.typecasts["base64Binary"]  = lambda{|v| v.unpack('m').first }
 
   self.available_typecasts = self.typecasts.keys
 
@@ -275,7 +273,7 @@ class REXMLUtilityNode
 
   def to_hash
     if @type == "file"
-      f = StringIO.new(::Base64.decode64(@children.first || ""))
+      f = StringIO.new((@children.first || '').unpack('m').first)
       class << f
         attr_accessor :original_filename, :content_type
       end

data/lib/extlib/inflection.rb

@@ -1,19 +1,10 @@
-# The original of this file was copied for the ActiveSupport project which is
-# part of the Ruby On Rails web-framework (http://rubyonrails.org)
-#
-# Methods have been modified or removed. English inflection is now provided via
-# the english gem (http://english.rubyforge.org)
-#
-# sudo gem install english
-#
-gem 'english', '>=0.2.0'
-require 'english/inflect'
-
-English::Inflect.word 'postgres'
-English::Inflect.singular_word "status", "status"
-
 module Extlib
+
+  # = English Nouns Number Inflection.
+  #
+  # This module provides english singular <-> plural noun inflections.
   module Inflection
+
     class << self
       # Take an underscored name and make it into a camelized name
       #
@@ -103,36 +94,342 @@ module Extlib
 
         Object.module_eval("::#{$1}", __FILE__, __LINE__)
       end
+    end
+
+    @singular_of = {}
+    @plural_of = {}
 
-      # The reverse of pluralize, returns the singular form of a word in a string.
-      # Wraps the English gem
+    @singular_rules = []
+    @plural_rules = []
+
+    class << self
+      # Defines a general inflection exception case.
       #
-      # @example
-      #   "posts".singularize #=> "post"
-      #   "octopi".singularize #=> "octopus"
-      #   "sheep".singluarize #=> "sheep"
-      #   "word".singluarize #=> "word"
-      #   "the blue mailmen".singularize #=> "the blue mailman"
-      #   "CamelOctopi".singularize #=> "CamelOctopus"
+      # ==== Parameters
+      # singular<String>::
+      #   singular form of the word
+      # plural<String>::
+      #   plural form of the word
+      #
+      # ==== Examples
       #
-      def singularize(word)
-        English::Inflect.singular(word)
+      # Here we define erratum/errata exception case:
+      #
+      # English::Inflect.word "erratum", "errata"
+      #
+      # In case singular and plural forms are the same omit
+      # second argument on call:
+      #
+      # English::Inflect.word 'information'
+      def word(singular, plural=nil)
+        plural = singular unless plural
+        singular_word(singular, plural)
+        plural_word(singular, plural)
       end
 
-      # Returns the plural form of the word in the string.
+      def clear(type = :all)
+        if type == :singular || type == :all
+          @singular_of = {}
+          @singular_rules = []
+          @singularization_rules, @singularization_regex = nil, nil
+        end
+        if type == :plural || type == :all
+          @singular_of = {}
+          @singular_rules = []
+          @singularization_rules, @singularization_regex = nil, nil
+        end
+      end
+
+
+      # Define a singularization exception.
       #
-      # @example
-      #   "post".pluralize #=> "posts"
-      #   "octopus".pluralize #=> "octopi"
-      #   "sheep".pluralize #=> "sheep"
-      #   "words".pluralize #=> "words"
-      #   "the blue mailman".pluralize #=> "the blue mailmen"
-      #   "CamelOctopus".pluralize #=> "CamelOctopi"
+      # ==== Parameters
+      # singular<String>::
+      #   singular form of the word
+      # plural<String>::
+      #   plural form of the word
+      def singular_word(singular, plural)
+        @singular_of[plural] = singular
+        @singular_of[plural.capitalize] = singular.capitalize
+      end
+
+      # Define a pluralization exception.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   singular form of the word
+      # plural<String>::
+      #   plural form of the word
+      def plural_word(singular, plural)
+        @plural_of[singular] = plural
+        @plural_of[singular.capitalize] = plural.capitalize
+      end
+
+      # Define a general rule.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   ending of the word in singular form
+      # plural<String>::
+      #   ending of the word in plural form
+      # whole_word<Boolean>::
+      #   for capitalization, since words can be
+      #   capitalized (Man => Men)      #
+      # ==== Examples
+      # Once the following rule is defined:
+      # English::Inflect.rule 'y', 'ies'
+      #
+      # You can see the following results:
+      # irb> "fly".plural
+      # => flies
+      # irb> "cry".plural
+      # => cries
+      # Define a general rule.
+
+      def rule(singular, plural, whole_word = false)
+        singular_rule(singular, plural)
+        plural_rule(singular, plural)
+        word(singular, plural) if whole_word
+      end
+
+      # Define a singularization rule.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   ending of the word in singular form
+      # plural<String>::
+      #   ending of the word in plural form
+      #
+      # ==== Examples
+      # Once the following rule is defined:
+      # English::Inflect.singular_rule 'o', 'oes'
+      #
+      # You can see the following results:
+      # irb> "heroes".singular
+      # => hero
+      def singular_rule(singular, plural)
+        @singular_rules << [singular, plural]
+      end
+
+      # Define a plurualization rule.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   ending of the word in singular form
+      # plural<String>::
+      #   ending of the word in plural form
+      #
+      # ==== Examples
+      # Once the following rule is defined:
+      # English::Inflect.singular_rule 'fe', 'ves'
       #
-      def pluralize(word)
-        English::Inflect.plural(word)
+      # You can see the following results:
+      # irb> "wife".plural
+      # => wives
+      def plural_rule(singular, plural)
+        @plural_rules << [singular, plural]
       end
 
+      # Read prepared singularization rules.
+      def singularization_rules
+        if defined?(@singularization_regex) && @singularization_regex
+          return [@singularization_regex, @singularization_hash]
+        end
+        # No sorting needed: Regexen match on longest string
+        @singularization_regex = Regexp.new("(" + @singular_rules.map {|s,p| p}.join("|") + ")$", "i")
+        @singularization_hash  = Hash[*@singular_rules.flatten].invert
+        [@singularization_regex, @singularization_hash]
+      end
+
+      # Read prepared pluralization rules.
+      def pluralization_rules
+        if defined?(@pluralization_regex) && @pluralization_regex
+          return [@pluralization_regex, @pluralization_hash]
+        end
+        @pluralization_regex = Regexp.new("(" + @plural_rules.map {|s,p| s}.join("|") + ")$", "i")
+        @pluralization_hash  = Hash[*@plural_rules.flatten]
+        [@pluralization_regex, @pluralization_hash]
+      end
+
+      attr_reader :singular_of, :plural_of
+
+      # Convert an English word from plurel to singular.
+      #
+      #   "boys".singular      #=> boy
+      #   "tomatoes".singular  #=> tomato
+      #
+      # ==== Parameters
+      # word<String>:: word to singularize
+      #
+      # ==== Returns
+      # <String>:: singularized form of word
+      #
+      # ==== Notes
+      # Aliased as singularize (a Railism)
+      def singular(word)
+        if result = singular_of[word]
+          return result.dup
+        end
+        result = word.dup
+        regex, hash = singularization_rules
+        result.sub!(regex) {|m| hash[m]}
+        singular_of[word] = result
+        return result
+      end
+
+      # Alias for #singular (a Railism).
+      #
+      alias_method(:singularize, :singular)
+
+      # Convert an English word from singular to plurel.
+      #
+      #   "boy".plural     #=> boys
+      #   "tomato".plural  #=> tomatoes
+      #
+      # ==== Parameters
+      # word<String>:: word to pluralize
+      #
+      # ==== Returns
+      # <String>:: pluralized form of word
+      #
+      # ==== Notes
+      # Aliased as pluralize (a Railism)
+      def plural(word)
+        # special exceptions
+        return "" if word == ""
+        if result = plural_of[word]
+          return result.dup
+        end
+        result = word.dup
+        regex, hash = pluralization_rules
+        result.sub!(regex) {|m| hash[m]}
+        plural_of[word] = result
+        return result
+      end
+
+      # Alias for #plural (a Railism).
+      alias_method(:pluralize, :plural)
     end
-  end # module Inflection
-end # module Extlib
+
+    # One argument means singular and plural are the same.
+
+    word 'equipment'
+    word 'information'
+    word 'money'
+    word 'species'
+    word 'series'
+    word 'fish'
+    word 'sheep'
+    word 'moose'
+    word 'hovercraft'
+    word 'grass'
+    word 'rain'
+    word 'milk'
+    word 'rice'
+    word 'plurals'
+    word 'postgres'
+    word 'status'
+
+    # Two arguments defines a singular and plural exception.
+    word 'status'    , 'status'
+    word 'Swiss'     , 'Swiss'
+    word 'life'      , 'lives'
+    word 'wife'      , 'wives'
+    word 'goose'     , 'geese'
+    word 'criterion' , 'criteria'
+    word 'alias'     , 'aliases'
+    word 'status'    , 'statuses'
+    word 'axis'      , 'axes'
+    word 'crisis'    , 'crises'
+    word 'testis'    , 'testes'
+    word 'potato'    , 'potatoes'
+    word 'tomato'    , 'tomatoes'
+    word 'buffalo'   , 'buffaloes'
+    word 'torpedo'   , 'torpedoes'
+    word 'quiz'      , 'quizzes'
+    word 'matrix'    , 'matrices'
+    word 'vertex'    , 'vertices'
+    word 'index'     , 'indices'
+    word 'ox'        , 'oxen'
+    word 'mouse'     , 'mice'
+    word 'louse'     , 'lice'
+    word 'thesis'    , 'theses'
+    word 'thief'     , 'thieves'
+    word 'analysis'  , 'analyses'
+    word 'erratum'   , 'errata'
+    word 'phenomenon', 'phenomena'
+    word 'octopus'   , 'octopi'
+    word 'thesaurus' , 'thesauri'
+    word 'movie'     , 'movies'
+    word 'cactus'    , 'cacti'
+    word 'plus'      , 'plusses'
+    word 'cross'     , 'crosses'
+    word 'medium'    , 'media'
+    word 'cow'       , 'kine'
+    word 'datum'     , 'data'
+    word 'basis'     , 'bases'
+    word 'diagnosis' , 'diagnoses'
+
+    # One-way singularization exception (convert plural to singular).
+
+    # General rules.
+    rule 'person' , 'people', true
+    rule 'shoe'   , 'shoes', true
+    rule 'hive'   , 'hives', true
+    rule 'man'    , 'men', true
+    rule 'child'  , 'children', true
+    rule 'news'   , 'news', true
+    rule 'rf'   , 'rves'
+    rule 'af'   , 'aves'
+    rule 'ero'  , 'eroes'
+    rule 'man'  , 'men'
+    rule 'ch'   , 'ches'
+    rule 'sh'   , 'shes'
+    rule 'ss'   , 'sses'
+    rule 'ta'   , 'tum'
+    rule 'ia'   , 'ium'
+    rule 'ra'   , 'rum'
+    rule 'ay'   , 'ays'
+    rule 'ey'   , 'eys'
+    rule 'oy'   , 'oys'
+    rule 'uy'   , 'uys'
+    rule 'y'    , 'ies'
+    rule 'x'    , 'xes'
+    rule 'lf'   , 'lves'
+    rule 'ffe'  , 'ffes'
+    rule 'afe'  , 'aves'
+    rule 'ouse' , 'ouses'
+    # more cases of words ending in -oses not being singularized properly
+    # than cases of words ending in -osis
+#    rule 'osis' , 'oses'
+    rule 'ox'   , 'oxes'
+    rule 'us'   , 'uses'
+    rule ''     , 's'
+
+    # One-way singular rules.
+
+    singular_rule 'of' , 'ofs' # proof
+    singular_rule 'o'  , 'oes' # hero, heroes
+    singular_rule 'f'  , 'ves'
+
+    # One-way plural rules.
+
+    #plural_rule 'fe' , 'ves' # safe, wife
+    plural_rule 's'   , 'ses'
+    plural_rule 'ive' , 'ives' # don't want to snag wife
+    plural_rule 'fe'  , 'ves'  # don't want to snag perspectives
+
+
+  end
+end
+
+class String
+  def singular
+    Extlib::Inflection.singular(self)
+  end
+  alias_method(:singularize, :singular)
+  def plural
+    Extlib::Inflection.plural(self)
+  end
+  alias_method(:pluralize, :plural)
+end

data/lib/extlib/lazy_array.rb

@@ -1,5 +1,5 @@
 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 extend ].include?(m) }
+  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 extend ].include?(m.to_s) }
 
   include Enumerable
 

data/lib/extlib/mash.rb

@@ -96,6 +96,17 @@ class Mash < Hash
     super(convert_key(key)) 
   end
 
+  # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
+  #
+  # @return <Mash> A new mash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { "two" => 2, "three" => 3 }
+  def except(*keys)
+    super(*keys.map {|k| convert_key(k)})
+  end
+
   # Used to provide the same interface as Hash.
   #
   # @return <Mash> This mash unchanged.
@@ -126,13 +137,12 @@ class Mash < Hash
   #
   # @api private
   def convert_value(value) 
-    case value 
-    when Hash 
+    if value.class == Hash
       value.to_mash 
-    when Array 
+    elsif value.is_a?(Array)
       value.collect { |e| convert_value(e) } 
-    else 
-      value 
+    else
+      value
     end 
   end
 end

data/lib/extlib/pooling.rb

@@ -25,31 +25,43 @@ module Extlib
   # object is reset when it is released.
   module Pooling
 
+    def self.scavenger?
+      @scavenger && @scavenger.alive?
+    end
+
     def self.scavenger
-      @scavenger || begin
+      if @scavenger.nil? || !@scavenger.alive?
         @scavenger = Thread.new do
-          loop do
+          running = true
+          while running do
             # Sleep before we actually start doing anything.
             # Otherwise we might clean up something we just made
             sleep(scavenger_interval)
+
             lock.synchronize do
               pools.each do |pool|
                 # This is a useful check, but non-essential, and right now it breaks lots of stuff.
                 # if pool.expired?
                 pool.lock.synchronize do
-                  if pool.used.size == 0
+                  if pool.expired?
                     pool.dispose
                   end
                 end
                 # end
               end
+
+              # The pool is empty, we stop the scavenger
+              # It wil be restarted if new resources are added again
+              if pools.empty?
+                running = false
+              end
             end
           end # loop
         end
-
-        @scavenger.priority = -10
-        @scavenger
       end
+
+      @scavenger.priority = -10
+      @scavenger
     end
 
     def self.pools
@@ -79,7 +91,7 @@ module Extlib
           alias __new new
         end
 
-        @__pools = Hash.new { |h,k| __pool_lock.synchronize { h[k] = Pool.new(target.pool_size, target, k) } }
+        @__pools     = {}
         @__pool_lock = Mutex.new
         @__pool_wait = ConditionVariable.new
 
@@ -92,7 +104,7 @@ module Extlib
         end
 
         def self.new(*args)
-          @__pools[args].new
+          (@__pools[args] ||= __pool_lock.synchronize { Pool.new(self.pool_size, self, args) }).new
         end
 
         def self.__pools
@@ -122,7 +134,7 @@ module Extlib
         @args = args
 
         @available = []
-        @used      = Set.new
+        @used      = {}
         Extlib::Pooling::append_pool(self)
       end
 
@@ -144,14 +156,14 @@ module Extlib
           lock.synchronize do
             if @available.size > 0
               instance = @available.pop
-              @used.add instance
+              @used[instance.object_id] = instance
             elsif @used.size < @max_size
               instance = @resource.__new(*@args)
               raise InvalidResourceError.new("#{@resource} constructor created a nil object") if instance.nil?
               raise InvalidResourceError.new("#{instance} is already part of the pool") if @used.include? instance
               instance.instance_variable_set(:@__pool, self)
               instance.instance_variable_set(:@__allocated_in_pool, Time.now)
-              @used.add instance
+              @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
@@ -171,8 +183,9 @@ module Extlib
       end
 
       def release(instance)
+        instance.instance_variable_set(:@__allocated_in_pool, Time.now)
         lock.synchronize do
-          @used.delete instance
+          @used.delete(instance.object_id)
           @available.push(instance)
           wait.signal
         end
@@ -182,7 +195,7 @@ module Extlib
       def delete(instance)
         lock.synchronize do
           instance.instance_variable_set(:@__pool, nil)
-          used.delete instance
+          @used.delete(instance.object_id)
         end
         nil
       end
@@ -206,20 +219,16 @@ module Extlib
         !Extlib::Pooling::pools.delete?(self).nil?
       end
 
-      # Disabled temporarily.
-      #
-      # def expired?
-      #   lock.synchronize do
-      #     @available.each do |instance|
-      #       if instance.instance_variable_get(:@__allocated_in_pool) + scavenge_interval < Time.now
-      #         instance.release
-      #         @available.delete(instance)
-      #       end
-      #     end
-      #
-      #     size == 0
-      #   end
-      # end
+      def expired?
+        @available.each do |instance|
+          if Extlib.exiting || instance.instance_variable_get(:@__allocated_in_pool) + Extlib::Pooling.scavenger_interval <= Time.now
+            instance.dispose
+            @available.delete(instance)
+          end
+        end
+
+        size == 0
+      end
 
     end
 

data/lib/extlib/string.rb

@@ -127,6 +127,6 @@ class String
   # "%s %s %s" % %w(one two three) #=> "one two three"
   # "%3$s %2$s %1$s" % %w(one two three) #=> "three two one"
   def t(*values)
-    self.class::translate(self) % values
+    self.class::translate(self) % values.collect! { |value| value.frozen? ? value : self.class::translate(value.to_s) }
   end
 end # class String

data/lib/extlib/time.rb

@@ -5,7 +5,7 @@ class Time
   # 
   # @example
   #   Time.now.to_json # => "\"2008-03-28T17:54:20-05:00\""
-  def to_json
+  def to_json(*)
     self.xmlschema.to_json
   end
   

data/lib/extlib/version.rb

@@ -1,3 +1,3 @@
 module Extlib
-  VERSION = "0.9.6"
+  VERSION = "0.9.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: extlib
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors: 
 - Sam Smoot
@@ -9,19 +9,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-09 00:00:00 +03:00
+date: 2008-10-06 00:00:00 +03:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: english
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.2.0
-    version: 
+dependencies: []
+
 description: Support library for DataMapper and Merb.
 email: ssmoot@gmail.com
 executables: []
@@ -41,6 +32,7 @@ files:
 - lib/extlib/boolean.rb
 - lib/extlib/class.rb
 - lib/extlib/datetime.rb
+- lib/extlib/dictionary.rb
 - lib/extlib/hash.rb
 - lib/extlib/hook.rb
 - lib/extlib/inflection.rb