ruby-nuggets 0.9.9 → 1.0.0

data/spec/nuggets/hash/deep_merge_spec.rb

@@ -1,78 +0,0 @@
-require 'nuggets/hash/deep_merge'
-
-describe_extended Hash, Nuggets::Hash::DeepMergeMixin do
-
-  example do
-    { :a => 1 }.deep_merge(:a => 2).should == { :a => 2 }
-  end
-
-  example do
-    { :a => 1 }.deep_merge(:b => 2).should == { :a => 1, :b => 2 }
-  end
-
-  example do
-    { :a => { :b => 1 } }.deep_merge(:b => 2).should == { :a => { :b => 1 }, :b => 2 }
-  end
-
-  example do
-    { :a => { :b => 1 } }.deep_merge(:a => { :b => 2 }).should == { :a => { :b => 2 } }
-  end
-
-  example do
-    lambda { { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => 2 }) }.should raise_error(TypeError)
-  end
-
-  example do
-    { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => { :c => 2 } }).should == { :a => { :b => { :c => 2 } } }
-  end
-
-  example do
-    { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => { :d => 2 } }).should == { :a => { :b => { :c => 1, :d => 2 } } }
-  end
-
-  example do
-    { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => { :c => 2 }, :d => 3 }).should == { :a => { :b => { :c => 2 }, :d => 3 } }
-  end
-
-  example do
-    { :a => { :b => { :c => 1 }, :d => 2 } }.deep_merge(:a => { :b => { :c => 2 }, :d => 3 }).should == { :a => { :b => { :c => 2 }, :d => 3 } }
-  end
-
-  example do
-    { :a => { :b => { :c => 1 }, :d => 2 }, :e => 3 }.deep_merge(:a => { :b => { :c => 2 }, :d => 3 }).should == { :a => { :b => { :c => 2 }, :d => 3 }, :e => 3 }
-  end
-
-  example do
-    { :a => { :b => { :c => 1 } }, :d => { :e => 3 } }.deep_merge(:a => { :b => { :c => 2 } }, :d => { :e => 4 }).should == { :a => { :b => { :c => 2 } }, :d => { :e => 4 } }
-  end
-
-  context do
-
-    before :each do
-      @sub_hash1 = { :b => 1 }
-      @sub_hash2 = { :b => 2 }
-
-      @hash1 = { :a => @sub_hash1 }
-      @hash2 = { :a => @sub_hash2 }
-      @hash3 = { :a => { :b => 2} }
-    end
-
-    example do
-      @hash1.deep_merge(@hash2).should == @hash3
-      @hash1.should_not == @hash3
-
-      @sub_hash1[:b].should == 1
-      @sub_hash2[:b].should == 2
-    end
-
-    example do
-      @hash1.deep_merge!(@hash2).should == @hash3
-      @hash1.should == @hash3
-
-      @sub_hash1[:b].should == 1
-      @sub_hash2[:b].should == 2
-    end
-
-  end
-
-end

data/spec/nuggets/hash/in_order_spec.rb

@@ -1,12 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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,102 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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,36 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,13 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-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,18 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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