nuggets 0.9.9 → 1.0.0

data/spec/nuggets/hash/nest_spec.rb

@@ -0,0 +1,102 @@
+require 'nuggets/hash/nest'
+
+describe_extended Hash, Nuggets::Hash::NestMixin, true do
+
+  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/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

@@ -0,0 +1,36 @@
+require 'nuggets/hash/seen'
+
+describe_extended Hash, Nuggets::Hash::SeenMixin, true do
+
+  example do
+    hash = Hash.seen
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should == false
+    hash.should have_key(:a)
+
+    hash[:a].should == true
+    hash[:a].should == true
+  end
+
+  example do
+    hash = Hash.seen(0, 1)
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should == 1
+    hash.should have_key(:a)
+
+    hash[:a].should == 0
+    hash[:a].should == 0
+  end
+
+  example do
+    hash = Hash.seen.update(:a => :b)
+    hash.should be_an_instance_of(Hash)
+
+    hash[:a].should == :b
+    hash[:a].should == :b
+    hash.should have_key(:a)
+  end
+
+end

data/spec/nuggets/hash/unroll_spec.rb

@@ -0,0 +1,68 @@
+require 'nuggets/hash/unroll'
+
+describe_extended Hash, Nuggets::Hash::UnrollMixin do
+
+  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.size.should == 3
+
+    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/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

@@ -0,0 +1,18 @@
+require 'nuggets/integer/length'
+
+describe_extended Integer, Nuggets::Integer::LengthMixin do
+
+  {
+    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,19 @@
+require 'nuggets/integer/map'
+
+describe_extended Integer, Nuggets::Integer::MapMixin do
+
+  {
+    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/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

@@ -0,0 +1,34 @@
+require 'nuggets/object/blank'
+
+describe_extended Object, Nuggets::Object::BlankMixin do
+
+  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