darthjee-core_ext 1.2.6

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,35 @@
+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 'camelize the symbol without captalization' 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
+
+  describe '#underscore' do
+    it { expect(:symBol.underscore).to be_kind_of(Symbol) }
+
+    context 'when called with upper option' do
+      it 'underscore the symbol' do
+        expect(:symBol.underscore).to eq(:sym_bol)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require 'simplecov'
+
+SimpleCov.profiles.define 'gem' do
+  add_filter '/spec/'
+end
+
+SimpleCov.start 'gem'
+require 'pry-nav'
+require 'darthjee/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/models/hash/value_changer/dummy.rb

@@ -0,0 +1,15 @@
+class Hash::ValueChanger::Dummy
+  attr_reader :value
+
+  delegate :+, to: :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def eql?(other)
+    return true if equals?(other)
+    return false unless other.is_a?(self.class)
+    a.value == value
+  end
+end

data/spec/support/models/hash/value_changer/dummy_iteractor.rb

@@ -0,0 +1,12 @@
+class Hash::ValueChanger::DummyIteractor
+  def initialize(*array)
+    @array = array
+  end
+
+  delegate :each, :to_a, to: :array
+
+  private
+
+  attr_reader :array
+end
+

data/spec/support/shared_examples/array_random.rb

@@ -0,0 +1,16 @@
+shared_examples 'a method that returns a random element' do |method|
+  let(:array) { [ 7, 5, 3 ] }
+
+  (0..2).each do |index|
+    context "when random returns #{index}" do
+      let!(:expected) { array[index] }
+      before do
+        allow_any_instance_of(Array).to receive(:rand).with(array.size) { index }
+      end
+
+      it 'returns the randomized index of the array' do
+        expect(array.public_send(method)).to eq(expected)
+      end
+    end
+  end
+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

data/spec/support/shared_examples/chain_hash_keys_changer.rb

@@ -0,0 +1,88 @@
+shared_examples 'a class with chain_change_key method' do
+  let(:hash) do
+    { 'a' => 1, b: 2, c: { d: 3, e: 4 }, f: [{ g: 5 }, { h: 6 }] }
+  end
+
+  describe :chain_change_keys do
+
+    it_behaves_like 'a method that is able to chain change keys', :chain_change_keys
+    it 'does not affects the original hash' do
+      expect do
+        hash.chain_change_keys(:to_s, :upcase)
+      end.not_to change { hash }
+    end
+  end
+
+  describe :ichain_change_keys! do
+    it_behaves_like 'a method that is able to chain change keys', :chain_change_keys!
+
+    it 'affects the original hash' do
+      expect do
+        hash.chain_change_keys!(:to_s, :upcase)
+      end.to change { hash }
+    end
+  end
+end
+
+shared_examples 'a method that is able to chain change keys' do |method|
+  let(:result) { hash.public_send(method, *transformations, options) }
+  let(:options) { {} }
+  let(:transformations) { [ :to_s ] }
+
+  context 'with simple level hash' do
+    let(:hash) { { 'a' => 1, b: 2 } }
+
+    context 'with symbol transformation' do
+      let(:transformations) { [ :to_sym ] }
+      let(:expected) { { a: 1, b: 2 } }
+      it_behaves_like 'result is as expected'
+    end
+
+    context 'with string transformation' do
+      let(:expected) { { 'a' => 1, 'b' => 2 } }
+      it_behaves_like 'result is as expected'
+    end
+  end
+
+  context 'with recursive hash' do
+    let(:hash) { { 'a' => 1, b:  { c: 3, 'd' => 4 } } }
+    let(:expected) do
+      { 'a' => 1, 'b' =>  { 'c' => 3, 'd' => 4 } }
+    end
+
+    context 'when no options are given' do
+      it_behaves_like 'result is as expected'
+    end
+
+    context 'when options are given' do
+      let(:options) { { recursive: recursive } }
+
+      context 'with recursion' do
+        let(:recursive) { true }
+        it_behaves_like 'result is as expected'
+      end
+
+      context 'without recursion' do
+        let(:recursive) { false }
+        let(:expected) { { 'a' => 1, 'b' =>  { c: 3, 'd' => 4 } } }
+        it_behaves_like 'result is as expected'
+      end
+    end
+  end
+
+  context 'with many many levels' do
+    let(:hash) { { a: 1, b: { c: 2, d: { e: 3, f: 4 } } } }
+    let(:expected) do
+      { 'a' => 1, 'b' => { 'c' => 2, 'd' => { 'e' => 3, 'f' => 4 } } }
+    end
+    it_behaves_like 'result is as expected'
+  end
+
+  context 'calling with chained transformations' do
+    let(:transformations) { [ :to_s, :upcase, :to_sym ] }
+
+    let(:hexpected) do
+      { A: 1, B: 2, C: { D: 3, E: 4 }, F: [{ G: 5 }, { H: 6 }] }
+    end
+  end
+end

data/spec/support/shared_examples/clean.rb

@@ -0,0 +1,143 @@
+shared_examples 'a hash clean method' do |method|
+  context 'when hash has one level' do
+    let(:subject) do
+      { a: 1, b: nil, c: '', d: {} }
+    end
+
+    let(:expected) do
+      { a: 1 }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has two levels' do
+    let(:subject) do
+      { a: 1, c: '', d: { e: 1 }, f: { g: { b: nil } } }
+    end
+
+    let(:expected) do
+      { a: 1, d: { e: 1 } }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has many levels' do
+    let(:subject) do
+      { a: 1, d: { e: { k: { l: { m: { n: 1 } } } } }, f: { g: { h: { i: { j: { c: '' } } } } } }
+    end
+
+    let(:expected) do
+      { a: 1, d: { e: { k: { l: { m: { n: 1 } } } } } }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has one nil value and one valid value' do
+    let(:subject) do
+      { a: { b: 1, c: nil } }
+    end
+
+    let(:expected) do
+      { a: { b: 1 } }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays' do
+    let(:subject) do
+      { a: [] }
+    end
+
+    let(:expected) do
+      {}
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays with hashes' do
+    let(:subject) do
+      { a: [{ c: nil }] }
+    end
+
+    let(:expected) do
+      {}
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays with hashes with valid values' do
+    let(:subject) do
+      { a: [{ c: 1 }] }
+    end
+
+    let(:expected) do
+      { a: [{ c: 1 }] }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays with hashes with valid and invalid values' do
+    let(:subject) do
+      { a: [{ c: nil }, { d: 1 }] }
+    end
+
+    let(:expected) do
+      { a: [{ d: 1 }] }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+end
+
+shared_examples 'an array clean method' do |method|
+  context 'when array has one level' do
+    let(:subject) do
+      [1, nil, '', {}, []]
+    end
+
+    let(:expected) do
+      [1]
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when array has many levels' do
+    let(:subject) do
+      [1, nil, '', {}, [[[{ a: [[[[[[[]]]]]]] }]]], [[[[[[[2]]]]]]], [{ a: [2] }]]
+    end
+
+    let(:expected) do
+      [1, [[[[[[[2]]]]]]], [{ a: [2] }]]
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+end