ruby-nuggets 0.9.8.1 → 0.9.9

data/spec/nuggets/hash/deep_fetch_spec.rb

@@ -0,0 +1,159 @@
+require 'nuggets/hash/deep_fetch'
+
+describe_extended Hash, Nuggets::Hash::DeepFetchMixin do
+
+  example do
+    lambda { {}.deep_fetch('') }.should raise_error(ArgumentError, 'no keys given')
+  end
+
+  context do
+
+    let(:hash) { { 'foo' => { 'bar' => { 'baz' => 42 }, 'bay' => 23 } } }
+
+    example do
+      hash.deep_fetch('foo/bar/baz').should == 42
+    end
+
+    example do
+      hash.deep_fetch('foo/bar/bax').should == nil
+    end
+
+    example do
+      lambda { hash.deep_fetch('foo/bax/baz') }.should raise_error(KeyError)
+    end
+
+    example do
+      lambda { hash.deep_fetch('foo/bay/baz') }.should raise_error(TypeError)
+    end
+
+    example do
+      hash.deep_fetch('foo:bar:baz').should == nil
+    end
+
+    example do
+      hash.deep_fetch('foo:bar:baz', ':').should == 42
+    end
+
+    example do
+      hash.deep_fetch(%w[foo bar baz]).should == 42
+    end
+
+    example do
+      lambda { hash.deep_fetch([:foo, :bar, :baz]) }.should raise_error(KeyError)
+    end
+
+    example do
+      (hash % 'foo/bar/baz').should == 42
+    end
+
+    example do
+      (hash % %w[foo bar baz]).should == 42
+    end
+
+  end
+
+  context do
+
+    let(:hash) { { :foo => { :bar => { :baz => 42 } } } }
+
+    example do
+      lambda { hash.deep_fetch('foo/bar/baz') }.should raise_error(KeyError)
+    end
+
+    example do
+      hash.deep_fetch('foo/bar/baz', &:to_sym).should == 42
+    end
+
+    example do
+      hash.deep_fetch('foo:bar:baz', &:to_sym).should == nil
+    end
+
+    example do
+      hash.deep_fetch('foo:bar:baz', ':', &:to_sym).should == 42
+    end
+
+    example do
+      lambda { hash.deep_fetch(%w[foo bar baz]) }.should raise_error(KeyError)
+    end
+
+    example do
+      hash.deep_fetch([:foo, :bar, :baz]).should == 42
+    end
+
+    example do
+      lambda { hash % 'foo/bar/baz' }.should raise_error(KeyError)
+    end
+
+    example do
+      (hash % [:foo, :bar, :baz]).should == 42
+    end
+
+  end
+
+  context do
+
+    let(:hash) { { 1 => { 2 => { 3 => 42 } } } }
+
+    example do
+      lambda { hash.deep_fetch('1/2/3') }.should raise_error(KeyError)
+    end
+
+    example do
+      hash.deep_fetch('1/2/3', &:to_i).should == 42
+    end
+
+    example do
+      hash.deep_fetch('1:2:3', &:to_i).should == { 2 => { 3 => 42 } }
+    end
+
+    example do
+      hash.deep_fetch('1:2:3', ':', &:to_i).should == 42
+    end
+
+    example do
+      lambda { hash.deep_fetch(%w[1 2 3]) }.should raise_error(KeyError)
+    end
+
+    example do
+      hash.deep_fetch([1, 2, 3]).should == 42
+    end
+
+    example do
+      lambda { hash % '1/2/3' }.should raise_error(KeyError)
+    end
+
+    example do
+      (hash % [1, 2, 3]).should == 42
+    end
+
+  end
+
+  context do
+
+    let(:hash) { { 'foo' => Hash.new(0) } }
+
+    example do
+      hash.deep_fetch('foo/bar').should == 0
+    end
+
+    example do
+      lambda { hash.deep_fetch('foo/bar/baz') }.should raise_error(KeyError)
+    end
+
+  end
+
+  context do
+
+    let(:hash) { { 'foo' => Hash.new { |h, k| h[k] = [] } } }
+
+    example do
+      hash.deep_fetch('foo/bar').should == []
+    end
+
+    example do
+      lambda { hash.deep_fetch('foo/bar/baz') }.should raise_error(KeyError)
+    end
+
+  end
+
+end

data/spec/nuggets/hash/deep_merge_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/hash/deep_merge'
 
-describe Hash, 'when extended by', Nuggets::Hash::DeepMergeMixin do
-
-  it { Hash.ancestors.should include(Nuggets::Hash::DeepMergeMixin) }
+describe_extended Hash, Nuggets::Hash::DeepMergeMixin do
 
   example do
     { :a => 1 }.deep_merge(:a => 2).should == { :a => 2 }

data/spec/nuggets/hash/in_order_spec.rb

@@ -0,0 +1,12 @@
+require 'nuggets/hash/in_order'
+
+describe Hash, 'in_order' do
+
+  example {
+    h = { a: 1, b: 2, c: 3 }
+
+    h.in_order(:b, :c).should == [[:b, 2], [:c, 3], [:a, 1]]
+    h.in_order(:b, :d).should == [[:b, 2], [:a, 1], [:c, 3]]
+  }
+
+end

data/spec/nuggets/hash/insert_spec.rb

@@ -0,0 +1,13 @@
+require 'nuggets/hash/insert'
+
+describe Hash, 'insert' do
+
+  let(:h) { { a: 0, b: { b1: 1, b2: 2 } } }
+
+  example { h.insert(a: -1).should == { a: -1, b: { b1: 1, b2: 2 } } }
+
+  example { h.insert(b: { b3: 3 }).should == { a: 0, b: { b1: 1, b2: 2, b3: 3 } } }
+
+  example { h.insert!(b: { b0: 0 }); h.should == { a: 0, b: { b1: 1, b2: 2, b0: 0 } } }
+
+end

data/spec/nuggets/hash/nest_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/hash/nest'
 
-describe Hash, 'when extended by', Nuggets::Hash::NestMixin do
-
-  it { (class << Hash; self; end).ancestors.should include(Nuggets::Hash::NestMixin) }
+describe_extended Hash, Nuggets::Hash::NestMixin, true do
 
   example do
     hash = Hash.nest

data/spec/nuggets/hash/only_spec.rb

@@ -0,0 +1,29 @@
+require 'nuggets/hash/only'
+
+describe Hash, 'only' do
+
+  example {
+    h = { a: 5 }
+
+    h.only.should == { a: 5 }
+    h.only_pair.should == [:a, 5]
+    h.only(true).should == { a: 5 }
+  }
+
+  example {
+    h = { 1 => 2, 3 => 4 }
+
+    lambda { h.only }.should raise_error(IndexError, 'not a single-element hash')
+    lambda { h.only_pair }.should raise_error(IndexError, 'not a single-element hash')
+    h.only(true).should == { 1 => 2 }
+  }
+
+  example {
+    h = {}
+
+    lambda { h.only }.should raise_error(IndexError, 'not a single-element hash')
+    lambda { h.only_pair }.should raise_error(IndexError, 'not a single-element hash')
+    h.only(true).should == {}
+  }
+
+end

data/spec/nuggets/hash/seen_spec.rb

@@ -1,18 +1,16 @@
 require 'nuggets/hash/seen'
 
-describe Hash, 'when extended by', Nuggets::Hash::SeenMixin do
-
-  it { (class << Hash; self; end).ancestors.should include(Nuggets::Hash::SeenMixin) }
+describe_extended Hash, Nuggets::Hash::SeenMixin, true do
 
   example do
     hash = Hash.seen
     hash.should be_an_instance_of(Hash)
 
-    hash[:a].should be_false
+    hash[:a].should == false
     hash.should have_key(:a)
 
-    hash[:a].should be_true
-    hash[:a].should be_true
+    hash[:a].should == true
+    hash[:a].should == true
   end
 
   example do

data/spec/nuggets/hash/unroll_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/hash/unroll'
 
-describe Hash, 'when extended by', Nuggets::Hash::UnrollMixin do
-
-  it { Hash.ancestors.should include(Nuggets::Hash::UnrollMixin) }
+describe_extended Hash, Nuggets::Hash::UnrollMixin do
 
   example do
     hash = {}
@@ -28,7 +26,7 @@ describe Hash, 'when extended by', Nuggets::Hash::UnrollMixin do
     hash = { :a => { :b => 1, :c => 2 } }
 
     result = hash.unroll.first
-    result.should have(3).items
+    result.size.should == 3
 
     result.first.should == :a
     result.should include(1)

data/spec/nuggets/i18n_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'nuggets/i18n'
+
+describe String, 'i18n' do
+
+  let(:s) { 'Äh, Rüby iß sö cüül, nö? SÖS!' }
+
+  example { s.replace_diacritics.should == 'Aeh, Rueby iss soe cueuel, noe? SOES!' }
+
+  example { s.replace_diacritics!; s.should == 'Aeh, Rueby iss soe cueuel, noe? SOES!' }
+
+end

data/spec/nuggets/integer/factorial_spec.rb

@@ -0,0 +1,10 @@
+require 'nuggets/integer/factorial'
+
+describe Integer, 'factorial' do
+
+  { 1 => 1, 2 => 2, 3 => 6, 4 => 24, 5 => 120, 6 => 720 }.each { |i, j|
+    example { i.factorial.should == j }
+    example { i.factorial_memoized.should == j }
+  }
+
+end

data/spec/nuggets/integer/length_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/integer/length'
 
-describe Integer, 'when extended by', Nuggets::Integer::LengthMixin do
-
-  it { Integer.ancestors.should include(Nuggets::Integer::LengthMixin) }
+describe_extended Integer, Nuggets::Integer::LengthMixin do
 
   {
     0           => [1, 1],

data/spec/nuggets/integer/map_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/integer/map'
 
-describe Integer, 'when extended by', Nuggets::Integer::MapMixin do
-
-  it { Integer.ancestors.should include(Nuggets::Integer::MapMixin) }
+describe_extended Integer, Nuggets::Integer::MapMixin do
 
   {
     0           => 1,

data/spec/nuggets/integer/to_binary_s_spec.rb

@@ -0,0 +1,19 @@
+require 'nuggets/integer/to_binary_s'
+
+describe Integer, 'to_binary_s' do
+
+  {
+    20000 => %w[00000000000000000100111000100000 100111000100000],
+    800   => %w[00000000000000000000001100100000 1100100000],
+    300   => %w[00000000000000000000000100101100 100101100],
+    700   => %w[00000000000000000000001010111100 1010111100],
+    130   => %w[00000000000000000000000010000010 10000010],
+    480   => %w[00000000000000000000000111100000 111100000],
+    9999  => %w[00000000000000000010011100001111 10011100001111],
+    25000 => %w[00000000000000000110000110101000 110000110101000]
+  }.each { |i, (j, k)|
+    example { i.to_binary_s.should == k }
+    example { i.to_binary_s(32).should == j }
+  }
+
+end

data/spec/nuggets/numeric/duration_spec.rb

@@ -0,0 +1,25 @@
+require 'nuggets/numeric/duration'
+
+describe Numeric, 'duration' do
+
+  {
+    123        => [[[    0,  2,  3],                 '2m3s',        '2m3.00s'],        [[0,  0, 0.0014236111111111112],  '0d',      '0d 2m3s']],
+    123456789  => [[[34293, 33,  9],                 '34293h33m9s', '34293h33m9.00s'], [[3, 11, 3.1480208333333333],     '3y11m3d', '3y11m3d 3h33m9s']],
+    0          => [[[    0,  0,  0],                 '0s',          '0.00s'],          [[0,  0, 0.0],                    '0d',      '0d 0s']],
+    0.001      => [[[    0,  0,  0.001],             '0s',          '0.00s'],          [[0,  0, 1.1574074074074074e-08], '0d',      '0d 0s']],
+    1.23       => [[[    0,  0,  1.23],              '1s',          '1.23s'],          [[0,  0, 1.4236111111111111e-05], '0d',      '0d 1s']],
+    1234.56789 => [[[    0, 20, 34.567890000000034], '20m35s',      '20m34.57s'],      [[0,  0, 0.014288980208333333],   '0d',      '0d 20m35s']]
+  }.each { |n, (h, y)|
+    example { [n.hms, n.to_hms, n.to_hms(2)].should == h }
+    example { [n.ymd, n.to_ymd, n.to_ymd(true)].should == y }
+  }
+
+  example {
+    lambda { -1.hms }.should raise_error(ArgumentError, 'negative duration -1')
+  }
+
+  example {
+    lambda { -1.ymd }.should raise_error(ArgumentError, 'negative duration -1')
+  }
+
+end

data/spec/nuggets/numeric/limit_spec.rb

@@ -0,0 +1,16 @@
+require 'nuggets/numeric/limit'
+
+describe Numeric, 'limit' do
+
+  {
+    123   => 10,
+    -123  =>  0,
+    0     =>  0,
+    0.001 =>  0.001,
+    1.23  =>  1.23,
+    -12.3 => 0
+  }.each { |n, m|
+    example { n.between(0, 10).should == m }
+  }
+
+end

data/spec/nuggets/numeric/signum_spec.rb

@@ -0,0 +1,16 @@
+require 'nuggets/numeric/signum'
+
+describe Numeric, 'signum' do
+
+  {
+    123   =>  1,
+    -123  => -1,
+    0     =>  0,
+    0.001 =>  1,
+    1.23  =>  1,
+    -12.3 => -1
+  }.each { |n, s|
+    example { n.sign.should == s }
+  }
+
+end

data/spec/nuggets/numeric/to_multiple_spec.rb

@@ -0,0 +1,16 @@
+require 'nuggets/numeric/to_multiple'
+
+describe Numeric, 'to_multiple' do
+
+  {
+    123   => [ 120,  120,  130],
+    -123  => [-120, -130, -120],
+    0     => [   0,    0,    0],
+    0.001 => [   0,    0,   10],
+    5.67  => [  10,    0,   10],
+    -12.3 => [ -10,  -20,  -10]
+  }.each { |n, m|
+    example { [n.round_to(10), n.floor_to(10), n.ceil_to(10)].should == m }
+  }
+
+end

data/spec/nuggets/object/blank_spec.rb

@@ -1,8 +1,7 @@
 require 'nuggets/object/blank'
 
-describe Object, 'when extended by', Nuggets::Object::BlankMixin do
+describe_extended Object, 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) }
 

data/spec/nuggets/object/boolean_spec.rb

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

data/spec/nuggets/object/msend_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/object/msend'
 
-describe Object, 'when extended by', Nuggets::Object::MSendMixin do
-
-  it { Object.ancestors.should include(Nuggets::Object::MSendMixin) }
+describe_extended Object, Nuggets::Object::MSendMixin do
 
   example do
     o = 'foo bar'

data/spec/nuggets/object/silence_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/object/silence'
 
-describe Object, 'when extended by', Nuggets::Object::SilenceMixin do
-
-  it { Object.ancestors.should include(Nuggets::Object::SilenceMixin) }
+describe_extended Object, Nuggets::Object::SilenceMixin do
 
   before do
     @stderr, @old_stderr = '', $stderr
@@ -20,7 +18,12 @@ describe Object, 'when extended by', Nuggets::Object::SilenceMixin do
     AConst = :bar
 
     AConst.should be_equal(:bar)
-    @stderr.should =~ /warning: already initialized constant AConst/
+
+    if RUBY_ENGINE == 'rbx'
+      @stderr.should == ''
+    else
+      @stderr.should =~ /warning: already initialized constant AConst/
+    end
   end
 
   example do

data/spec/nuggets/object/singleton_class_spec.rb

@@ -1,10 +1,11 @@
 require 'nuggets/object/singleton_class'
 
-describe Object, 'when extended by', Nuggets::Object::SingletonClassMixin do
+describe_extended Object, Nuggets::Object::SingletonClassMixin do
 
-  it { Object.ancestors.should include(Nuggets::Object::SingletonClassMixin) }
+  objects = [Class, Object.new, Class.new, 's', [1, 2], { :a => 'b' }]
+  objects.unshift(Object) unless RUBY_PLATFORM == 'java' || RUBY_ENGINE == 'rbx'
 
-  [Object, Class, Object.new, Class.new, 's', [1, 2], { :a => 'b' }].each { |o|
+  objects.each { |o|
     example { o.should_not be_a_singleton_class }
     example { lambda { o.singleton_object }.should raise_error(TypeError) }
 
@@ -23,7 +24,13 @@ describe Object, 'when extended by', Nuggets::Object::SingletonClassMixin do
 
   example do
     nil.singleton_class.should == NilClass
-    #NilClass.should be_a_singleton_class
+
+    if RUBY_VERSION < '2'
+      NilClass.should be_a_singleton_class
+    else
+      NilClass.should be_a_virtual_class
+    end
+
     NilClass.singleton_object.should be_equal(nil)
   end
 

data/spec/nuggets/proc/bind_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/proc/bind'
 
-describe Proc, 'when extended by', Nuggets::Proc::BindMixin do
-
-  it { Proc.ancestors.should include(Nuggets::Proc::BindMixin) }
+describe_extended Proc, Nuggets::Proc::BindMixin do
 
   before :each do
     @l = lambda { bla }

data/spec/nuggets/range/quantile_spec.rb

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

data/spec/nuggets/string/camelscore_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/string/camelscore'
 
-describe String, 'when extended by', Nuggets::String::CamelscoreMixin do
-
-  it { String.ancestors.should include(Nuggets::String::CamelscoreMixin) }
+describe_extended String, Nuggets::String::CamelscoreMixin do
 
   def self.with_acronyms(acronyms, &block)
     describe "with acronyms #{acronyms.inspect}" do
@@ -68,18 +66,18 @@ describe String, 'when extended by', Nuggets::String::CamelscoreMixin do
     example { 'HTML'.underscore.should == 'html' }
     example { 'html5'.camelcase.should == 'HTML5' }
     example { 'HTML5'.underscore.should == 'html5' }
-    pending { 'xhtml'.camelcase.should == 'XHTML' }
-    pending { 'XHTML'.underscore.should == 'xhtml' }
+   #pending { 'xhtml'.camelcase.should == 'XHTML' }
+   #pending { 'XHTML'.underscore.should == 'xhtml' }
     example { 'sql'.camelcase.should == 'SQL' }
     example { 'SQL'.underscore.should == 'sql' }
-    pending { 'mysql'.camelcase.should == 'MySQL' }
-    pending { 'MySQL'.underscore.should == 'mysql' }
-    pending { 'postgresql'.camelcase.should == 'PostgreSQL' }
-    pending { 'PostgreSQL'.underscore.should == 'postgresql' }
-    pending { 'sqlite'.camelcase.should == 'SQLite' }
-    pending { 'SQLite'.underscore.should == 'sqlite' }
-    pending { 'nosql'.camelcase.should == 'NoSQL' }
-    pending { 'NoSQL'.underscore.should == 'nosql' }
+   #pending { 'mysql'.camelcase.should == 'MySQL' }
+   #pending { 'MySQL'.underscore.should == 'mysql' }
+   #pending { 'postgresql'.camelcase.should == 'PostgreSQL' }
+   #pending { 'PostgreSQL'.underscore.should == 'postgresql' }
+   #pending { 'sqlite'.camelcase.should == 'SQLite' }
+   #pending { 'SQLite'.underscore.should == 'sqlite' }
+   #pending { 'nosql'.camelcase.should == 'NoSQL' }
+   #pending { 'NoSQL'.underscore.should == 'nosql' }
   }
 
   with_acronyms('rss' => 'RSS', 'xml' => 'XML') {

data/spec/nuggets/string/capitalize_first_spec.rb

@@ -0,0 +1,13 @@
+require 'nuggets/string/capitalize_first'
+
+describe String, 'capitalize_first' do
+
+  {
+    'Some string' => 'Some string',
+    'some string' => 'Some string',
+    'SOME STRING' => 'SOME STRING'
+  }.each { |s, c|
+    example { s.capitalize_first.should == c }
+  }
+
+end

data/spec/nuggets/string/case_spec.rb

@@ -0,0 +1,31 @@
+require 'nuggets/string/case'
+
+describe String, 'case' do
+
+  example {
+    s = 'Some string'
+
+    s.case.should == :mixed
+    s.should_not be_downcase
+    s.should_not be_upcase
+    s.should be_mixed_case
+    s.should be_capitalized
+  }
+
+  example {
+    s = 'some string'
+
+    s.case.should == :lower
+    s.should be_downcase
+    s.should_not be_mixed_case
+  }
+
+  example {
+    s = 'SOME STRING'
+
+    s.case.should == :upper
+    s.should be_upcase
+    s.should_not be_mixed_case
+  }
+
+end

data/spec/nuggets/string/evaluate_spec.rb

@@ -1,8 +1,6 @@
 require 'nuggets/string/evaluate'
 
-describe String, 'when extended by', Nuggets::String::EvaluateMixin do
-
-  it { String.ancestors.should include(Nuggets::String::EvaluateMixin) }
+describe_extended String, Nuggets::String::EvaluateMixin do
 
   describe do
 

data/spec/nuggets/string/msub_spec.rb

@@ -0,0 +1,20 @@
+require 'nuggets/string/msub'
+
+describe String, 'msub' do
+
+  let(:s) { 'Foo, Bar - Baz' }
+
+  example { s.gsub(/a/, 'o').gsub(/o/, 'a').should == 'Faa, Bar - Baz' }
+  example { s.msub('a' => 'o', 'o' => 'a').should == 'Faa, Bor - Boz' }
+
+  example { s.msub!('a' => 'o', 'o' => 'a'); s.should == 'Faa, Bor - Boz' }
+
+  example { s.msub(/[A-Z]/ => '#{__match__.downcase}', __binding__: binding).should == 'foo, bar - baz' }
+  example { s.msub(/[A-Z]/ => lambda { |match| match.downcase }).should == 'foo, bar - baz' }
+
+  t = '!!!'
+
+  example { lambda { s.msub('r' => '???', 'z' => '#{t}') }.should raise_error(NameError) }
+  example { s.msub('r' => '???', 'z' => '#{t}', __binding__: binding).should == 'Foo, Ba??? - Ba!!!' }
+
+end

data/spec/nuggets/string/nsub_spec.rb

@@ -0,0 +1,13 @@
+require 'nuggets/string/nsub'
+
+describe String, 'nsub' do
+
+  let(:s) { 'a b c d e f g h i' }
+
+  example { s.nsub(' ', '', 6).should == 'abcdefg h i' }
+
+  example { s.nsub(' ', 6) { '' }.should == 'abcdefg h i' }
+
+  example { s.nsub!(' ', '', 6); s.should == 'abcdefg h i' }
+
+end