more_core_extensions 3.2.0 → 3.3.0

data/spec/core_ext/array/nested_spec.rb

@@ -1,183 +0,0 @@
-shared_examples_for "core_ext/array/nested will not modify arguments" do |meth|
-  it "will not modify arguments" do
-    args = (meth == :store_path ? [1] : [])
-
-    key  = [3, 0, 1, 2]
-    key2 = key.dup
-    array.send(meth, key2, *args)
-    expect(key2).to eq(key)
-
-    key  = [4, 0, 1]
-    key2 = key.dup
-    array.send(meth, key2, *args)
-    expect(key2).to eq(key)
-  end
-end
-
-shared_examples_for "core_ext/array/nested" do
-  context '#fetch_path' do
-    it "with various values" do
-      expect(array.fetch_path(0)).to eq(1)
-      expect(array.fetch_path(1)).to eq([])
-      expect(array.fetch_path(1, 0)).to be_nil
-      expect(array.fetch_path(1, 0, 1)).to be_nil
-      expect(array.fetch_path(2)).to eq([2])
-      expect(array.fetch_path(2, 0)).to eq(2)
-      expect(array.fetch_path(-4, 0)).to eq(2)
-      expect(array.fetch_path(2, 0, 1)).to be_nil
-      expect(array.fetch_path(3, 0, 0, 0)).to eq(3)
-      expect(array.fetch_path(3, 0, 1, 999)).to be_nil
-      expect(array.fetch_path(3, 0, 1, 2, 3)).to be_nil
-      expect(array.fetch_path(4)).to eq([nil, nil, nil, nil])
-      expect(array.fetch_path(4, 0)).to be_nil
-      expect(array.fetch_path(4, 0, 1)).to be_nil
-      expect(array.fetch_path(5)).to eq([])
-      expect(array.fetch_path(5, 0)).to be_nil
-      expect(array.fetch_path(5, 0, 1)).to be_nil
-    end
-
-    it "with a nil value should raise ArgumentError" do
-      expect { array.fetch_path(nil) }.to raise_error(ArgumentError)
-      expect { array.fetch_path(3, nil, 0) }.to raise_error(ArgumentError)
-    end
-
-    it "with invalid values" do
-      expect { array.fetch_path }.to raise_error(ArgumentError)
-    end
-
-    include_examples "core_ext/array/nested will not modify arguments", :fetch_path
-  end
-
-  context "#store_path" do
-    it "on an empty array" do
-      a = described_class.new
-      a.store_path(0, 1)
-      expect(a).to eq([1])
-
-      a = described_class.new
-      a.store_path(1, 0, 2)
-      expect(a).to eq([nil, [2]])
-    end
-
-    it "on an existing array" do
-      array.store_path(1, 0, 2)
-      expect(array[1]).to eq([2])
-      array.store_path(2, 0, 3)
-      expect(array[2]).to eq([3])
-      array.store_path(-4, 0, 3)
-      expect(array[2]).to eq([3])
-    end
-
-    it "on an existing item that is not a array" do
-      array.store_path(0, 2)
-      expect(array[0]).to eq(2)
-      array.store_path(0, 0, 3)
-      expect(array[0]).to eq([3])
-    end
-
-    it "with an array of args" do
-      a = described_class.new
-      a.store_path([3, 0, 1, 2], 3)
-      expect(a).to eq([nil, nil, nil, [[nil, [nil, nil, 3]]]])
-    end
-
-    it "with a nil value" do
-      a = described_class.new
-      a.store_path(0, 1, nil)
-      expect(a).to eq([[nil, nil]])
-    end
-
-    it "with an Array value" do
-      a = described_class.new
-      a.store_path(0, 1, [2, 3])
-      expect(a).to eq([[nil, [2, 3]]])
-    end
-
-    it "with a Hash value" do
-      a = described_class.new
-      a.store_path(0, 1, {2 => 3})
-      expect(a).to eq([[nil, {2 => 3}]])
-    end
-
-    it "with invalid values" do
-      expect { described_class.new.store_path }.to raise_error(ArgumentError)
-      expect { described_class.new.store_path(1) }.to raise_error(ArgumentError)
-    end
-
-    include_examples "core_ext/array/nested will not modify arguments", :store_path
-  end
-
-  context '#has_key_path?' do
-    it "with various values" do
-      expect(array.has_key_path?(0)).to be_truthy
-      expect(array.has_key_path?(1)).to be_truthy
-      expect(array.has_key_path?(1, 0)).to be_falsey
-      expect(array.has_key_path?(1, 0, 1)).to be_falsey
-      expect(array.has_key_path?(2)).to be_truthy
-      expect(array.has_key_path?(2, 0)).to be_truthy
-      expect(array.has_key_path?(2, 0, 1)).to be_falsey
-      expect(array.has_key_path?(3, 0, 1, 2)).to be_falsey
-      expect(array.has_key_path?(3, 0, 1, 999)).to be_falsey
-      expect(array.has_key_path?(3, 0, 1, 2, 3)).to be_falsey
-      expect(array.has_key_path?(4)).to be_truthy
-      expect(array.has_key_path?(4, 0)).to be_truthy
-      expect(array.has_key_path?(4, 0, 1)).to be_falsey
-      expect(array.has_key_path?(5)).to be_truthy
-      expect(array.has_key_path?(5, 0)).to be_falsey
-      expect(array.has_key_path?(5, 0, 1)).to be_falsey
-    end
-
-    it "with a nil value" do
-      expect { array.fetch_path(nil) }.to raise_error(ArgumentError)
-      expect { array.fetch_path(3, nil, 0) }.to raise_error(ArgumentError)
-    end
-
-    it "with invalid values" do
-      expect { array.has_key_path? }.to raise_error(ArgumentError)
-    end
-
-    include_examples "core_ext/array/nested will not modify arguments", :has_key_path?
-  end
-
-  context "#delete_path" do
-    it "on a nested array" do
-      array.delete_path(3, 0, 0, 0)
-      expect(array[3]).to eq([[[]]])
-    end
-
-    it "with an invalid path" do
-      array.delete_path(3, 0, 5)
-      expect(array[3]).to eq([[[3]]])
-    end
-
-    include_examples "core_ext/array/nested will not modify arguments", :delete_path
-  end
-
-  it "#delete_blank_paths" do
-    expect(array.delete_blank_paths).to eq([1, [2], [[[3]]]])
-  end
-
-  context "#find_path" do
-    it "with a real value" do
-      expect(array.find_path(3)).to eq([3, 0, 0, 0])
-    end
-
-    it "with non-existent value" do
-      expect(array.find_path(42)).to eq([])
-    end
-  end
-end
-
-describe Array do
-  let(:array) do
-    [ 1,
-      [],
-      [2],
-      [[[3]]],
-      Array.new(4),
-      described_class.new
-    ]
-  end
-
-  include_examples "core_ext/array/nested"
-end

data/spec/core_ext/array/random_spec.rb

@@ -1,21 +0,0 @@
-describe Array do
-  around do |example|
-    old_seed = srand(12072)
-    example.call
-    srand(old_seed)
-  end
-
-  it '#random_index' do
-    expect(20.times.collect { [].random_index }.uniq.sort).to          eq([nil])
-    expect(20.times.collect { %w{a}.random_index }.uniq.sort).to       eq([0])
-    expect(20.times.collect { %w{a b}.random_index }.uniq.sort).to     eq([0, 1])
-    expect(20.times.collect { %w{a b c d}.random_index }.uniq.sort).to eq([0, 1, 2, 3])
-  end
-
-  it '#random_element' do
-    expect(20.times.collect { [].random_element }.uniq.sort).to          eq([nil])
-    expect(20.times.collect { %w{a}.random_element }.uniq.sort).to       eq(%w{a})
-    expect(20.times.collect { %w{a b}.random_element }.uniq.sort).to     eq(%w{a b})
-    expect(20.times.collect { %w{a b c d}.random_element }.uniq.sort).to eq(%w{a b c d})
-  end
-end

data/spec/core_ext/array/stretch_spec.rb

@@ -1,94 +0,0 @@
-describe Array do
-  STRETCH_CASES = [
-    # 2 parameter cases
-    # Message                             Test case               Expected
-    "receiver same size as parameter",    [[1, 2, 3], [4, 5, 6]], [[1, 2, 3],       [4, 5, 6]],
-
-    "receiver longer than parameter",     [[1, 2, 3], [4, 5]],    [[1, 2, 3],       [4, 5, nil]],
-    "receiver shorter than parameter",    [[1, 2],    [4, 5, 6]], [[1, 2, nil],     [4, 5, 6]],
-
-    "receiver with empty parameter",      [[1, 2, 3], []],        [[1, 2, 3],       [nil, nil, nil]],
-    "receiver is empty with 1 parameter", [[],        [4, 5, 6]], [[nil, nil, nil], [4, 5, 6]],
-
-    # 3 parameter cases
-    # Message                                Test Case                          Expected
-    "receiver longer than some parameters",  [[1, 2, 3], [4, 5],    [7, 8, 9]], [[1, 2, 3],       [4, 5, nil], [7, 8, 9]],
-    "receiver shorter than parameters",      [[1, 2],    [4, 5, 6], [7, 8, 9]], [[1, 2, nil],     [4, 5, 6],   [7, 8, 9]],
-
-    "receiver longer than all parameters",   [[1, 2, 3], [4, 5],    [7, 8]],    [[1, 2, 3],       [4, 5, nil], [7, 8, nil]],
-    "receiver shorter than some parameters", [[1, 2],    [4, 5, 6], [7, 8]],    [[1, 2, nil],     [4, 5, 6],   [7, 8, nil]],
-
-    "receiver is empty with 2 parameters",   [[],        [],        [7, 8, 9]], [[nil, nil, nil], [nil, nil, nil], [7, 8, 9]],
-  ]
-
-  context '.stretch' do
-    STRETCH_CASES.each_slice(3) do |msg, test_case, expected|
-      it "where #{msg}" do
-        result = Array.stretch(*test_case)
-        result.each_with_index do |r, i|
-          expect(r).not_to equal(test_case[i])
-          expect(r).to eq(expected[i])
-        end
-      end
-    end
-  end
-
-  context '.stretch!' do
-    STRETCH_CASES.each_slice(3) do |msg, test_case, expected|
-      it "where #{msg}" do
-        result = Array.stretch!(*test_case)
-        result.each_with_index do |r, i|
-          expect(r).to equal(test_case[i])
-          expect(r).to eq(expected[i])
-        end
-      end
-    end
-  end
-
-  context '#stretch' do
-    STRETCH_CASES.each_slice(3) do |msg, test_case, expected|
-      it "where #{msg}" do
-        receiver, params = test_case[0], test_case[1..-1]
-        result = receiver.stretch(*params)
-        expect(result).not_to equal(receiver)
-        expect(result).to eq(expected[0])
-      end
-    end
-  end
-
-  context '#stretch!' do
-    STRETCH_CASES.each_slice(3) do |msg, test_case, expected|
-      it "where #{msg}" do
-        receiver, params = test_case[0].dup, test_case[1..-1]
-        result = receiver.stretch!(*params)
-        expect(result).to equal(receiver)
-        expect(result).to eq(expected[0])
-      end
-    end
-  end
-
-  ZIP_STRETCHED_CASES = [
-    # 1 parameter tests
-    # Message                          Test case               Expected
-    "receiver same size as parameter", [1, 2, 3], [[4, 5, 6]], [[1, 4], [2, 5], [3, 6]],
-    "receiver longer than parameter",  [1, 2, 3], [[4, 5]],    [[1, 4], [2, 5], [3, nil]],
-    "receiver shorter than parameter", [1, 2],    [[4, 5, 6]], [[1, 4], [2, 5], [nil, 6]],  # Different than zip
-
-    # 2 parameter tests
-    # Message                                Test case                          Expected
-    "receiver same size as all parameters",  [1, 2, 3], [[4, 5, 6], [7, 8, 9]], [[1, 4, 7],   [2, 5, 8],   [3, 6, 9]],
-    "receiver longer than first parameter",  [1, 2, 3], [[4, 5],    [7, 8, 9]], [[1, 4, 7],   [2, 5, 8],   [3, nil, 9]],
-    "receiver shorter than all parameters",  [1, 2],    [[4, 5, 6], [7, 8, 9]], [[1, 4, 7],   [2, 5, 8],   [nil, 6, 9]],    # Different than zip
-    "receiver shorter than first parameter", [1, 2],    [[4, 5, 6], [7, 8]],    [[1, 4, 7],   [2, 5, 8],   [nil, 6, nil]],  # Different than zip
-    "receiver shorter than last parameter",  [1, 2],    [[4, 5],    [7, 8, 9]], [[1, 4, 7],   [2, 5, 8],   [nil, nil, 9]],  # Different than zip
-    "receiver is empty with 2 parameters",   [],        [[4, 5, 6], [7, 8, 9]], [[nil, 4, 7], [nil, 5, 8], [nil, 6, 9]],    # Different than zip
-  ]
-
-  context '#zip_stretched' do
-    ZIP_STRETCHED_CASES.each_slice(4) do |msg, receiver, params, expected|
-      it "where #{msg}" do
-        expect(receiver.zip_stretched(*params)).to eq(expected)
-      end
-    end
-  end
-end

data/spec/core_ext/array/tableize_spec.rb

@@ -1,156 +0,0 @@
-describe Array do
-  context '#tableize' do
-    context "on an Array of Arrays" do
-      it 'normal case' do
-        test = [["Col1", "Col2"], ["Val1", "Val2"], ["Value3", "Value4"]]
-        expected = <<-EOF
- Col1   | Col2
---------+--------
- Val1   | Val2
- Value3 | Value4
-EOF
-        expect(test.tableize).to eq(expected)
-      end
-
-      it 'with numeric column values right justified' do
-        test = [["Col1", "Col2"], ["Val1", 200], ["Value3", 30]]
-        expected = <<-EOF
- Col1   | Col2
---------+------
- Val1   |  200
- Value3 |   30
-EOF
-        expect(test.tableize).to eq(expected)
-      end
-
-      it 'with really long column value' do
-        test = [["Col1", "Col2"], ["Val1", "Val2"], ["Really Really Long Value3", "Value4"]]
-        expected = <<-EOF
- Col1                      | Col2
----------------------------+--------
- Val1                      | Val2
- Really Really Long Value3 | Value4
-EOF
-        expect(test.tableize).to eq(expected)
-      end
-
-      it 'with really long column value and :max_width option' do
-        test = [["Col1", "Col2"], ["Val1", "Val2"], ["Really Really Long Value3", "Value4"]]
-        expected = <<-EOF
- Col1       | Col2
-------------+--------
- Val1       | Val2
- Really Rea | Value4
-EOF
-        expect(test.tableize(:max_width => 10)).to eq(expected)
-      end
-
-      it 'with :header => false option' do
-        test = [["Col1", "Col2"], ["Val1", "Val2"], ["Value3", "Value4"]]
-        expected = <<-EOF
- Col1   | Col2
- Val1   | Val2
- Value3 | Value4
-EOF
-        expect(test.tableize(:header => false)).to eq(expected)
-      end
-    end
-
-    context "on an Array of Hashes" do
-      before do
-        @str_case = [{"Col3" => "Val3", "Col2" => "Val2", "Col1" => "Val1"}, {"Col3" => "Value6", "Col2" => "Value5", "Col1" => "Value4"}]
-        @sym_case = [{:Col3  => "Val3", :Col2  => "Val2", :Col1  => "Val1"}, {:Col3  => "Value6", :Col2  => "Value5", :Col1  => "Value4"}]
-      end
-
-      it "normal case" do
-          expected = <<-EOF
- Col1   | Col2   | Col3
---------+--------+--------
- Val1   | Val2   | Val3
- Value4 | Value5 | Value6
-EOF
-
-        expect(@str_case.tableize).to eq(expected)
-        expect(@sym_case.tableize).to eq(expected)
-      end
-
-      context "with :columns option" do
-        before do
-          @expected = <<-EOF
- Col3   | Col1   | Col2
---------+--------+--------
- Val3   | Val1   | Val2
- Value6 | Value4 | Value5
-EOF
-        end
-
-        it "normal case" do
-          expect(@str_case.tableize(:columns => ["Col3", "Col1", "Col2"])).to eq(@expected)
-          expect(@sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ])).to eq(@expected)
-        end
-
-        it "with only some values" do
-          expected = <<-EOF
- Col3   | Col1
---------+--------
- Val3   | Val1
- Value6 | Value4
-EOF
-
-          expect(@str_case.tableize(:columns => ["Col3", "Col1"])).to eq(expected)
-          expect(@sym_case.tableize(:columns => [:Col3,  :Col1 ])).to eq(expected)
-        end
-
-        it "and :leading_columns option" do
-          expect(@str_case.tableize(:columns => ["Col3", "Col1", "Col2"], :leading_columns => ["Col1"])).to eq(@expected)
-          expect(@sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ], :leading_columns => [:Col1 ])).to eq(@expected)
-        end
-
-        it "and :trailing_columns option" do
-          expect(@str_case.tableize(:columns => ["Col3", "Col1", "Col2"], :trailing_columns => ["Col1"])).to eq(@expected)
-          expect(@sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ], :trailing_columns => [:Col1 ])).to eq(@expected)
-        end
-      end
-
-      it "with :leading_columns option" do
-        expected = <<-EOF
- Col3   | Col2   | Col1
---------+--------+--------
- Val3   | Val2   | Val1
- Value6 | Value5 | Value4
-EOF
-
-        expect(@str_case.tableize(:leading_columns => ["Col3", "Col2"])).to eq(expected)
-        expect(@sym_case.tableize(:leading_columns => [:Col3,  :Col2 ])).to eq(expected)
-      end
-
-      it "with :trailing_columns option" do
-        expected = <<-EOF
- Col1   | Col3   | Col2
---------+--------+--------
- Val1   | Val3   | Val2
- Value4 | Value6 | Value5
-EOF
-
-        expect(@str_case.tableize(:trailing_columns => ["Col3", "Col2"])).to eq(expected)
-        expect(@sym_case.tableize(:trailing_columns => [:Col3,  :Col2 ])).to eq(expected)
-      end
-
-      it "with both :leading_columns and :trailing_columns options" do
-        expected = <<-EOF
- Col3   | Col1   | Col2
---------+--------+--------
- Val3   | Val1   | Val2
- Value6 | Value4 | Value5
-EOF
-
-        expect(@str_case.tableize(:leading_columns => ["Col3"], :trailing_columns => ["Col2"])).to eq(expected)
-        expect(@sym_case.tableize(:leading_columns => [:Col3 ], :trailing_columns => [:Col2 ])).to eq(expected)
-      end
-    end
-
-    it 'with an invalid receiver' do
-      expect { [1, 2, 3].tableize }.to raise_error(RuntimeError)
-    end
-  end
-end

data/spec/core_ext/hash/deletes_spec.rb

@@ -1,15 +0,0 @@
-describe Hash do
-  it "#delete_nils" do
-    expect({}.delete_nils).to eq({})
-    expect({:a => 1}.delete_nils).to eq({:a => 1})
-    expect({:c => nil}.delete_nils).to eq({})
-    expect({:a => 1, :b => [], :c => nil}.delete_nils).to eq({:a => 1, :b => []})
-  end
-
-  it "#delete_blanks" do
-    expect({}.delete_blanks).to eq({})
-    expect({:a => 1}.delete_blanks).to eq({:a => 1})
-    expect({:c => nil}.delete_blanks).to eq({})
-    expect({:a => 1, :b => [], :c => nil}.delete_blanks).to eq({:a => 1})
-  end
-end