darthjee-core_ext 1.7.3 → 1.7.4

data/spec/lib/date_spec.rb

@@ -3,10 +3,11 @@
 require 'spec_helper'
 
 describe Date do
-  let(:year) { 2018 }
-  let(:month) { 10 }
-  let(:day) { 4 }
-  let(:subject) { Date.new(year, month, day) }
+  subject(:date) { described_class.new(year, month, day) }
+
+  let(:year)    { 2018 }
+  let(:month)   { 10 }
+  let(:day)     { 4 }
 
   describe '#days_between' do
     it_behaves_like 'an object that knows how to calculate days between'

data/spec/lib/hash_spec.rb

@@ -28,34 +28,36 @@ describe Hash do
     let(:result) { hash.sort_keys(**options) }
   end
 
-  describe :exclusive_merge do
-    let(:subject) { { a: 1, b: 2 } }
+  describe '#exclusive_merge' do
+    subject(:hash) { { 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)
+      expect(hash.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 })
+      expect { hash.exclusive_merge(other) }.not_to(change { hash })
     end
   end
 
-  describe :exclusive_merge! do
-    let(:subject) { { a: 1, b: 2 } }
+  describe '#exclusive_merge!' do
+    subject(:hash) { { 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)
+      expect(hash.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 })
+      expect { hash.exclusive_merge!(other) }.to(change { hash })
     end
   end
 
-  describe :to_deep_hash do
-    let(:subject) do
+  describe '#to_deep_hash' do
+    subject(:hash) do
       {
         'person.name' => 'Some name',
         'person.age' => 22,
@@ -74,11 +76,11 @@ describe Hash do
     end
 
     it 'build a deep hash' do
-      expect(subject.to_deep_hash).to eq(expected)
+      expect(hash.to_deep_hash).to eq(expected)
     end
 
     context 'with indexed keys' do
-      let(:subject) do
+      subject(:hash) do
         {
           'person[0].name' => 'First person',
           'person[0].age' => 22,
@@ -102,12 +104,12 @@ describe Hash do
       end
 
       it 'build a deep hash with arrays' do
-        expect(subject.to_deep_hash).to eq(expected)
+        expect(hash.to_deep_hash).to eq(expected)
       end
     end
 
     context 'with a n level hash' do
-      let(:subject) do
+      subject(:hash) do
         {
           'quote_request.personal.person.name' => 'Some name',
           'quote_request.personal.person.age' => 22,
@@ -134,12 +136,12 @@ describe Hash do
       end
 
       it 'build a deep hash with arrays' do
-        expect(subject.to_deep_hash).to eq(expected)
+        expect(hash.to_deep_hash).to eq(expected)
       end
     end
 
     context 'with a n level hash and arrays' do
-      let(:subject) do
+      subject(:hash) do
         {
           'quote_request.personal.person[0].name' => 'Some name 1',
           'quote_request.personal.person[0].age' => 22,
@@ -172,12 +174,12 @@ describe Hash do
       end
 
       it 'build a deep hash with arrays' do
-        expect(subject.to_deep_hash).to eq(expected)
+        expect(hash.to_deep_hash).to eq(expected)
       end
     end
 
     context 'with custom separator' do
-      let(:subject) do
+      subject(:hash) do
         {
           'person_name' => 'Some name',
           'person_age' => 22,
@@ -188,12 +190,12 @@ describe Hash do
       end
 
       it 'build a deep hash with arrays' do
-        expect(subject.to_deep_hash('_')).to eq(expected)
+        expect(hash.to_deep_hash('_')).to eq(expected)
       end
     end
 
     context 'with custom separator on n level deep hash' do
-      let(:subject) do
+      subject(:hash) do
         {
           'person_name_clazz' => String
         }
@@ -208,22 +210,24 @@ describe Hash do
       end
 
       it 'build a deep hash with arrays' do
-        expect(subject.to_deep_hash('_')).to eq(expected)
+        expect(hash.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(: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
 
@@ -238,18 +242,22 @@ describe Hash do
         it { expect(value).to eq(:b) }
       end
 
-      context 'but not for the first value' do
-        let(:transformer) { double(:transformer) }
+      context 'when first value returns nothing' do
         let(:block) { proc { |_, v| transformer.transform(v) } }
 
-        before do
-          allow(transformer).to receive(:transform) do |v|
-            v.to_s if v > 1
+        let(:transformer) do
+          DummyTransformer.new do |value|
+            value.to_s if value > 1
           end
+        end
+
+        before do
+          allow(transformer).to receive(:transform).and_call_original
           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
@@ -271,11 +279,13 @@ describe Hash do
 
     context 'when block returns nil' do
       let(:block) { proc {} }
+
       it { expect(list).to be_empty }
     end
 
     context 'when block returns false' do
       let(:block) { proc { false } }
+
       it { expect(list).to be_empty }
     end
 
@@ -290,14 +300,17 @@ describe Hash do
         it { expect(list).to eq(%i[b c d]) }
       end
 
-      context 'but not for the first value' do
-        let(:transformer) { double(:transformer) }
+      context 'when first value does not return a value' do
         let(:block) { proc { |_, v| transformer.transform(v) } }
 
-        before do
-          allow(transformer).to receive(:transform) do |v|
-            v.to_s if v > 1
+        let(:transformer) do
+          DummyTransformer.new do |value|
+            value.to_s if value > 1
           end
+        end
+
+        before do
+          allow(transformer).to receive(:transform).and_call_original
           list
         end
 

data/spec/lib/math_spec.rb

@@ -13,6 +13,7 @@ describe Math do
 
       context 'when average is not a round number' do
         let(:values) { [0, 1, 2, 3] }
+
         it 'returns the average' do
           expect(described_class.average(values)).to eq(1.5)
         end

data/spec/lib/numeric_spec.rb

@@ -7,38 +7,60 @@ describe Numeric 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)
+      context 'when total is bigger than number' do
+        it 'converts to percentage of number' do
+          expect(number.percent_of(240)).to eq(50)
+        end
       end
 
-      it 'converts to percentage of number' do
-        expect(number.percent_of(60)).to eq(200)
+      context 'when total is smaller than number' do
+        it 'converts to percentage of number' do
+          expect(number.percent_of(60)).to eq(200)
+        end
       end
 
-      it 'do not raise an error when divisor is 0' do
-        expect(100.0.percent_of(0)).to eq(Float::INFINITY)
+      context 'when total is equal number' do
+        it 'converts to percentage of number' do
+          expect(number.percent_of(number)).to eq(100)
+        end
       end
 
-      it 'do not raise an error when divisor is 0.0' do
-        expect(100.0.percent_of(0.0)).to eq(Float::INFINITY)
+      context 'when divisor is 0' do
+        it 'do not raise an error' do
+          expect(100.0.percent_of(0)).to eq(Float::INFINITY)
+        end
+      end
+
+      context 'when divisor is 0.0' do
+        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
     end
 
     context 'when number is integer' do
-      it 'converts to percentage of number' do
-        expect(500.percent_of(50)).to eq(1000)
+      context 'when number is bigger than total' do
+        it 'converts to percentage of number' do
+          expect(500.percent_of(50)).to eq(1000)
+        end
       end
 
-      it 'converts to percentage of number' do
-        expect(0.percent_of(50)).to eq(0)
+      context 'when number is 0' do
+        it 'converts to percentage of number' do
+          expect(0.percent_of(50)).to eq(0)
+        end
       end
 
-      it 'converts to percentage of number' do
-        expect(10.percent_of(100)).to eq(10)
+      context 'when number is smaller than total' do
+        it 'converts to percentage of number' do
+          expect(10.percent_of(100)).to eq(10)
+        end
       end
 
-      it 'do not raise an error when divisor is 0' do
-        expect(100.percent_of(0)).to eq(Float::INFINITY)
+      context 'when total is 0' do
+        it 'do not raise an error' do
+          expect(100.percent_of(0)).to eq(Float::INFINITY)
+        end
       end
     end
 
@@ -51,7 +73,7 @@ describe Numeric do
         it { expect(100.percent_of(0)).to eq(Float::INFINITY) }
       end
 
-      context 'both are 0' do
+      context 'when both are 0' do
         it { expect(0.percent_of(0)).to eq(Float::INFINITY) }
       end
     end

data/spec/lib/object_spec.rb

@@ -4,33 +4,33 @@ require 'spec_helper'
 
 describe Object do
   describe '#is_any?' do
-    subject { 1 }
+    subject(:object) { 1 }
 
     it do
-      expect(subject).to respond_to(:is_any?)
+      expect(object).to respond_to(:is_any?)
     end
 
     context 'when no argument is passed' do
       it do
-        expect(subject.is_any?).to be_falsey
+        expect(object).not_to be_is_any
       end
     end
 
     context 'when passing the correct class as argument' do
       it do
-        expect(subject.is_any?(subject.class)).to be_truthy
+        expect(object).to be_is_any(object.class)
       end
 
-      context 'along any other class' do
+      context 'when passing any other class' do
         it do
-          expect(subject.is_any?(Symbol, subject.class)).to be_truthy
+          expect(object).to be_is_any(Symbol, object.class)
         end
       end
     end
 
     context 'when passing the wrong class' do
       it do
-        expect(subject.is_any?(Symbol)).to be_falsey
+        expect(object).not_to be_is_any(Symbol)
       end
     end
   end

data/spec/lib/symbol_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Symbol do
   describe '#camelize' do
-    it { expect(:sym.camelize).to be_kind_of(Symbol) }
+    it { expect(:sym.camelize).to be_kind_of(described_class) }
 
     context 'when called with upper option' do
       it 'camelize the symbol' do
@@ -26,7 +26,7 @@ describe Symbol do
   end
 
   describe '#underscore' do
-    it { expect(:symBol.underscore).to be_kind_of(Symbol) }
+    it { expect(:symBol.underscore).to be_kind_of(described_class) }
 
     context 'when called with upper option' do
       it 'underscore the symbol' do

data/spec/lib/time_spec.rb

@@ -3,10 +3,11 @@
 require 'spec_helper'
 
 describe Time do
-  let(:year) { 2018 }
-  let(:month) { 10 }
-  let(:day) { 4 }
-  let(:subject) { Time.new(year, month, day, 10, 0, 0) }
+  subject(:date) { described_class.new(year, month, day, 10, 0, 0) }
+
+  let(:year)    { 2018 }
+  let(:month)   { 10 }
+  let(:day)     { 4 }
 
   describe '#days_between' do
     it_behaves_like 'an object that knows how to calculate days between'

data/spec/support/models/default_reader_model.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class DefaultReaderModel
+  attr_writer :name, :cars
+
+  default_reader :name, 'John'
+  default_readers :cars, :houses, 2
+end

data/spec/support/models/default_value_model.rb

@@ -3,4 +3,6 @@
 class DefaultValueModel
   default_value :x, 10
   default_values :y, :z, 20
+  default_value :array, [10, 20]
+  default_values :hash, :json, a: 1
 end

data/spec/support/models/dummy_iterator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class DummyIterator
+  def initialize(array)
+    @array = array
+  end
+
+  def map(*args, &block)
+    @array.map(*args, &block)
+  end
+
+  def each(*args, &block)
+    @array.each(*args, &block)
+  end
+end

data/spec/support/models/dummy_transformer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class DummyTransformer
+  def initialize(&block)
+    @block = block
+  end
+
+  def transform(value)
+    block.call(value)
+  end
+
+  private
+
+  attr_reader :block
+end

data/spec/support/shared_examples/array/array_random.rb

@@ -6,8 +6,9 @@ shared_examples 'a method that returns a random element' do |method|
   (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)
+        allow(Random).to receive(:rand)
           .with(array.size) { index }
       end