extlib 0.9.9 → 0.9.10

data/History.txt

@@ -1,3 +1,21 @@
+=== 0.9.10 / 2009-01-19
+
+* 1 major enhancement:
+
+  * Ruby 1.9.1 compatibility
+
+* 1 minor enhancement:
+
+  * Updated LazyArray#eql? and LazyArray#== to compare without lazy
+    loading if possible.
+
+3 bug fixes:
+
+  * Fix for inheritance and hooks
+  * Fix for Class inheritable accessor to use #try_dup
+  * Fix for LazyArray to be more explicit in delegating to Array,
+    to lessen conflicts in subclasses
+
 === 0.9.9 / 2008-12-07
 
 * 1 major enhancement:

data/LICENSE

@@ -18,3 +18,30 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---
+---
+
+Some portions of blank.rb and mash.rb are verbatim copies of software
+licensed under the MIT license. That license is included below:
+
+Copyright (c) 2005-2008 David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -75,7 +75,7 @@ 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')
+    t.spec_files = Pathname.glob(ENV['FILES'] || 'spec/**/*_spec.rb').map { |f| f.to_s }
 
     begin
       gem 'rcov'

data/lib/extlib/class.rb

@@ -118,7 +118,7 @@ class Class
           return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
           ivar = superclass.#{ivar}
           return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
-          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
+          @#{ivar} = ivar.try_dup
         end
       RUBY
       unless instance_reader == false

data/lib/extlib/hook.rb

@@ -249,7 +249,7 @@ module Extlib
 
         source = %{class << self\n#{source}\nend} if scope == :class
 
-        hooks[target_method][:in].class_eval(source, __FILE__, __LINE__)
+        hooks[target_method][:in].class_eval(source, __FILE__, __LINE__ - 12)
       end
 
       # Returns ruby code that will invoke the hook. It checks the arity of the hook method
@@ -283,7 +283,7 @@ module Extlib
           end
         EOD
 
-        if scope == :instance && !instance_methods(false).include?(target_method.to_s)
+        if scope == :instance && !instance_methods(false).map { |m| m.to_s }.include?(target_method.to_s)
           send(:alias_method, renamed_target, target_method)
 
           proxy_module = Module.new
@@ -315,14 +315,33 @@ module Extlib
           raise ArgumentError, 'You need to pass :class or :instance as scope'
         end
 
-        register_hook(target_method, scope) unless registered_as_hook?(target_method, scope)
-
-        hooks = hooks_with_scope(scope)
+        if registered_as_hook?(target_method, scope)
+          hooks = hooks_with_scope(scope)
+
+          #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
+            )
+            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
+        else
+          register_hook(target_method, scope)
+          hooks = hooks_with_scope(scope)
+        end
 
+        #if  we were passed a block, create a method out of it.
         if block
           method_sym = "__hooks_#{type}_#{quote_method(target_method)}_#{hooks[target_method][type].length}".to_sym
           if scope == :class
-            (class << self; self; end;).instance_eval do
+            meta_class.instance_eval do
               define_method(method_sym, &block)
             end
           else

data/lib/extlib/lazy_array.rb

@@ -1,25 +1,23 @@
 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) }
 
-  include Enumerable
-
-  # this avoids a strange Ruby 1.8.6 bug where it cannot delegate to super() in #first
-  if RUBY_VERSION <= '1.8.6'
-    def first(*args)
-      if lazy_possible?(@head, *args)
-        @head.first(*args)
-      else
+  # 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
-        @array.first(*args)
-      end
-    end
-  else
-    def first(*args)
-      if lazy_possible?(@head, *args)
-        @head.first(*args)
-      else
-        super
+        results = @array.#{method}(*args, &block)
+        results.equal?(@array) ? self : results
       end
+    EOS
+  end
+
+  def first(*args)
+    if lazy_possible?(@head, *args)
+      @head.first(*args)
+    else
+      lazy_load
+      @array.first(*args)
     end
   end
 
@@ -27,7 +25,8 @@ class LazyArray  # borrowed partially from StrokeDB
     if lazy_possible?(@tail, *args)
       @tail.last(*args)
     else
-      super
+      lazy_load
+      @array.last(*args)
     end
   end
 
@@ -37,7 +36,8 @@ class LazyArray  # borrowed partially from StrokeDB
     elsif index < 0 && lazy_possible?(@tail, index.abs)
       @tail.at(index)
     else
-      super
+      lazy_load
+      @array.at(index)
     end
   end
 
@@ -49,7 +49,8 @@ class LazyArray  # borrowed partially from StrokeDB
     elsif index < 0 && lazy_possible?(@tail, index.abs)
       @tail.fetch(*args, &block)
     else
-      super
+      lazy_load
+      @array.fetch(*args, &block)
     end
   end
 
@@ -69,28 +70,36 @@ class LazyArray  # borrowed partially from StrokeDB
     if lazy_possible
       accumulator
     else
-      super
+      lazy_load
+      @array.values_at(*args)
     end
   end
 
   def index(entry)
-    (lazy_possible?(@head) && @head.index(entry)) || super
+    (lazy_possible?(@head) && @head.index(entry)) || begin
+      lazy_load
+      @array.index(entry)
+    end
   end
 
   def include?(entry)
     (lazy_possible?(@tail) && @tail.include?(entry)) ||
-    (lazy_possible?(@head) && @head.include?(entry)) ||
-    super
+    (lazy_possible?(@head) && @head.include?(entry)) || begin
+      lazy_load
+      @array.include?(entry)
+    end
   end
 
   def empty?
     !any?
   end
 
-  def any?
-    (lazy_possible?(@tail) && @tail.any?) ||
-    (lazy_possible?(@head) && @head.any?) ||
-    super
+  def any?(&block)
+    (lazy_possible?(@tail) && @tail.any?(&block)) ||
+    (lazy_possible?(@head) && @head.any?(&block)) || begin
+      lazy_load
+      @array.any?(&block)
+    end
   end
 
   def [](*args)
@@ -103,11 +112,12 @@ class LazyArray  # borrowed partially from StrokeDB
     length ||= 1
 
     if index >= 0 && lazy_possible?(@head, index + length)
-      @head.slice(*args)
+      @head[*args]
     elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
-      @tail.slice(*args)
+      @tail[*args]
     else
-      super
+      lazy_load
+      @array[*args]
     end
   end
 
@@ -123,7 +133,8 @@ class LazyArray  # borrowed partially from StrokeDB
     elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
       @tail.slice!(*args)
     else
-      super
+      lazy_load
+      @array.slice!(*args)
     end
   end
 
@@ -137,7 +148,8 @@ class LazyArray  # borrowed partially from StrokeDB
     elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
       @tail.[]=(*args)
     else
-      super
+      lazy_load
+      @array.[]=(*args)
     end
   end
 
@@ -167,7 +179,8 @@ class LazyArray  # borrowed partially from StrokeDB
 
   def <<(entry)
     if loaded?
-      super
+      lazy_load
+      @array << entry
     else
       @tail << entry
     end
@@ -178,16 +191,18 @@ class LazyArray  # borrowed partially from StrokeDB
 
   def concat(other)
     if loaded?
-      super
+      lazy_load
+      @array.concat(other)
     else
-      @tail.concat(other.entries)
+      @tail.concat(other)
     end
     self
   end
 
   def push(*entries)
     if loaded?
-      super
+      lazy_load
+      @array.push(*entries)
     else
       @tail.push(*entries)
     end
@@ -196,7 +211,8 @@ class LazyArray  # borrowed partially from StrokeDB
 
   def unshift(*entries)
     if loaded?
-      super
+      lazy_load
+      @array.unshift(*entries)
     else
       @head.unshift(*entries)
     end
@@ -209,7 +225,8 @@ class LazyArray  # borrowed partially from StrokeDB
     elsif index < 0 && lazy_possible?(@tail, index.abs - 1)
       @tail.insert(index, *entries)
     else
-      super
+      lazy_load
+      @array.insert(index, *entries)
     end
     self
   end
@@ -218,7 +235,8 @@ class LazyArray  # borrowed partially from StrokeDB
     if lazy_possible?(@tail)
       @tail.pop
     else
-      super
+      lazy_load
+      @array.pop
     end
   end
 
@@ -226,7 +244,8 @@ class LazyArray  # borrowed partially from StrokeDB
     if lazy_possible?(@head)
       @head.shift
     else
-      super
+      lazy_load
+      @array.shift
     end
   end
 
@@ -236,13 +255,15 @@ class LazyArray  # borrowed partially from StrokeDB
     elsif index < 0 && lazy_possible?(@tail, index.abs)
       @tail.delete_at(index)
     else
-      super
+      lazy_load
+      @array.delete_at(index)
     end
   end
 
   def delete_if(&block)
     if loaded?
-      super
+      lazy_load
+      @array.delete_if(&block)
     else
       @reapers ||= []
       @reapers << block
@@ -254,7 +275,7 @@ class LazyArray  # borrowed partially from StrokeDB
 
   def replace(other)
     mark_loaded
-    @array.replace(other.entries)
+    @array.replace(other)
     self
   end
 
@@ -284,6 +305,8 @@ class LazyArray  # borrowed partially from StrokeDB
     super || @array.kind_of?(klass)
   end
 
+  alias is_a? kind_of?
+
   def respond_to?(method, include_private = false)
     super || @array.respond_to?(method)
   end
@@ -304,11 +327,58 @@ class LazyArray  # borrowed partially from StrokeDB
   end
 
   def eql?(other)
-    lazy_load
-    @array.eql?(other.entries)
+    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
+    end
+
+    # convert other to an Array before checking equality
+    @array.eql?(other.to_ary)
   end
 
-  alias == eql?
+  def ==(other)
+    return true if equal?(other)
+    return false unless other.respond_to?(:to_ary)
+
+    # 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
+
+      # 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
+
+      lazy_load
+    end
+
+    @array == other
+  end
 
   protected
 

data/lib/extlib/module.rb

@@ -30,7 +30,11 @@ class Module
     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
+        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
 

data/lib/extlib/version.rb

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

data/spec/class_spec.rb

@@ -18,6 +18,14 @@ class Grandparent
   self._attribute = 1900
 end
 
+class ClassWithInheritableSymbolAccessor
+  class_inheritable_accessor :symbol
+  self.symbol = :foo
+end
+
+class ClassInheritingSymbolAccessor < ClassWithInheritableSymbolAccessor
+end
+
 describe Class, "#inheritable_accessor" do
 
   after :each do
@@ -104,6 +112,14 @@ describe Class, "#inheritable_accessor" do
 
 end
 
+describe Class, "#inheritable_accessor (of type Symbol)" do
+
+  it "should not raise" do
+    lambda { ClassInheritingSymbolAccessor.symbol }.should_not raise_error(TypeError)
+  end
+
+end
+
 #
 # The bug that prompted this estoric spec was found in
 # the wild when using dm-is-versioned with c_i_w.
@@ -132,10 +148,10 @@ end
 
 describe Class, "#inheritable_accessor" do
   it "uses object_id for comparison" do
-    Model.methods.should include("plugin_options")
+    Model.methods.map { |m| m.to_s }.should include("plugin_options")
     Model.plugin_options.should == :foo
 
-    Model::Version.methods.should include("plugin_options")
+    Model::Version.methods.map { |m| m.to_s }.should include("plugin_options")
     Model::Version.plugin_options.should == :foo
   end
 end

data/spec/hook_spec.rb

@@ -779,6 +779,34 @@ describe Extlib::Hook do
         inst.should_not_receive(:hello_world!)
         inst.hookable
       end
+
+      it 'should call different hooks in different children when they are defined there' do
+        @class.send(:define_method, :hello_world) {}
+
+        @child1 = Class.new(@class) do
+          before(:hello_world){ hi_dad! }
+        end
+
+        @child2 = Class.new(@class) do
+          before(:hello_world){ hi_mom! }
+        end
+
+        @child3 = Class.new(@child1) do
+          before(:hello_world){ hi_grandma! }
+        end
+
+        inst1 = @child1.new
+        inst2 = @child2.new
+        inst3 = @child3.new
+        inst1.should_receive(:hi_dad!).once
+        inst2.should_receive(:hi_mom!).once
+        inst3.should_receive(:hi_dad!).once
+        inst3.should_receive(:hi_grandma!).once
+        inst1.hello_world
+        inst2.hello_world
+        inst3.hello_world
+      end
+
     end
 
   end

data/spec/lazy_array_spec.rb

@@ -44,7 +44,7 @@ module LazyArraySpec
       end
 
       it 'should eql self' do
-        action.should eql(subject.entries)
+        action.should eql(subject)
       end
     end
 
@@ -176,42 +176,72 @@ end
     should_respond_to(:any?)
 
     describe '#any?', state do
-      describe 'when the subject has entries that are not loaded' do
+      describe 'when not provided a block' do
         action { subject.any? }
 
-        should_return_true
-        should_be_a_kicker
-        should_not_change_subject
-      end
+        describe 'when the subject has entries that are not loaded' do
+          should_return_true
+          should_be_a_kicker
+          should_not_change_subject
+        end
 
-      describe 'when the subject has entries that are prepended' do
-        subject { LazyArray.new.unshift(@nancy) }
+        describe 'when the subject has entries that are prepended' do
+          subject { LazyArray.new.unshift(@nancy) }
 
-        action { subject.any? }
+          should_return_true
+          should_not_be_a_kicker
+          should_not_change_subject
+        end
 
-        should_return_true
-        should_not_be_a_kicker
-        should_not_change_subject
-      end
+        describe 'when the subject has entries that are appended' do
+          subject { LazyArray.new << @nancy }
 
-      describe 'when the subject has entries that are appended' do
-        subject { LazyArray.new << @nancy }
+          should_return_true
+          should_not_be_a_kicker
+          should_not_change_subject
+        end
 
-        action { subject.any? }
+        describe 'when the subject has no entries' do
+          subject { LazyArray.new }
 
-        should_return_true
-        should_not_be_a_kicker
-        should_not_change_subject
+          should_return_false
+          should_be_a_kicker
+          should_not_change_subject
+        end
       end
 
-      describe 'when the subject has no entries' do
-        subject { LazyArray.new }
+      describe 'when provided a block that always returns true' do
+        action { subject.any? { true } }
 
-        action { subject.any? }
+        describe 'when the subject has entries that are not loaded' do
+          should_return_true
+          should_be_a_kicker
+          should_not_change_subject
+        end
 
-        should_return_false
-        should_be_a_kicker
-        should_not_change_subject
+        describe 'when the subject has entries that are prepended' do
+          subject { LazyArray.new.unshift(@nancy) }
+
+          should_return_true
+          should_not_be_a_kicker
+          should_not_change_subject
+        end
+
+        describe 'when the subject has entries that are appended' do
+          subject { LazyArray.new << @nancy }
+
+          should_return_true
+          should_not_be_a_kicker
+          should_not_change_subject
+        end
+
+        describe 'when the subject has no entries' do
+          subject { LazyArray.new }
+
+          should_return_false
+          should_be_a_kicker
+          should_not_change_subject
+        end
       end
     end
 
@@ -472,7 +502,7 @@ end
     describe '#each_with_index', state do
       before { @accumulator = [] }
 
-      action { subject.each_with_index { |*args| @accumulator << args } }
+      action { subject.each_with_index { |entry,index| @accumulator << [ entry, index ] } }
 
       should_return_subject
       should_be_a_kicker
@@ -525,23 +555,54 @@ end
       end
     end
 
-    should_respond_to(:eql?)
+    [ :eql?, :== ].each do |method|
+      should_respond_to(method)
 
-    describe '#eql?', state do
-      describe 'with an Enumerable containing the same entries' do
-        action { subject.eql?([ @nancy, @bessie ]) }
+      describe "##{method}", state do
+        describe 'with an Enumerable containing the same entries' do
+          before do
+            if method == :eql?
+              @other = LazyArray.new
+              @other.load_with { |la| la.push(@nancy, @bessie) }
+            else
+              @other = [ @nancy, @bessie ]
+            end
+          end
 
-        should_return_true
-        should_be_a_kicker
-        should_not_change_subject
-      end
+          action { subject.send(method, @other) }
 
-      describe 'with an Enumerable containing different entries' do
-        action { subject.eql?(@other) }
+          should_return_true
+          should_be_a_kicker
+          should_not_change_subject
+        end
 
-        should_return_false
-        should_be_a_kicker
-        should_not_change_subject
+        describe 'with an Enumerable containing different entries' do
+          action { subject.send(method, @other) }
+
+          should_return_false
+          should_be_a_kicker
+          should_not_change_subject
+        end
+
+        describe 'with an Enumerable with different entries than in head' do
+          before { subject.unshift(@nancy) }
+
+          action { subject.send(method, [ @steve ]) }
+
+          should_return_false
+          should_not_be_a_kicker
+          should_not_change_subject
+        end
+
+        describe 'with an Enumerable with different entries than in tail' do
+          before { subject.push(@nancy) }
+
+          action { subject.send(method, [ @steve ]) }
+
+          should_return_false
+          should_not_be_a_kicker
+          should_not_change_subject
+        end
       end
     end
 
@@ -1008,7 +1069,7 @@ end
       should_not_change_subject
 
       it 'should return a reversed LazyArray' do
-        action.should eql([ @bessie, @nancy ])
+        action.should == [ @bessie, @nancy ]
       end
     end
 
@@ -1021,7 +1082,7 @@ end
       should_not_be_a_kicker
 
       it 'should return a reversed LazyArray' do
-        action.should eql([ @bessie, @nancy ])
+        action.should == [ @bessie, @nancy ]
       end
     end
 
@@ -1727,8 +1788,11 @@ end
       action { subject.to_a }
 
       should_return_kind_of(Array)
-      should_return_copy
       should_be_a_kicker
+
+      it 'should be equivalent to self' do
+        action.should == subject
+      end
     end
 
     should_respond_to(:unshift)

data/spec/module_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 describe Module do
 
   before(:all) do
-    module Foo
+    module ::Foo
       module ModBar
         module Noo
           module Too
@@ -15,10 +15,10 @@ describe Module do
       end
     end
 
-    class Baz
+    class ::Baz
     end
 
-    class Bar
+    class ::Bar
     end
   end
 
@@ -51,7 +51,7 @@ describe Module do
   it "should be able to deal with constants being added and removed" do
     Object.find_const('Bar') # First we load Bar with find_const
     Object.module_eval { remove_const('Bar') } # Now we delete it
-    module Bar; end; # Now we redefine it
+    module ::Bar; end; # Now we redefine it
     Object.find_const('Bar').should == Bar
   end
 

data/spec/pooling_spec.rb

@@ -146,7 +146,7 @@ describe "Extlib::Pooling" do
   end
 
   it "should wake up the scavenger thread when exiting" do
-    pending 'Fix for Ruby 1.9.1 and JRuby' if RUBY_VERSION >= '1.9.1' || RUBY_PLATFORM =~ /java/
+    pending 'Fix for JRuby' if RUBY_PLATFORM =~ /java/
     bob = Person.new('Bob')
     bob.release
     Extlib.exiting = true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: extlib
 version: !ruby/object:Gem::Version 
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors: 
 - Sam Smoot
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-07 00:00:00 -08:00
+date: 2009-01-19 00:00:00 -08:00
 default_executable: 
 dependencies: []