bidu-core_ext 1.0.0

data/spec/lib/hash_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe Hash do
+  it_behaves_like 'a class with change_key method'
+  it_behaves_like 'a class with camlize_keys method'
+  it_behaves_like 'a class with append_keys method'
+  it_behaves_like 'a class with change_kvalues method'
+  it_behaves_like 'a class with remap method'
+  it_behaves_like 'an object with chain_fetch method'
+
+  describe :squash do
+    let(:hash) { { a: { b: 1, c: { d: 2 } } } }
+
+    it 'flattens the hash' do
+      expect(hash.squash).to eq('a.b' => 1, 'a.c.d' => 2)
+    end
+
+    it { expect { hash.squash }.not_to change { hash } }
+
+    context 'with array value' do
+      let(:hash) { { a: { b: [1, { x: 3, y: { z: 4 } }] } } }
+
+      it 'flattens the hash' do
+        expect(hash.squash).to eq('a.b' => [1, { x: 3, y: { z: 4 } }])
+      end
+    end
+  end
+
+  describe :sort_keys do
+    it 'sorts keys as symbols' do
+      expect({ b: 1, a: 2 }.sort_keys).to eq(a: 2, b: 1)
+    end
+    it 'sorts keys as string' do
+      expect({ 'b' => 1, 'a' => 2 }.sort_keys).to eq('a' => 2, 'b' => 1)
+    end
+    it 'sorts keys recursively' do
+      expect({ b: 1, a: { d: 3, c: 4 } }.sort_keys).to eq(a: { c: 4, d: 3 }, b: 1)
+    end
+    it 'sorts keys recursively when argumen is passed' do
+      expect({ b: 1, a: { d: 3, c: 4 } }.sort_keys(recursive: true)).to eq(a: { c: 4, d: 3 }, b: 1)
+    end
+    it 'does not sorts keys recursively when argumen is passed' do
+      expect({ b: 1, a: { d: 3, c: 4 } }.sort_keys(recursive: false)).to eq(a: { d: 3, c: 4 }, b: 1)
+    end
+    it 'sort recursevely on many levels' do
+      hash = { b: 1, a: { d: 2, c: { e: 3, f: 4 } } }
+      expected = { a: { c: { f: 4, e: 3 }, d: 2 }, b: 1 }
+      expect(hash.sort_keys(recursive: true)).to eq(expected)
+    end
+    it 'applies to arrays as well' do
+      hash = { b: 1, a: { d: 2, c: [{ e: 3, f: 4 }] } }
+      expected = { a: { c: [{ f: 4, e: 3 }], d: 2 }, b: 1 }
+      expect(hash.sort_keys(recursive: true)).to eq(expected)
+    end
+  end
+
+  describe :exclusive_merge do
+    let(:subject) { { a: 1, b: 2 } }
+    let(:other) { { b: 3, c: 4 } }
+
+    it 'merge only the common keys' do
+      expect(subject.exclusive_merge(other)).to eq(a: 1, b: 3)
+    end
+
+    it 'does not change the original hash' do
+      expect { subject.exclusive_merge(other) }.not_to change { subject }
+    end
+  end
+
+  describe :exclusive_merge! do
+    let(:subject) { { a: 1, b: 2 } }
+    let(:other) { { b: 3, c: 4 } }
+
+    it 'merge only the common keys' do
+      expect(subject.exclusive_merge!(other)).to eq(a: 1, b: 3)
+    end
+
+    it 'does not change the original hash' do
+      expect { subject.exclusive_merge!(other) }.to change { subject }
+    end
+  end
+
+  describe :to_deep_hash do
+    let(:subject) do
+      {
+        'person.name' => 'Some name',
+        'person.age' => 22,
+        'status' => :success,
+        'vehicle.fuel' => 'GASOLINE',
+        'vehicle.doors' => 4
+      }
+    end
+
+    let(:expected) do
+      {
+        'person' => { 'name' => 'Some name', 'age' => 22 },
+        'vehicle' => { 'fuel' => 'GASOLINE', 'doors' => 4 },
+        'status' => :success
+      }
+    end
+
+    it 'build a deep hash' do
+      expect(subject.to_deep_hash).to eq(expected)
+    end
+
+    context 'with indexed keys' do
+      let(:subject) do
+        {
+          'person[0].name' => 'First person',
+          'person[0].age' => 22,
+          'person[1].name' => 'Second person',
+          'person[1].age' => 27,
+          'device[0]' => 'GEAR_LOCK',
+          'device[1]' => 'GPS',
+          'zipCode' => '122345-123'
+        }
+      end
+
+      let(:expected) do
+        {
+          'person' => [
+            { 'name' => 'First person', 'age' => 22 },
+            { 'name' => 'Second person', 'age' => 27 }
+          ],
+          'device' => %w(GEAR_LOCK GPS),
+          'zipCode' => '122345-123'
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(subject.to_deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with a n level hash' do
+      let(:subject) do
+        {
+          'quote_request.personal.person.name' => 'Some name',
+          'quote_request.personal.person.age' => 22,
+          'quote_request.insurance.vehicle.fuel' => 'GASOLINE',
+          'quote_request.insurance.vehicle.doors' => 4,
+          'request.status' => :success,
+          'trials' => 3
+        }
+      end
+
+      let(:expected) do
+        {
+          'quote_request' => {
+            'personal' => {
+              'person' => { 'name' => 'Some name', 'age' => 22 }
+            },
+            'insurance' => {
+              'vehicle' => { 'fuel' => 'GASOLINE', 'doors' => 4 }
+            }
+          },
+          'request' => { 'status' => :success },
+          'trials' => 3
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(subject.to_deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with a n level hash and arrays' do
+      let(:subject) do
+        {
+          'quote_request.personal.person[0].name' => 'Some name 1',
+          'quote_request.personal.person[0].age' => 22,
+          'quote_request.personal.person[1].name' => 'Some name 2',
+          'quote_request.personal.person[1].age' => 23,
+          'request[0].status.clazz' => String,
+          'request[1].status.clazz' => Fixnum,
+          'request[2].status.clazz' => Date,
+          'trials' => 3
+        }
+      end
+
+      let(:expected) do
+        {
+          'quote_request' => {
+            'personal' => {
+              'person' => [
+                { 'name' => 'Some name 1', 'age' => 22 },
+                { 'name' => 'Some name 2', 'age' => 23 }
+              ]
+            }
+          },
+          'request' => [
+            { 'status' => { 'clazz' => String } },
+            { 'status' => { 'clazz' => Fixnum } },
+            { 'status' => { 'clazz' => Date } }
+          ],
+          'trials' => 3
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(subject.to_deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with custom separator' do
+      let(:subject) do
+        {
+          'person_name' => 'Some name',
+          'person_age' => 22,
+          'status' => :success,
+          'vehicle_fuel' => 'GASOLINE',
+          'vehicle_doors' => 4
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(subject.to_deep_hash('_')).to eq(expected)
+      end
+    end
+
+    context 'with custom separator on n level deep hash' do
+      let(:subject) do
+        {
+          'person_name_clazz' => String
+        }
+      end
+
+      let(:expected) do
+        {
+          'person' => {
+            'name' => { 'clazz' => String }
+          }
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(subject.to_deep_hash('_')).to eq(expected)
+      end
+    end
+  end
+
+  describe '#map_and_find' do
+    let(:hash) { { a: 1, b: 2, c: 3, d: 4 } }
+    let(:value) { hash.map_and_find(&block) }
+
+    context 'when block returns nil' do
+      let(:block) { proc {} }
+      it { expect(value).to be_nil }
+    end
+
+    context 'when block returns false' do
+      let(:block) { proc { false } }
+      it { expect(value).to be_nil }
+    end
+
+    context 'when block returns a true evaluated value' do
+      let(:block) { proc { |_, v| v.to_s } }
+
+      it { expect(value).to eq('1') }
+
+      context 'but not for the first value' do
+        let(:transformer) { double(:transformer) }
+        let(:block) { proc { |_, v| transformer.transform(v) } }
+
+        before do
+          allow(transformer).to receive(:transform) do |v|
+            v.to_s if v > 1
+          end
+          value
+        end
+
+        it { expect(value).to eq('2') }
+        it 'calls the mapping only until it returns a valid value' do
+          expect(transformer).to have_received(:transform).exactly(2)
+        end
+      end
+    end
+
+    context 'when the block accepts one argument' do
+      let(:block) { proc { |v| v } }
+
+      it do
+        expect(value).to eq([:a, 1])
+      end
+    end
+  end
+end

data/spec/lib/numeric_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Numeric do
+  describe '#percent_of' do
+    context 'when number is float' do
+      let(:number) { 120.0 }
+
+      it 'converts to percentage of number' do
+        expect(number.percent_of(240)).to eq(50)
+      end
+
+      it 'converts to percentage of number' do
+        expect(number.percent_of(60)).to eq(200)
+      end
+
+      it 'do not raise an error when divisor is 0' do
+        expect(100.0.percent_of(0)).to eq(Float::INFINITY)
+      end
+
+      it 'do not raise an error when divisor is 0.0' do
+        expect(100.0.percent_of(0.0)).to eq(Float::INFINITY)
+      end
+    end
+
+    context 'when number is integer' do
+      it 'converts to percentage of number' do
+        expect(500.percent_of(50)).to eq(1000)
+      end
+
+      it 'converts to percentage of number' do
+        expect(0.percent_of(50)).to eq(0)
+      end
+
+      it 'converts to percentage of number' do
+        expect(10.percent_of(100)).to eq(10)
+      end
+
+      it 'do not raise an error when divisor is 0' do
+        expect(100.percent_of(0)).to eq(Float::INFINITY)
+      end
+    end
+
+    context 'when a number is 0' do
+      context 'when divident is 0' do
+        it { expect(0.percent_of(100)).to eq(0) }
+      end
+
+      context 'when divisor is 0' do
+        it { expect(100.percent_of(0)).to eq(Float::INFINITY) }
+      end
+
+      context 'both are 0' do
+        it { expect(0.percent_of(0)).to eq(Float::INFINITY) }
+      end
+    end
+
+    context 'when divisor is nil' do
+      it { expect(100.percent_of(nil)).to eq(Float::INFINITY) }
+    end
+  end
+end

data/spec/lib/symbol_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Symbol do
+  describe '#camelize' do
+    it { expect(:sym.camelize).to be_kind_of(Symbol) }
+
+    context 'when called with upper option' do
+      it 'camelize the symbol' do
+        expect(:underscore_sym.camelize(:upper)).to eq(:UnderscoreSym)
+      end
+    end
+
+    context 'when called with lower option' do
+      it 'snake case the symbol' do
+        expect(:underscore_sym.camelize(:lower)).to eq(:underscoreSym)
+      end
+    end
+
+    context 'when called without option' do
+      it 'camelize the symbol' do
+        expect(:underscore_sym.camelize).to eq(:UnderscoreSym)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'simplecov'
+
+SimpleCov.profiles.define 'gem' do
+  add_filter '/spec/'
+end
+
+SimpleCov.start 'gem'
+require 'bidu/core_ext'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  # --seed 1234
+  config.order = 'random'
+end

data/spec/support/shared_examples/chain_fetch.rb

@@ -0,0 +1,88 @@
+shared_examples 'an object with chain_fetch method' do
+  describe :chain_fetch do
+    let(:value) { 10 }
+    let(:hash) do
+      {
+        b: 1, c: 2, d: 3, a: {
+          c: 3, d: 5, b: {
+            d: 6, a: 1, b: 2, c: {
+              d: value
+            }
+          }
+        }
+      }
+    end
+    let(:keys) { [:a, :b, :c, :d] }
+    let(:result) { hash.chain_fetch(*keys) }
+
+    context 'when fetching existing keys' do
+      it 'returns the value' do
+        expect(result).to eq(value)
+      end
+    end
+
+    context 'when fetching non existing keys keys' do
+      let(:keys) { [:a, :x, :y] }
+
+      context 'when there is no default value' do
+        it 'raises fetch error' do
+          expect { result }.to raise_error(KeyError)
+        end
+
+        context 'when the hash has no keys' do
+          let(:hash) { {} }
+          let(:keys) { [:a] }
+
+          it 'raises fetch error' do
+            expect { result }.to raise_error(KeyError)
+          end
+        end
+
+        context 'with a simple level hash' do
+          let(:hash) { { a: 1 } }
+          let(:keys) { [:c] }
+
+          it 'raises fetch error' do
+            expect { result }.to raise_error(KeyError)
+          end
+        end
+      end
+
+      context 'but a default value block is given' do
+        let(:default_value) { 100 }
+        let(:result) { hash.chain_fetch(*keys) { default_value } }
+
+        it 'returns the default_value' do
+          expect(result).to eq(default_value)
+        end
+
+        context 'and the block logs the missing keys' do
+          it 'hnadles the missing keys' do
+            missing_keys = nil
+            hash.chain_fetch(*keys) do |_, keys|
+              missing_keys = keys
+            end
+
+            expect(missing_keys).to eq([:y])
+          end
+        end
+
+        context 'and the block uses the key for the return' do
+          let(:result) { hash.chain_fetch(*keys) { |k| "returned #{k}" } }
+          it 'hnadles the missing keys' do
+            expect(result).to eq('returned x')
+          end
+        end
+      end
+    end
+
+    context 'when mixing key types' do
+      let(:hash) { { a: { 'b' => { 100 => { true => value } } } } }
+      let(:keys) { [:a, 'b', 100, true] }
+
+      it 'returns the value' do
+        expect(result).to eq(value)
+      end
+    end
+  end
+end