darthjee-core_ext 1.7.4 → 2.0.0

data/spec/integration/yard/darthjee/core_ext/hash/transposeable_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::Transposeable do
+  describe 'yard' do
+    subject(:hash) do
+      {
+        key1: :value1,
+        key2: :value2
+      }
+    end
+
+    describe '#transpose' do
+      it 'transpose rows and keys' do
+        expect(hash.transpose).to eq(
+          value1: :key1,
+          value2: :key2
+        )
+      end
+
+      it do
+        expect { hash.transpose }.not_to(change { hash })
+      end
+    end
+
+    describe '#transpose' do
+      it 'transpose rows and keys' do
+        expect { hash.transpose! }.to change { hash }
+          .to(
+            value1: :key1,
+            value2: :key2
+          )
+      end
+    end
+  end
+end

data/spec/integration/yard/darthjee/core_ext/hash_spec.rb

@@ -22,13 +22,15 @@ describe Hash do
       context 'when key is not found' do
         context 'when no block is given' do
           it do
-            expect { hash.chain_fetch(:a, :c, :d) }.to raise_error(KeyError)
+            expect { hash.chain_fetch(:a, :c, :d) }
+              .to raise_error(KeyError)
           end
         end
 
         context 'when a block is given' do
           it do
-            expect { hash.chain_fetch(:a, :c, :d) { 10 } }.not_to raise_error
+            expect { hash.chain_fetch(:a, :c, :d) { 10 } }
+              .not_to raise_error
           end
 
           it 'returns the result of the block' do
@@ -37,6 +39,15 @@ describe Hash do
           end
         end
       end
+
+      describe '#append_to_keys' do
+        let(:hash) { { :a => 1, 'b' => 2 } }
+
+        it 'appends string to keys' do
+          expect(hash.prepend_to_keys('foo_'))
+            .to eq(:foo_a => 1, 'foo_b' => 2)
+        end
+      end
     end
   end
 end

data/spec/integration/yard/darthjee/core_ext/math_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Math do
+  describe 'yard' do
+    describe '.average' do
+      describe 'Average of array' do
+        let(:values) { [1, 2, 3, 4] }
+
+        it 'calculates the average' do
+          expect(Math.average(values)).to eq(2.5)
+        end
+      end
+
+      describe 'Average of hash' do
+        let(:values) do
+          {
+            1 => 3,
+            7 => 1
+          }
+        end
+
+        it 'calculates the average' do
+          expect(Math.average(values)).to eq(2.5)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/darthjee/core_ext/numeric_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Numeric do
+  describe 'yard' do
+    describe '#percent_of' do
+      it 'calculates the percentage over total' do
+        expect(10.percent_of(30)).to eq(33.33333333333333)
+      end
+    end
+  end
+end

data/spec/integration/yard/darthjee/core_ext/object_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Object do
+  describe 'yard' do
+    describe '#is_any?' do
+      subject(:object) { [1, 2, 3] }
+
+      context 'when none match' do
+        it do
+          expect(object).not_to be_is_any(Hash, Class)
+        end
+      end
+
+      context 'when at least one of them matches' do
+        it do
+          expect(object).to be_is_any(Hash, Array)
+        end
+      end
+
+      context 'when a module matches' do
+        it do
+          expect(object).to be_is_any(Enumerable, Class)
+        end
+      end
+    end
+
+    # rubocop: disable RSpec/PredicateMatcher
+    describe '#trueful?' do
+      describe 'Calling on nil object' do
+        it { expect(nil.trueful?).not_to be_truthy }
+      end
+
+      describe 'Calling on empty array' do
+        it { expect([].trueful?).to be_truthy }
+      end
+
+      describe 'Calling on empty hash' do
+        it { expect({}.trueful?).to be_truthy }
+      end
+
+      describe 'Calling on empty string' do
+        it { expect(''.trueful?).to be_truthy }
+      end
+    end
+    # rubocop: enable RSpec/PredicateMatcher
+  end
+end

data/spec/integration/yard/darthjee/core_ext/symbol_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Symbol do
+  describe 'yard' do
+    describe '#camelize' do
+      it 'camelizes symbol' do
+        expect(:the_symbol.camelize).to eq(:TheSymbol)
+      end
+    end
+
+    describe '#underscore' do
+      it 'underscores symbol' do
+        expect(:theSymbol.underscore).to eq(:the_symbol)
+      end
+    end
+  end
+end

data/spec/lib/darthjee/core_ext/hash/deep_hash_constructor/setter_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Hash::DeepHashConstructor::Setter do
+  subject(:setter) { described_class.new(hash, base_key) }
+
+  let(:hash)  { {} }
+  let(:value) { 21 }
+
+  describe '#set' do
+    context 'when base_key does not have index' do
+      let(:base_key) { 'person' }
+
+      context 'when key is nil' do
+        let(:key) { nil }
+
+        it 'set value on base key' do
+          expect { setter.set(key, value) }
+            .to change { hash }
+            .from({})
+            .to(base_key => value)
+        end
+      end
+
+      context 'when key is present' do
+        let(:key) { 'age' }
+
+        it 'set value on inner hash' do
+          expect { setter.set(key, value) }
+            .to change { hash }
+            .from({})
+            .to(base_key => { key => value })
+        end
+      end
+    end
+
+    context 'when base_key has index' do
+      let(:base_key) { 'person[0]' }
+
+      context 'when key is nil' do
+        let(:key) { nil }
+
+        it 'set value on base key array' do
+          expect { setter.set(key, value) }
+            .to change { hash }
+            .from({})
+            .to('person' => [value])
+        end
+      end
+
+      context 'when key is present' do
+        let(:key) { 'age' }
+
+        it 'set value on inner hash inside array' do
+          expect { setter.set(key, value) }
+            .to change { hash }
+            .from({})
+            .to('person' => [{ key => value }])
+        end
+      end
+    end
+  end
+end

data/spec/lib/darthjee/core_ext/hash/deep_hash_constructor_spec.rb

@@ -3,167 +3,27 @@
 require 'spec_helper'
 
 describe Darthjee::CoreExt::Hash::DeepHashConstructor do
-  let(:subject)   { described_class.new('.') }
-  let(:deep_hash) { subject.deep_hash(hash) }
+  subject(:constructor) { described_class.new('.') }
 
-  describe '.deep_hash' do
-    let(:hash) 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(deep_hash).to eq(expected)
-    end
-
-    context 'with indexed keys' do
-      let(:hash) 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(deep_hash).to eq(expected)
-      end
-    end
-
-    context 'with a n level hash' do
-      let(:hash) 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(deep_hash).to eq(expected)
-      end
-    end
-
-    context 'with a n level hash and arrays' do
-      let(:hash) 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' => Integer,
-          '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' => Integer } },
-            { 'status' => { 'clazz' => Date } }
-          ],
-          'trials' => 3
-        }
-      end
-
-      it 'build a deep hash with arrays' do
-        expect(deep_hash).to eq(expected)
-      end
-    end
+  let(:hash) do
+    {
+      'person.name' => 'John',
+      'person.age' => '22'
+    }
+  end
 
-    context 'with custom separator' do
-      let(:subject) { described_class.new('_') }
-      let(:hash) do
-        {
-          'person_name' => 'Some name',
-          'person_age' => 22,
-          'status' => :success,
-          'vehicle_fuel' => 'GASOLINE',
-          'vehicle_doors' => 4
-        }
-      end
+  describe '#deep_hash' do
+    it_behaves_like 'a method that returns a deep hash' do
+      subject(:constructor) { described_class.new(*args) }
 
-      it 'build a deep hash with arrays' do
-        expect(deep_hash).to eq(expected)
-      end
+      let(:result) { constructor.deep_hash(hash) }
     end
 
-    context 'with custom separator on n level deep hash' do
-      let(:subject) { described_class.new('_') }
-      let(:hash) do
-        {
-          'person_name_clazz' => String
-        }
-      end
-
-      let(:expected) do
-        {
-          'person' => {
-            'name' => { 'clazz' => String }
-          }
-        }
-      end
-
-      it 'build a deep hash with arrays' do
-        expect(deep_hash).to eq(expected)
-      end
+    it 'does changes hash' do
+      expect { constructor.deep_hash(hash) }
+        .to change { hash }
+        .from('person.name' => 'John', 'person.age' => '22')
+        .to('person' => { 'name' => 'John', 'age' => '22' })
     end
   end
 end

data/spec/lib/darthjee/core_ext/hash/keys_sorter_spec.rb

@@ -3,9 +3,10 @@
 require 'spec_helper'
 
 describe Darthjee::CoreExt::Hash::KeysSorter do
-  it_behaves_like 'a class with a keys sort method' do
-    subject { described_class.new(hash, **options) }
+  subject { described_class.new(hash, **options) }
 
-    let(:result) { subject.sort }
-  end
+  let(:result) { subject.sort }
+
+  it_behaves_like 'a class with a keys sort method'
+  it_behaves_like 'a class with a keys sort method that changes original'
 end

data/spec/lib/darthjee/core_ext/hash/squasher_spec.rb

@@ -3,7 +3,13 @@
 require 'spec_helper'
 
 describe Darthjee::CoreExt::Hash::Squasher do
-  it_behaves_like 'a class that has a method to squash a hash' do
-    let(:squashed) { described_class.squash(hash) }
+  describe '#squash' do
+    it_behaves_like 'a method to squash a hash' do
+      let(:squashed) { described_class.new.squash(hash) }
+    end
+
+    it_behaves_like 'a method to squash a hash', '/' do
+      let(:squashed) { described_class.new('/').squash(hash) }
+    end
   end
 end