ruby-nuggets 0.6.5 → 0.6.6

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--require spec/spec_helper.rb

data/README

@@ -2,7 +2,7 @@
 
 == VERSION
 
-This documentation refers to ruby-nuggets version 0.6.5
+This documentation refers to ruby-nuggets version 0.6.6
 
 
 == DESCRIPTION

data/Rakefile

@@ -13,7 +13,7 @@ begin
       :version     => Nuggets::VERSION,
       :summary     => 'Some extensions to the Ruby programming language.',
       :files       => FileList['lib/**/*.rb'].to_a,
-      :extra_files => FileList['[A-Z]*'].to_a
+      :extra_files => FileList['[A-Z]*', '.rspec', 'spec/**/*.rb'].to_a
     }
   }}
 rescue LoadError => err

data/lib/nuggets/file/which_mixin.rb

@@ -25,24 +25,36 @@
 ###############################################################################
 #++
 
+require 'rbconfig'
+
 module Nuggets
   class File
     module WhichMixin
 
+  DEFAULT_EXTENSIONS = [Config::CONFIG['EXEEXT']]
+
   # call-seq:
-  #   File.which(executable) => aString or nil
+  #   File.which(executable, extensions = DEFAULT_EXTENSIONS) => aString or nil
+  #
+  # Returns +executable+ if it's executable, or the full path to +executable+
+  # found in PATH, or +nil+ otherwise. Checks +executable+ with each extension
+  # in +extensions+ appended in turn.
   #
-  # Returns the full path to +executable+, or +nil+ if not found in PATH.
   # Inspired by Gnuplot.which -- thx, Gordon!
-  def which(executable)
-    return executable if executable?(executable)
-
-    if path = ENV['PATH']
-      path.split(::File::PATH_SEPARATOR).each { |dir|
-        candidate = join(expand_path(dir), executable)
-        return candidate if executable?(candidate)
-      }
-    end
+  def which(executable, extensions = DEFAULT_EXTENSIONS)
+    extensions |= ['']
+
+    extensions.each { |extension|
+      executable += extension
+      return executable if executable?(executable)
+
+      if path = ENV['PATH']
+        path.split(::File::PATH_SEPARATOR).each { |dir|
+          candidate = join(expand_path(dir), executable)
+          return candidate if executable?(candidate)
+        }
+      end
+    }
 
     nil
   end
@@ -50,9 +62,9 @@ module Nuggets
   # call-seq:
   #   File.which_command(commands) => aString or nil
   #
-  # Returns the first of +commands+ that is executable.
-  def which_command(commands)
-    commands.find { |command| which(command[/\S+/]) }
+  # Returns the first of +commands+ that is executable (according to #which).
+  def which_command(commands, extensions = DEFAULT_EXTENSIONS)
+    commands.find { |command| which(command[/\S+/], extensions) }
   end
 
     end

data/lib/nuggets/version.rb

@@ -4,7 +4,7 @@ module Nuggets
 
     MAJOR = 0
     MINOR = 6
-    TINY  = 5
+    TINY  = 6
 
     class << self
 

data/spec/nuggets/array/limit_spec.rb

@@ -0,0 +1,36 @@
+require 'nuggets/array/limit'
+require 'nuggets/numeric/limit'
+
+describe Array, 'when extended by', Nuggets::Array::LimitMixin do
+
+  it { Array.ancestors.should include(Nuggets::Array::LimitMixin) }
+
+  example do
+    [].limit(0, 1).should == []
+  end
+
+  example do
+    [1].limit(0, 1).should == [1]
+  end
+
+  example do
+    [1, 1, 1].limit(0, 1).should == [1]
+  end
+
+  example do
+    [1, 2, 3].limit(0, 1).should == [1]
+  end
+
+  example do
+    [1, 2, 3].limit(0, 2).should == [1, 2]
+  end
+
+  example do
+    [-3, -2, -1].limit(0, 1).should == [0]
+  end
+
+  example do
+    [1, -2, 1, 2, 3, -4, 0, 3, 1, 2, 1, 0, 24].limit(-2, 2).should == [1, -2, 2, 0]
+  end
+
+end

data/spec/nuggets/array/runiq_spec.rb

@@ -0,0 +1,27 @@
+require 'nuggets/array/runiq'
+
+describe Array, 'when extended by', Nuggets::Array::RuniqMixin do
+
+  it { Array.ancestors.should include(Nuggets::Array::RuniqMixin) }
+
+  example do
+    [1, 2, 3, 4, 3, 2].runiq.should == [1, 4, 3, 2]
+  end
+
+  example do
+    ary = [1, 2, 3, 4, 3, 2]
+    ary.runiq!.should_not be_nil
+    ary.should == [1, 4, 3, 2]
+  end
+
+  example do
+    [1, 2, 3, 4].runiq.should == [1, 2, 3, 4]
+  end
+
+  example do
+    ary = [1, 2, 3, 4]
+    ary.runiq!.should be_nil
+    ary.should == [1, 2, 3, 4]
+  end
+
+end

data/spec/nuggets/array/standard_deviation_spec.rb

@@ -0,0 +1,35 @@
+require 'nuggets/array/standard_deviation'
+
+describe Array, 'when extended by', Nuggets::Array::StandardDeviationMixin do
+
+  it { Array.ancestors.should include(Nuggets::Array::StandardDeviationMixin) }
+
+  example do
+    [].standard_deviation.should == 0.0
+  end
+
+  example do
+    [1].standard_deviation.should == 0.0
+  end
+
+  example do
+    [1, 1, 1].standard_deviation.should == 0.0
+  end
+
+  example do
+    [1, 2, 3].standard_deviation.should be_within(0.0001).of(0.8165)
+  end
+
+  example do
+    [3, 2, 1].standard_deviation.should be_within(0.0001).of(0.8165)
+  end
+
+  example do
+    [-3, -2, -1].standard_deviation.should == [3, 2, 1].standard_deviation
+  end
+
+  example do
+    [1, -2, 1, 2, 3, -4, 0, 3, 1, 2, 1, 0, 24].standard_deviation.should be_within(0.01).of(6.49)
+  end
+
+end

data/spec/nuggets/array/variance_spec.rb

@@ -0,0 +1,35 @@
+require 'nuggets/array/variance'
+
+describe Array, 'when extended by', Nuggets::Array::VarianceMixin do
+
+  it { Array.ancestors.should include(Nuggets::Array::VarianceMixin) }
+
+  example do
+    [].variance.should == 0.0
+  end
+
+  example do
+    [1].variance.should == 0.0
+  end
+
+  example do
+    [1, 1, 1].variance.should == 0.0
+  end
+
+  example do
+    [1, 2, 3].variance.should == 2 / 3.0
+  end
+
+  example do
+    [3, 2, 1].variance.should == 2 / 3.0
+  end
+
+  example do
+    [-3, -2, -1].variance.should == [3, 2, 1].variance
+  end
+
+  example do
+    [1, -2, 1, 2, 3, -4, 0, 3, 1, 2, 1, 0, 24].variance.should be_within(0.1).of(42.0)
+  end
+
+end

data/spec/nuggets/env/set_spec.rb

@@ -0,0 +1,31 @@
+require 'nuggets/env/set'
+
+describe ENV, 'when extended by', Nuggets::Env::SetMixin do
+
+  it { class << ENV; ancestors; end.should include(Nuggets::Env::SetMixin) }
+
+  before do
+    @original = ENV.to_hash
+  end
+
+  after do
+    ENV.clear
+    ENV.update(@original)
+  end
+
+  example do
+    ENV.with(:lang => 'C') { ENV['LANG'].should == 'C' }
+    ENV['LANG'].should == @original['LANG']
+  end
+
+  example do
+    ENV.set(:lang => 'C').to_hash.should == @original
+    ENV.to_hash.should == { 'LANG' => 'C' }
+  end
+
+  example do
+    ENV.set(@original)
+    ENV.to_hash.should == @original
+  end
+
+end

data/spec/nuggets/env/user_encoding_spec.rb

@@ -0,0 +1,40 @@
+require 'nuggets/env/user_encoding'
+
+describe ENV, 'when extended by', Nuggets::Env::UserEncodingMixin do
+
+  it { class << ENV; ancestors; end.should include(Nuggets::Env::UserEncodingMixin) }
+
+  before do
+    @old_env = ENV.to_hash
+  end
+
+  after do
+    ENV.clear
+    ENV.update(@old_env)
+  end
+
+  example do
+    ENV.user_encoding.should be_an_instance_of(String)
+  end
+
+  example do
+    ENV.clear
+    ENV.user_encoding.should be_an_instance_of(String)
+  end
+
+  example do
+    ENV['ENCODING'] = 'foo'
+    ENV.user_encoding.should == 'foo'
+  end
+
+  example do
+    ENV.clear
+    ENV.user_encoding('bar').should == 'bar'
+  end
+
+  example do
+    ENV.clear
+    ENV.user_encoding(nil).should be_nil
+  end
+
+end

data/spec/nuggets/env/user_home_spec.rb

@@ -0,0 +1,40 @@
+require 'nuggets/env/user_home'
+
+describe ENV, 'when extended by', Nuggets::Env::UserHomeMixin do
+
+  it { class << ENV; ancestors; end.should include(Nuggets::Env::UserHomeMixin) }
+
+  before do
+    @old_env = ENV.to_hash
+  end
+
+  after do
+    ENV.clear
+    ENV.update(@old_env)
+  end
+
+  example do
+    ENV.user_home.should be_an_instance_of(String)
+  end
+
+  example do
+    ENV.clear
+    ENV.user_home.should be_an_instance_of(String)
+  end
+
+  example do
+    ENV['HOME'] = 'foo'
+    ENV.user_home.should == 'foo'
+  end
+
+  example do
+    ENV.clear
+    ENV.user_home('bar').should == 'bar'
+  end
+
+  example do
+    ENV.clear
+    ENV.user_home(nil).should be_nil
+  end
+
+end

data/spec/nuggets/file/which_spec.rb

@@ -0,0 +1,24 @@
+require 'nuggets/file/which'
+
+describe File, 'when extended by', Nuggets::File::WhichMixin do
+
+  it { (class << File; ancestors; end).should include(Nuggets::File::WhichMixin) }
+
+  %w[cat dog rat gcc /usr/bin/X11/gcc].each { |c|
+    example do
+      r = %x{which #{c}}.chomp
+      File.which(c).should == (r.empty? ? nil : r)
+    end
+  }
+
+  example do
+    c = [
+      'unison --args source target',
+      'rsync --args source target',
+      'scp --args source target'
+    ]
+    r = c.find { |s| !%x{which #{s[/\S+/]}}.chomp.empty? }
+    File.which_command(c).should == r
+  end
+
+end

data/spec/nuggets/hash/nest_spec.rb

@@ -0,0 +1,104 @@
+require 'nuggets/hash/nest'
+
+describe Hash, 'when extended by', Nuggets::Hash::NestMixin do
+
+  it { (class << Hash; self; end).ancestors.should include(Nuggets::Hash::NestMixin) }
+
+  example do
+    hash = Hash.nest
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should be_nil
+    hash.should have_key(:a)
+  end
+
+  example do
+    hash = Hash.nest(0, 1)
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should == 1
+    hash.should have_key(:a)
+  end
+
+  example do
+    hash = Hash.nest(1)
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should be_an_instance_of(Hash)
+    hash.should have_key(:a)
+
+    hash[:a][:b].should be_nil
+    hash[:a].should have_key(:b)
+  end
+
+  example do
+    hash = Hash.nest(1, 1)
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should be_an_instance_of(Hash)
+    hash.should have_key(:a)
+
+    hash[:a][:b].should == 1
+    hash[:a].should have_key(:b)
+  end
+
+  example do
+    hash = Hash.nest(1, [])
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should be_an_instance_of(Hash)
+    hash.should have_key(:a)
+
+    hash[:a][:b].should == []
+    hash[:a].should have_key(:b)
+
+    hash[:a][:b] << 1
+    hash[:a][:b].should == [1]
+
+    hash[:a][:c] << 2
+    hash[:a][:c].should == [1, 2]
+
+    hash[:a][:b].should == [1, 2]
+  end
+
+  example do
+    hash = Hash.nest(1) { [] }
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should be_an_instance_of(Hash)
+    hash.should have_key(:a)
+
+    hash[:a][:b].should == []
+    hash[:a].should have_key(:b)
+
+    hash[:a][:b] << 1
+    hash[:a][:b].should == [1]
+
+    hash[:a][:c] << 2
+    hash[:a][:c].should == [2]
+
+    hash[:a][:b].should == [1]
+  end
+
+  example do
+    hash = Hash.nest(3)
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should be_an_instance_of(Hash)
+    hash.should have_key(:a)
+
+    hash[:a][:b].should be_an_instance_of(Hash)
+    hash[:a].should have_key(:b)
+
+    hash[:a][:b][:c].should be_an_instance_of(Hash)
+    hash[:a][:b].should have_key(:c)
+
+    hash[:a][:b][:c][:d].should be_nil
+    hash[:a][:b][:c].should have_key(:d)
+
+    hash[:a][:b][:c][:e] = 1
+    hash[:a][:b][:c][:e].should == 1
+    hash[:a][:b][:c].should have_key(:e)
+  end
+
+end

data/spec/nuggets/hash/unroll_spec.rb

@@ -0,0 +1,70 @@
+require 'nuggets/hash/unroll'
+
+describe Hash, 'when extended by', Nuggets::Hash::UnrollMixin do
+
+  it { Hash.ancestors.should include(Nuggets::Hash::UnrollMixin) }
+
+  example do
+    hash = {}
+    hash.unroll.should == [[]]
+  end
+
+  example do
+    hash = { 'a' => 1 }
+    hash.unroll.should == [[1]]
+  end
+
+  example do
+    hash = { 'a' => { 'b' => 1 } }
+    hash.unroll.should == [['a', 1]]
+  end
+
+  example do
+    hash = { :a => { :b => 1 } }
+    hash.unroll.should == [[:a, 1]]
+  end
+
+  example do
+    hash = { :a => { :b => 1, :c => 2 } }
+
+    result = hash.unroll.first
+    result.should have(3).items
+
+    result.first.should == :a
+    result.should include(1)
+    result.should include(2)
+  end
+
+if RUBY_VERSION < '1.9'
+  example do
+    hash = { :a => { :b => 1, :c => 2 } }
+    lambda { hash.unroll(:sort => true) }.should raise_error(NoMethodError, /<=>/)
+  end
+
+  example do
+    hash = { :a => { :b => 1, :c => 2 } }
+    lambda { hash.unroll(:sort_by => lambda { |h| h.to_s }) }.should_not raise_error(NoMethodError)
+  end
+end
+
+  example do
+    hash = { 'a' => { 'b' => 1, 'c' => 2 } }
+    hash.unroll(:sort => true).should == [['a', 1, 2]]
+  end
+
+  example do
+    hash = { 'a' => { 'b' => 1, 'c' => 2 }, 'd' => { 'b' => 0, 'c' => 3 } }
+    hash.unroll('b', 'c', :sort => true).should == [['a', 1, 2], ['d', 0, 3]]
+  end
+
+  example do
+    hash = { 'z' => { 'a' => { 'b' => 1, 'c' => 2 }, 'd' => { 'b' => 0, 'c' => 3 } } }
+    hash.unroll('b', :sort_by => lambda { |h| h.to_s }).should == [['z', 'a', 1], ['z', 'd', 0]]
+  end
+
+  example do
+    hash = { 'z' => { 'a' => { 'b' => 1, 'c' => 2 }, 'd' => { 'b' => 0, 'c' => 3 } } }
+    hash.unroll(:sort => true) { |h| h['b'] = nil; h['c'] *= 2 }.should == [['z', 'a', nil, 4], ['z', 'd', nil, 6]]
+  end
+
+end

data/spec/nuggets/integer/length_spec.rb

@@ -0,0 +1,20 @@
+require 'nuggets/integer/length'
+
+describe Integer, 'when extended by', Nuggets::Integer::LengthMixin do
+
+  it { Integer.ancestors.should include(Nuggets::Integer::LengthMixin) }
+
+  {
+    0           => [1, 1],
+    123         => [3, 3],
+    -123        => [4, 3],
+    1_000_000   => [7, 7],
+    -1_000_000  => [8, 7],
+    10 ** 48    => [49, 49],
+    -(10 ** 48) => [50, 49]
+  }.each { |int, (len, cnt)|
+    example { int.length.should == len }
+    example { int.digit_count.should == cnt }
+  }
+
+end

data/spec/nuggets/integer/map_spec.rb

@@ -0,0 +1,21 @@
+require 'nuggets/integer/map'
+
+describe Integer, 'when extended by', Nuggets::Integer::MapMixin do
+
+  it { Integer.ancestors.should include(Nuggets::Integer::MapMixin) }
+
+  {
+    0           => 1,
+    1           => 2,
+    -1          => 3,
+    123         => 246,
+    -123        => 247,
+    1_000_000   => 2_000_000,
+    -1_000_000  => 2_000_001,
+    10 ** 48    => 2_000_000_000_000_000_000_000_000_000_000_000_000_000_000_000_000,
+    -(10 ** 48) => 2_000_000_000_000_000_000_000_000_000_000_000_000_000_000_000_001
+  }.each { |int, map|
+    example { int.map_positive.should == map }
+  }
+
+end

data/spec/nuggets/object/blank_spec.rb

@@ -0,0 +1,35 @@
+require 'nuggets/object/blank'
+
+describe Object, 'when extended by', Nuggets::Object::BlankMixin do
+
+  it { Object.ancestors.should include(Nuggets::Object::BlankMixin) }
+  it { Array.ancestors.should include(Nuggets::Array::BlankMixin) }
+  it { Hash.ancestors.should include(Nuggets::Hash::BlankMixin) }
+
+  ['s', ' ', 0, 1, true, [nil]].each { |o|
+    example { o.should_not be_blank }
+  }
+
+  ['', nil, false, [], {}].each { |o|
+    example { o.should be_blank }
+  }
+
+  ['s', 1, true].each { |o|
+    example { o.should_not be_void }
+    example { o.should_not be_vain }
+  }
+
+  ['', ' ', 0, nil, false, [], [nil], {}].each { |o|
+    example { o.should be_void }
+    example { o.should be_vain }
+  }
+
+  [['', [], [nil], {}], { :x => nil, :y => [], :z => { :zz => nil } }].each { |o|
+    example { o.should_not be_void }
+  }
+
+  [['', [], [nil], {}], { :x => nil, :y => [], :z => { :zz => nil } }].each { |o|
+    example { o.should be_vain }
+  }
+
+end

data/spec/nuggets/object/boolean_spec.rb

@@ -0,0 +1,25 @@
+require 'nuggets/object/boolean'
+
+describe Object, 'when extended by', Nuggets::Object::BooleanMixin do
+
+  it { Object.ancestors.should include(Nuggets::Object::BooleanMixin) }
+
+  [0, 1, -1, nil, '', 'abc', Class, Object.new].each { |o|
+    example { o.should_not be_boolean }
+  }
+
+  [true, false].each { |o|
+    example { o.should be_boolean }
+  }
+
+  [0, 1, -1, '', 'abc', Class, Object.new, true].each { |o|
+    example { o.negate.should == false }
+    example { o.to_bool.should == true }
+  }
+
+  [nil, false].each { |o|
+    example { o.negate.should == true }
+    example { o.to_bool.should == false }
+  }
+
+end

data/spec/nuggets/object/msend_spec.rb

@@ -0,0 +1,27 @@
+require 'nuggets/object/msend'
+
+describe Object, 'when extended by', Nuggets::Object::MSendMixin do
+
+  it { Object.ancestors.should include(Nuggets::Object::MSendMixin) }
+
+  example do
+    o = 'foo bar'
+    o.msend(:length, :reverse).should == [o.length, o.reverse]
+  end
+
+  example do
+    o = 42
+    o.msend(:to_s, :* => 2).should == [o.to_s, o * 2]
+  end
+
+  example do
+    o = 42
+    o.msend([:to_s, 2], '-@').should == [o.to_s(2), -o]
+  end
+
+  example do
+    o = Time.now
+    o.msend(:year, :month, :day).should == [o.year, o.month, o.day]
+  end
+
+end

data/spec/nuggets/object/silence_spec.rb

@@ -0,0 +1,33 @@
+require 'nuggets/object/silence'
+
+describe Object, 'when extended by', Nuggets::Object::SilenceMixin do
+
+  it { Object.ancestors.should include(Nuggets::Object::SilenceMixin) }
+
+  before do
+    @stderr, @old_stderr = '', $stderr
+    $stderr = StringIO.new(@stderr)
+
+    AConst = :foo
+  end
+
+  after do
+    $stderr = @old_stderr
+    Object.send(:remove_const, :AConst) if Object.const_defined?(:AConst)
+  end
+
+  example do
+    AConst = :bar
+
+    AConst.should be_equal(:bar)
+    @stderr.should =~ /warning: already initialized constant AConst/
+  end
+
+  example do
+    silence { AConst = :baz }
+
+    AConst.should be_equal(:baz)
+    @stderr.should == ''
+  end
+
+end

data/spec/nuggets/object/singleton_class_spec.rb

@@ -0,0 +1,44 @@
+require 'nuggets/object/singleton_class'
+
+describe Object, 'when extended by', Nuggets::Object::SingletonClassMixin do
+
+  it { Object.ancestors.should include(Nuggets::Object::SingletonClassMixin) }
+
+  [Object, Class, Object.new, Class.new, 's', [1, 2], { :a => 'b' }].each { |o|
+    example { o.should_not be_a_singleton_class }
+    example { lambda { o.singleton_object }.should raise_error(TypeError) }
+
+    s = o.singleton_class
+
+    example { s.should be_a_singleton_class }
+    example { s.singleton_object.should be_equal(o) }
+  }
+
+  example do
+    c = Class.new
+    c.should_not be_a_singleton_class
+    o = c.new
+    c.should_not be_a_singleton_class
+  end
+
+  example do
+    nil.singleton_class.should == NilClass
+    NilClass.should be_a_singleton_class
+    NilClass.singleton_object.should be_equal(nil)
+  end
+
+  example do
+    class A; end
+    class B < A; end
+
+    a = A.singleton_class
+    b = B.singleton_class
+
+    a.should be_a_singleton_class
+    b.should be_a_singleton_class
+
+    a.singleton_object.should be_equal(A)
+    b.singleton_object.should be_equal(B)
+  end
+
+end

data/spec/nuggets/proc/bind_spec.rb

@@ -0,0 +1,30 @@
+require 'nuggets/proc/bind'
+
+describe Proc, 'when extended by', Nuggets::Proc::BindMixin do
+
+  it { Proc.ancestors.should include(Nuggets::Proc::BindMixin) }
+
+  before :each do
+    @l = lambda { bla }
+  end
+
+  example do
+    lambda { @l.call }.should raise_error(NameError)
+  end
+
+  example do
+    module Foo; def self.bla; 'bar'; end; end
+    @l.bind(Foo).call.should == 'bar'
+  end
+
+  example do
+    class Bar; def self.bla; 'baz'; end; end
+    @l.bind(Bar).call.should == 'baz'
+  end
+
+  example do
+    class Baz; def bla; 'foo'; end; end
+    @l.bind(Baz.new).call.should == 'foo'
+  end
+
+end

data/spec/nuggets/range/quantile_spec.rb

@@ -0,0 +1,35 @@
+require 'nuggets/range/quantile'
+
+describe Range, 'when extended by', Nuggets::Range::QuantileMixin do
+
+  it { Range.ancestors.should include(Nuggets::Range::QuantileMixin) }
+
+  example do
+    (1..5).quantile(0, 3).should == 1
+  end
+
+  example do
+    (1..5).quantile(1, 3).should == 1
+  end
+
+  example do
+    (1..5).quantile(2, 3).should == 1
+  end
+
+  example do
+    (1..5).quantile(3, 3).should == 2
+  end
+
+  example do
+    (1..5).quantile(4, 3).should == 3
+  end
+
+  example do
+    (1..5).quantile(5, 3).should == 3
+  end
+
+  example do
+    (1..5).quantile(6, 3).should == 3
+  end
+
+end

data/spec/nuggets/string/evaluate_spec.rb

@@ -0,0 +1,26 @@
+require 'nuggets/string/evaluate'
+
+describe String, 'when extended by', Nuggets::String::EvaluateMixin do
+
+  it { String.ancestors.should include(Nuggets::String::EvaluateMixin) }
+
+  describe do
+
+    %w[bl#{a}blub bl#{a}#{b}lub].each { |str|
+      { 'blablub' => %w[a b], 'blubblub' => %w[ub b] }.each { |res, (a, b)|
+        example { str.evaluate(binding).should == res }
+      }
+
+      example {
+        lambda { str.evaluate(binding) }.should raise_error(NameError, /`a'/)
+      }
+    }
+
+  end
+
+  [ 'a"b"c', 'a\"b\"c', 'a\\"b\\"c', 'a\\\"b\\\"c',
+    "a'b'c", 'a%q{b}c', 'a{b}c', 'a{bc', 'ab}c' ].each { |str|
+    example { str.evaluate(binding).should == str }
+  }
+
+end

data/spec/nuggets/string/wc_spec.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'nuggets/string/wc'
+
+describe String, 'when extended by', Nuggets::String::WcMixin do
+
+  it { String.ancestors.should include(Nuggets::String::WcMixin) }
+
+  describe 'empty' do
+
+    before do
+      @str = ''
+    end
+
+    example { @str.wc.should == [0, 0, 0] }
+
+    example { @str.line_count.should == 0 }
+
+    example { @str.word_count.should == 0 }
+
+    example { @str.byte_count.should == 0 }
+
+    example { @str.char_count.should == 0 }
+
+  end
+
+  describe 'non-empty' do
+
+    before do
+      @str = <<-STR
+The fox went out on a chilly night / Prayed for the moon to give him light / For he had many a mile to go that night / Before he reached the town o
+He ran til he came to a great big bin / Where the ducks and the geese were kept therein / Said, a couple of you are going to grease my chin / Before I leave this town o
+He grabbed the grey goose by the neck / Throwed a duck across his back / He didn't mind the quack, quack, quack / And the legs all dangling down o
+Then old mother Flipper-flopper jumped out of bed / Out of the window she cocked her head / Crying, John, John the grey goose is gone / and the fox is on the town o
+Then John he went to the top of the hill / Blew his horn both loud and shrill / The fox, he said, I better flee with my kill / Or they'll soon be on my trail o
+He ran till he came to his cozy den / There were the little ones, eight, nine, ten / Saying, Daddy, daddy, Better go back again / For it must be a mighty fine town o
+Then the fox and his wife, without any strife / Cut up the goose with a carving knife / They never had such a supper in their life / And the little ones chewed on the bones o
+      STR
+    end
+
+    example { @str.wc.should == [7, 252, 1130] }
+
+    example { @str.line_count.should == 7 }
+
+    example { @str.word_count.should == 252 }
+
+    example { @str.byte_count.should == 1130 }
+
+    example { @str.char_count.should == 1130 }
+
+  end
+
+  describe 'special' do
+
+    before do
+      @str = <<-STR
+TECHNICIÄNS ÖF SPÅCE SHIP EÅRTH
+THIS IS YÖÜR CÄPTÅIN SPEÄKING
+YÖÜR ØÅPTÅIN IS DEA̋D
+      STR
+    end
+
+    example { @str.wc.should == [3, 14, 99] }
+
+    example { @str.line_count.should == 3 }
+
+    example { @str.word_count.should == 14 }
+
+    example { @str.byte_count.should == 99 }
+
+    example { @str.char_count.should == 84 }
+
+  end
+
+end

data/spec/nuggets/string/xor_spec.rb

@@ -0,0 +1,59 @@
+require 'nuggets/string/xor'
+
+describe String, 'when extended by', Nuggets::String::XorMixin do
+
+  it { String.ancestors.should include(Nuggets::String::XorMixin) }
+
+  describe 'same length' do
+
+    before do
+      @str1 = 'foobar'
+      @str2 = 'secret'
+
+      @res = "\025\n\f\020\004\006"
+    end
+
+    example { @str1.xor(@str2).should == @res }
+
+    example { @str2.xor(@str1).should == @res }
+
+    example { (@str1 ^ @str2).should == @res }
+
+    example { (@str2 ^ @str1).should == @res }
+
+  end
+
+  describe 'different length' do
+
+    before do
+      @str1 = 'baz'
+      @str2 = 'secret'
+      @str3 = 'foobarbaz'
+
+      @res1 = "sec\020\004\016"
+      @res2 = "foo\021\004\021\020\004\016"
+    end
+
+    example { @str1.xor(@str2).should == @res1 }
+
+    example { @str2.xor(@str1).should == @res1 }
+
+    example { (@str1 ^ @str2).should == @res1 }
+
+    example { (@str2 ^ @str1).should == @res1 }
+
+    example { lambda { @str1.xor(@str2, true) }.should raise_error(ArgumentError, 'must be of same length') }
+
+    example { @str2.xor(@str3).should == @res2 }
+
+    example { @str3.xor(@str2).should == @res2 }
+
+    example { (@str2 ^ @str3).should == @res2 }
+
+    example { (@str3 ^ @str2).should == @res2 }
+
+    example { lambda { @str2.xor(@str3, true) }.should raise_error(ArgumentError, 'must be of same length') }
+
+  end
+
+end

data/spec/nuggets/uri/content_type_spec.rb

@@ -0,0 +1,32 @@
+require 'nuggets/uri/content_type'
+
+describe URI, 'when extended by', Nuggets::URI::ContentTypeMixin do
+
+  it { (class << URI; ancestors; end).should include(Nuggets::URI::ContentTypeMixin) }
+
+  %w[
+    http://www.google.de
+    http://blackwinter.de/misc/
+  ].each { |u|
+    example { URI.content_type(u).should == 'text/html' }
+  }
+
+  %w[
+    htp://www.google.de
+    www.google.de
+    http://blackwinter.de/bla
+    http://blawinter.de
+  ].each { |u|
+    example { URI.content_type(u).should == nil }
+  }
+
+  {
+    'http://blackwinter.de/misc/ww.png'                  => 'image/png',
+    'http://blackwinter.de/misc/suicide_is_painless.mid' => 'audio/midi',
+    'http://blackwinter.de/misc/expand_macros.pl.gz'     => 'application/x-gzip',
+    'http://blackwinter.de/misc/blanc60302523.nth'       => 'application/vnd.nok-s40theme'
+  }.each { |u, t|
+    example { URI.content_type(u).should == t }
+  }
+
+end

data/spec/nuggets/uri/exist_spec.rb

@@ -0,0 +1,25 @@
+require 'nuggets/uri/exist'
+
+describe URI, 'when extended by', Nuggets::URI::ExistMixin do
+
+  it { (class << URI; ancestors; end).should include(Nuggets::URI::ExistMixin) }
+
+  %w[
+    http://www.google.de
+    http://blackwinter.de
+    http://blackwinter.de/index.html
+  ].each { |u|
+    example { URI.exist?(u).should be_true }
+  }
+
+  %w[
+    htp://www.google.de
+    www.google.de
+    http://xuugle.de
+    http://blackwinter.de/bla
+    http://blackwinter.de/index.htm
+  ].each { |u|
+    example { URI.exist?(u).should be_false }
+  }
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$:.unshift('lib') unless $:[0] == 'lib'
+
+#class << Spec::Matchers
+#
+#  def generated_description
+#    return nil if last_should.nil?
+#
+#    operator = last_should.to_s.tr('_', ' ')
+#    target = last_matcher.instance_variable_get(:@actual)
+#
+#    "#{target.inspect} #{operator} #{last_description}"
+#  end
+#
+#end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-nuggets
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 6
-  - 5
-  version: 0.6.5
+  - 6
+  version: 0.6.6
 platform: ruby
 authors: 
 - Jens Wille
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-06 00:00:00 +01:00
+date: 2011-01-07 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -129,21 +129,47 @@ files:
 - ChangeLog
 - Rakefile
 - COPYING
+- .rspec
+- spec/nuggets/integer/map_spec.rb
+- spec/nuggets/integer/length_spec.rb
+- spec/nuggets/array/variance_spec.rb
+- spec/nuggets/array/runiq_spec.rb
+- spec/nuggets/array/limit_spec.rb
+- spec/nuggets/array/standard_deviation_spec.rb
+- spec/nuggets/proc/bind_spec.rb
+- spec/nuggets/hash/unroll_spec.rb
+- spec/nuggets/hash/nest_spec.rb
+- spec/nuggets/file/which_spec.rb
+- spec/nuggets/string/evaluate_spec.rb
+- spec/nuggets/string/xor_spec.rb
+- spec/nuggets/string/wc_spec.rb
+- spec/nuggets/env/user_encoding_spec.rb
+- spec/nuggets/env/user_home_spec.rb
+- spec/nuggets/env/set_spec.rb
+- spec/nuggets/uri/content_type_spec.rb
+- spec/nuggets/uri/exist_spec.rb
+- spec/nuggets/range/quantile_spec.rb
+- spec/nuggets/object/singleton_class_spec.rb
+- spec/nuggets/object/boolean_spec.rb
+- spec/nuggets/object/msend_spec.rb
+- spec/nuggets/object/silence_spec.rb
+- spec/nuggets/object/blank_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://prometheus.rubyforge.org/ruby-nuggets
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --inline-source
-- --all
-- --charset
-- UTF-8
-- --main
-- README
 - --title
 - ruby-nuggets Application documentation
 - --line-numbers
+- --main
+- README
+- --inline-source
+- --charset
+- UTF-8
+- --all
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -167,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: prometheus
-rubygems_version: 1.4.1
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: Some extensions to the Ruby programming language.