darthjee-core_ext 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd01e58fe4568b6b2c651415bb7677f78265fee8
-  data.tar.gz: 21b3f51a75beeffad0404ce44696bf57ebe43bf4
+  metadata.gz: 7a7679a554bc9075b9a2e6495e47f2602834f106
+  data.tar.gz: ae306ba662a111238d997a02c9f178ace1980421
 SHA512:
-  metadata.gz: e0df37f38b68eae72c79633ab6e31a0e733591dc63164530b34dc326725a47cb158439813f567e3a7ecb5967ae0b245200001312f905cc4a86a5b067cf3f9e5d
-  data.tar.gz: 4c4955a0d35d16e0b7ccb1aebedecc8635a6534a58bafb665eb1f827a63e11c1a65809f16a390877cc6f684b08437a702ba87d63e0d2b2e740f548279a6789ea
+  metadata.gz: 3a9024a26c829e10daba4866d666a7b9ce0fb5ec92f89b839f5ca06263056326ceb85a400e2f35e416393b2c62123aeaddb42133d764d25fadd829aa525578ec
+  data.tar.gz: 4f672dce0e7ea9c55ae670480dfc4306d0776bec49fce1c336d5dfdc15a4927d214c1fe8cb1c5e220255acd47604843efc30bbf985b2c80099f7857e779d256c

data/.gitignore

@@ -1,3 +1,5 @@
 coverage
 pkg
 Gemfile.lock
+doc
+.yardoc

data/README.md

@@ -7,6 +7,10 @@ Darthjee/CoreExt
 [![Test Coverage](https://codeclimate.com/github/darthjee/core_ext/badges/coverage.svg)](https://codeclimate.com/github/darthjee/core_ext/coverage)
 [![Issue Count](https://codeclimate.com/github/darthjee/core_ext/badges/issue_count.svg)](https://codeclimate.com/github/darthjee/core_ext)
 
+Yard Documentation
+-------------------
+https://www.rubydoc.info/gems/darthjee-core_ext/2.7.1
+
 # Usage
 This project adds some new methods to the core ruby classes
 

data/core_ext.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'pry-nav',   '~> 0.2.4'
   gem.add_development_dependency 'rake',      '>= 12.3.1'
   gem.add_development_dependency 'rspec',     '>= 3.8'
-  gem.add_development_dependency 'rubocop',   '>= 0.58.1'
+  gem.add_development_dependency 'rubocop',   '0.58.1'
   gem.add_development_dependency 'simplecov', '~> 0.16.x'
   gem.add_development_dependency 'yard',      '>= 0.9'
 end

data/lib/darthjee/core_ext/array.rb

@@ -2,29 +2,48 @@
 
 module Darthjee
   module CoreExt
+    # Module containing new usefull methods to Ruby vanilla Array
     module Array
       autoload :HashBuilder, 'darthjee/core_ext/array/hash_builder'
 
-      def mapk(*keys)
-        keys.inject(self) do |enum, key|
-          enum.map { |hash| hash[key] }
-        end
-      end
-
-      def procedural_join(mapper = proc(&:to_s))
-        return '' if empty?
-        list = dup
-        prev = first
-        list[0] = mapper.call(prev).to_s
-
-        list.inject do |string, val|
-          j = yield(prev, val) if block_given?
-          "#{string}#{j}#{mapper.call(val)}".tap do
-            prev = val
-          end
-        end
+      # Returns a Hash where the values are the elements of the array
+      #
+      # @param [::Array<::Object>] keys The keys of the hash
+      #
+      # @return [::Hash] hash built pairing the keys and values
+      #
+      # @example Creation of hash with symbol keys
+      #   array = %w[each word one key]
+      #   array.as_hash(%i[a b c d])
+      #   # returns
+      #   # { a: 'each', b: 'word', c: 'one', d: 'key' }
+      def as_hash(keys)
+        Array::HashBuilder.new(self, keys).build
       end
 
+      # Maps the array using the given methods on each
+      # element of the array
+      #
+      # @param [::String,::Symbol] methods List of methods to be called
+      #   sequentially on each element of the array
+      #
+      # @yield [element] block to be called on each element performing
+      #   a final mapping
+      # @yieldparam [::Object] element element that will receive
+      #   the method calls in chain
+      #
+      # @return [::Array] Array with the result of all method calls in chain
+      #
+      # @example Mapping to string out of float size of strings
+      #   words = %w(big_word tiny oh_my_god_such_a_big_word)
+      #   words.chain_map(:size, :to_f, :to_s) # returns ["8.0", "4.0", "25.0"]
+      #
+      # @example Mapping with a block mapping at the end
+      #   words = %w(big_word tiny oh_my_god_such_a_big_word)
+      #
+      #   output = words.chain_map(:size) do |size|
+      #     (size % 2).zero? ? 'even size' : 'odd size'
+      #   end  # returns ["even size", "even size", "odd size"]
       def chain_map(*methods, &block)
         result = methods.inject(self) do |array, method|
           array.map(&method)
@@ -34,14 +53,89 @@ module Darthjee
         result.map(&block)
       end
 
-      def as_hash(keys)
-        Array::HashBuilder.new(self, keys).build
+      # Maps array chain fetching the keys of the hashes inside
+      #
+      # @param [::String,::Symbol] keys list of keys to be
+      # fetched from hashes inside
+      #
+      # @return [::Array] Array resulting of chain fetch of keys
+      #
+      # @example Multi level hash mapping
+      #   array = [
+      #     { a: { b: 1 }, b: 2 },
+      #     { a: { b: 3 }, b: 4 }
+      #   ]
+      #   array,mapk(:a)     # returns [{ b: 1 }, { b: 3 }]
+      #   array.mapk(:a, :b) # returns [1, 3]
+      #
+      # @example Key missing
+      #   array = [
+      #     { a: { b: 1 }, b: 2 },
+      #     { a: { b: 3 }, b: 4 }
+      #   ]
+      #   array.mapk(:c)     # returns [nil, nil]
+      #   array.mapk(:c, :d) # returns [nil, nil]
+      def mapk(*keys)
+        keys.inject(self) do |enum, key|
+          enum.map do |hash|
+            hash&.[] key
+          end
+        end
+      end
+
+      # Joins elements in a string using a proc
+      # to convert elements to Strig and a block for joining
+      #
+      # @param [Proc] mapper Proc that will be used to map values
+      # to string before joining
+      #
+      # @yield [previous, nexte]
+      #   defines the string to be used to join the previous and
+      #   next element
+      # @yieldparam [::Object] previous previous element that was joined
+      # @yieldparam [::Object] nexte next element that will be joined
+      #
+      # @example Addition of positive and negative numbers
+      #   [1, 2, -3, -4, 5].procedural_join do |_previous, nexte|
+      #     nexte.positive? ? '+' : ''
+      #   end     # returns '1+2-3-4+5'
+      #
+      # @example Spaced addition of positive and negative numbers
+      #   mapper = proc { |value| value.to_f.to_s }
+      #   array.procedural_join(mapper) do |_previous, nexte|
+      #     nexte.positive? ? ' +' : ' '
+      #   end     # returns '1.0 +2.0 -3.0 -4.0 +5.0'
+      def procedural_join(mapper = proc(&:to_s))
+        return '' if empty?
+        list =     dup
+        previous = first
+        list[0] = mapper.call(previous).to_s
+
+        list.inject do |string, value|
+          link =        yield(previous, value) if block_given?
+          next_string = mapper.call(value)
+          previous = value
+
+          "#{string}#{link}#{next_string}"
+        end
       end
 
+      # Reeturns a random element of the array without altering it
+      #
+      # @example Picking a random element of numeric array
+      #   array = [10, 20, 30]
+      #   array.random # might return 10, 20 or 30
+      #   array        # returns unchanged [10, 20, 30]
       def random
         self[rand(size)]
       end
 
+      # Reeturns a random element of the array removing it from the array
+      #
+      # @example Slicing a random element of a numeric array
+      #   array = [10, 20, 30]
+      #   array.random! # might return 10, 20 or 30 ... lets say 20
+      #   array         # returns changed [20, 30]
       def random!
         slice!(rand(size))
       end
@@ -49,6 +143,16 @@ module Darthjee
   end
 end
 
+# Ruby Array received
+#
+# - mapk
+# - procedural_join
+# - chain_map
+# - as_hash
+# - random
+# - random!
+#
+# @see Darthjee::CoreExt::Array
 class Array
   include Darthjee::CoreExt::Array
 end

data/lib/darthjee/core_ext/array/hash_builder.rb

@@ -3,14 +3,41 @@
 module Darthjee
   module CoreExt
     module Array
+      # Class responsible for building a Hash from 2 arrays
+      #
+      # @attribute [::Array] values
+      #   values of the hash to be built
+      # @attribute [::Array] keys
+      #   keys of the hash to be built
+      #
+      # @example Building the hash from the array
+      #   values = [10, 20, 30]
+      #   keys   = %i[a b c]
+      #   builder = Darthjee::CoreExt::Array::HashBuilder.new(values, keys)
+      #
+      #   builder.build  # returns { a: 10, b: 20, c: 30 }
+      #
+      # @example Rebuilding a hash from values and keys
+      #   hash = { a: 20, b: 200, c: 2000 }
+      #   builder = Darthjee::CoreExt::Array::HashBuilder.new(
+      #     hash.values,
+      #     hash.keys
+      #   )
+      #
+      #   builder.build == hash   # returns true
       class HashBuilder
         attr_accessor :values, :keys
 
+        # @param [::Array] values List of values of the hash
+        # @param [::Array] keys List of keys of the hash
         def initialize(values, keys)
           @values = values.dup
           @keys = keys.dup
         end
 
+        # Builds the hash
+        # @return [::Hash] Hash whose keys and values are paired
+        #   from builder's keys and values
         def build
           fixes_sizes
 

data/lib/darthjee/core_ext/class.rb

@@ -5,10 +5,81 @@ module Darthjee
     module Class
       private
 
+      # @!visibility public
+      # Adds a method that will return a default value
+      #
+      # the value is evaluated on class definition, meaning that
+      # everytime it is called it will be the same instance
+      #
+      # @param [::Symbol,::String] name Name of the method to be added
+      # @param [::Object] value default value
+      #
+      # @example Defining a default value
+      #   class MyClass
+      #     default_value :name, 'John'
+      #   end
+      #
+      #   MyClass.new.name # returns 'John'
+      #
+      # @example Comparing value across instances
+      #   # frozen_string_literal: false
+      #
+      #   class MyClass
+      #     default_value :name, 'John'
+      #   end
+      #
+      #   instance = MyClass.new
+      #   other = MyClass.new
+      #
+      #   instance.name.equal?('John')      # returns false
+      #   instance.name.equal?(other.name)  # returns true
       def default_value(name, value)
         define_method(name) { |*_| value }
       end
 
+      # @!visibility public
+      # Adds methods that will return a default value
+      #
+      # the value is evaluated on class definition, meaning that
+      # everytime any of them are called they will return the same instance
+      # of value
+      #
+      # @param [::Array<::Symbol,::String>] names Names of the
+      #   methods to be added
+      # @param [::Object] value default value
+      #
+      # @example Defining a default values
+      #   class MyClass
+      #     default_values :name, :nick_name, 'John'
+      #   end
+      #
+      #   MyClass.new.name      # returns 'John'
+      #   MyClass.new.nick_name # returns 'John'
+      #
+      # @example Comparing value across instances
+      #   # frozen_string_literal: false
+      #
+      #   class MyClass
+      #     default_values :name, :nick_name, 'John'
+      #   end
+      #
+      #   instance = MyClass.new
+      #   other = MyClass.new
+      #
+      #   instance.name.equal?('John')     # returns false
+      #   instance.name.equal?(other.name) # returns true
+      #
+      # @example Comparing value across methods
+      #   # frozen_string_literal: false
+      #
+      #   class MyClass
+      #     default_values :name, :nick_name, 'John'
+      #   end
+      #
+      #   instance = MyClass.new
+      #
+      #   instance.nick_name.equal?('John')        # returns false
+      #   instance.nick_name.equal?(instance.name) # returns true
       def default_values(*names, value)
         names.each do |name|
           default_value(name, value)

data/lib/darthjee/core_ext/date.rb

@@ -3,6 +3,28 @@
 module Darthjee
   module CoreExt
     module Date
+      # Calculates the number of days between 2 dates
+      #
+      # @param [::Date,::Time] other_date future/past date for comparisom
+      # @return [::Integer] days between two dates
+      #
+      # @example One year apart date
+      #   date = Date.new(2018, 11, 21)
+      #   other_date = Date.new(2019, 11, 21)
+      #
+      #   date.days_between(other_date)) # returns 365
+      #
+      # @example Four year apart date (having a leap year)
+      #   date = Date.new(2018, 11, 21)
+      #   other_date = Date.new(2014, 11, 21)
+      #
+      #   date.days_between(other_date)) # returns 365 * 4 + 1 = 1461
+      #
+      # @example Checking against time
+      #   date = Date.new(2018, 11, 21)
+      #   time = Time.new(2017, 11, 21, 12, 0, 0)
+      #
+      #   date.days_between(time)) # returns 365
       def days_between(other_date)
         (self - other_date.to_date).abs
       end

data/lib/darthjee/core_ext/enumerable.rb

@@ -5,8 +5,25 @@ module Enumerable
     deep_dup.clean!
   end
 
-  # delete hash or array values if value is nil
-  # ex: { a: nil, b: 2 }.clean! => { b: 2 }
+  # Removes any element that is nil or empty
+  #
+  # @returns [::Enumerable] the enumerable itself
+  #
+  # @example cleaning a Hash
+  #   hash = {
+  #     keep: 'value',
+  #     nil_value: nil,
+  #     empty_array: [],
+  #     empty_string: '',
+  #     empty_hash: {}
+  #   }
+  #   hash.clean! # changes the hash to
+  #               # { keep: 'value' }
+  #
+  # @example cleaning an Array
+  #   array = ['value', nil, [], '', {}]
+  #   array.clean! # changes the array to be
+  #                # ['value']
   def clean!
     if is_a?(Hash)
       delete_if { |_k, v| empty_value?(v) }
@@ -15,6 +32,31 @@ module Enumerable
     end
   end
 
+  # Maps the elements into a new value, returning
+  # the first element that is evaluated to true
+  #
+  # This method is equivalent to #map#find but
+  # only calling the map block up to when a value
+  # is found
+  #
+  # @yield (*args) mappig block
+  #
+  # @example Using an array of keys to remove remove elements of a hash
+  #
+  #   service_map = {
+  #     a: nil,
+  #     b: false,
+  #     c: 'found me',
+  #     d: nil,
+  #     e: 'didnt find me'
+  #   }
+  #
+  #   keys = %i[a b c d e]
+  #
+  #   keys.map_and_find { |key| service_values.delete(key) }
+  #               # returns 'found me'
+  #   service_map # has lost only 3 keys returning
+  #               # { d: nil, e: 'didnt find me' }
   def map_and_find
     mapped = nil
     find do |*args|
@@ -23,6 +65,25 @@ module Enumerable
     mapped || nil
   end
 
+  # Maps the elements into a new value returning an
+  # array of the values mapped to non false values
+  #
+  # This method is equivalent to call #map#select
+  #
+  # @yield (*args) mapping block
+  #
+  # @example Mapping the values of hash to their size
+  #   hash = {
+  #     a: nil,
+  #     b: 'aka',
+  #     c: 'a'
+  #   }
+  #
+  #   values = hash.map_and_select do |key, value|
+  #     value && value.to_s
+  #   end
+  #
+  #   values # returns [3, 1]
   def map_and_select
     mapped = map do |*args|
       yield(*args)
@@ -30,6 +91,15 @@ module Enumerable
     mapped.select { |e| e }
   end
 
+  # Maps values and creates a hash whose values are
+  # the result of the #map and the keys are the original values
+  #
+  # @yield (*args) the mapping block
+  #
+  # @example Mapping strings to their sizes
+  #   strings =  %w[word big_word]
+  #
+  #   strings.map_to_hash(&:size) # returns { 'word' => 4, 'big_word' => 8 }
   def map_to_hash
     {}.tap do |hash|
       each do |element|

data/lib/darthjee/core_ext/hash/transformable.rb

@@ -4,24 +4,132 @@ module Darthjee
   module CoreExt
     module Hash
       module Transformable
-        def squash
-          Hash::Squasher.squash(self)
+        # Merges both hashes not adding keys that don't
+        # exist in the original hash
+        #
+        # @param [::Hash] other other hash to be merged
+        #
+        # @return [::Hash] the merged hash
+        #
+        # @example merging of hashes with some clashing keys
+        #   hash = { a: 1, b: 2, c: 3 }
+        #   other = { b: 4, 'c' => 5, e: 6 }
+        #
+        #   hash.exclusive_merge(other) # returns { a: 1, b: 4, c: 3 }
+        #   hash                        # returns { a: 1, b: 2, c: 3 }
+        def exclusive_merge(other)
+          dup.exclusive_merge!(other)
         end
 
-        def to_deep_hash(separator = '.')
-          Hash::DeepHashConstructor.new(separator).deep_hash(self)
+        # Merges both hashes not adding keys that don't
+        # exist in the original hash
+        #
+        # @param [::Hash] other other hash to be merged
+        #
+        # @return [::Hash] the merged hash
+        #
+        # @example merging of hashes with some clashing keys
+        #   hash = { a: 1, b: 2, c: 3 }
+        #   other = { b: 4, 'c' => 5, e: 6 }
+        #
+        #   hash.exclusive_merge!(other) # returns { a: 1, b: 4, c: 3 }
+        #   hash                         # returns { a: 1, b: 4, c: 3 }
+        def exclusive_merge!(other)
+          merge!(other.slice(*keys))
         end
 
+        # Run map block where each pair key, value is mapped
+        # to a new value to be assigned in the same key on the
+        # returned hash
+        #
+        # @return new Hash made with the pairs key => mapped_value
+        #
+        # @yield (key, value) block returning the new value
+        #
+        # @see ToHashMapper
+        #
+        # @example mapping to size of the original words
+        #   hash = { a: 'word', b: 'bigword', c: 'c' }
+        #
+        #   new_hash = hash.map_to_hash do |key, value|
+        #     "#{key}->#{value.size}"
+        #   end
+        #
+        #   new_hash # returns { a: 'a->4', b: 'b->7', c: 'c->1' }
         def map_to_hash(&block)
           Hash::ToHashMapper.new(self).map(&block)
         end
 
-        def exclusive_merge(hash)
-          dup.exclusive_merge!(hash)
+        # Squash the hash so that it becomes a single level hash
+        # merging the keys of outter and inner hashes
+        #
+        # This operation is the oposite of {#to_deep_hash}
+        #
+        # @return [::Hash] A one level hash
+        #
+        # @see Squash::Builder
+        # @see #to_deep_hash
+        #
+        # @example a name hash
+        #   hash = { name: { first: 'John', last: 'Doe' } }
+        #
+        #   hash.squash # returns {
+        #               #   'name.first' => 'John',
+        #               #   'name.last'  => 'Doe'
+        #               # }
+        #
+        # @example Reverting a #to_deep_hash call
+        #   person_data = {
+        #     'person.name' => 'John',
+        #     'person.age' => 23
+        #   }
+        #   person = person_data.to_deep_hash
+        #
+        #   person.squash # returns {
+        #                 #   'person.name' => 'John',
+        #                 #   'person.age' => 23
+        #                 # }
+        def squash
+          Hash::Squasher.squash(self)
         end
 
-        def exclusive_merge!(hash)
-          merge!(hash.slice(*keys))
+        # Creates a new hash of multiple levels from a one level
+        # hash
+        #
+        # this operation is the oposite from {#squash}
+        #
+        # @return [::Hash] A multi-level hash
+        #
+        # @see Hash::DeepHashConstructor
+        # @see #squash
+        #
+        # @example construction of name hash
+        #   { 'name_first' => 'John', 'name_last' => 'Doe' }
+        #
+        #   hash.to_deep_hash # return {
+        #                     #   'name' => {
+        #                     #     'first' => 'John',
+        #                     #     'last' => 'Doe'
+        #                     #   }
+        #                     # }
+        # @example Reverting squash
+        #   person = {
+        #     'person' => {
+        #       'name' => 'John',
+        #       'age' => 23
+        #     }
+        #   }
+        #   person_data = person.squash
+        #
+        #   person_data.to_deep_hash
+        #   # returns {
+        #   #   'person' => {
+        #   #     'name' => 'John',
+        #   #     'age' => 23
+        #   #   }
+        #   # }
+        def to_deep_hash(separator = '.')
+          Hash::DeepHashConstructor.new(separator).deep_hash(self)
         end
       end
     end

data/lib/darthjee/core_ext/version.rb

@@ -2,6 +2,6 @@
 
 module Darthjee
   module CoreExt
-    VERSION = '1.7.0'
+    VERSION = '1.7.1'
   end
 end

data/spec/integration/yard/array/hash_builder_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Array::HashBuilder do
+  describe 'yard' do
+    describe '#build' do
+      subject { described_class.new(values, keys) }
+
+      let(:values) { [10, 20, 30] }
+      let(:keys)   { %i[a b c] }
+
+      it 'builds a hash pairing the keys and values' do
+        expect(subject.build).to eq(
+          a: 10, b: 20, c: 30
+        )
+      end
+
+      context 'when trying to rebuild a hash' do
+        let(:hash)   { { a: 20, b: 200, c: 2000 } }
+        let(:values) { hash.values }
+        let(:keys)   { hash.keys }
+
+        it 'rebuilds the original hash' do
+          expect(subject.build).to eq(hash)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/array_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Array do
+  describe 'yard' do
+    describe '#mapk' do
+      let(:array) { [{ a: { b: 1 }, b: 2 }, { a: { b: 3 }, b: 4 }] }
+
+      describe 'when passing just the first key' do
+        it 'returns the array mapped ' do
+          expect(array.mapk(:a)).to eq([{ b: 1 }, { b: 3 }])
+        end
+      end
+
+      describe 'when passing a second key' do
+        it 'chain fetches the key' do
+          expect(array.mapk(:a, :b)).to eq([1, 3])
+        end
+      end
+
+      describe 'when fetching a non existing key' do
+        it 'returns nil for value' do
+          expect(array.mapk(:c)).to eq([nil, nil])
+        end
+      end
+
+      describe 'when element is not a hash' do
+        it 'returns nil for value' do
+          expect(array.mapk(:c, :d)).to eq([nil, nil])
+        end
+      end
+    end
+
+    describe '#procedural_join' do
+      let(:array) { [1, 2, -3, -4, 5] }
+
+      context 'when not mapping the value' do
+        context 'when creating a sum' do
+          let(:result) do
+            array.procedural_join do |_previous, nexte|
+              nexte.positive? ? '+' : ''
+            end
+          end
+
+          it 'creates a sum' do
+            expect(result).to eq('1+2-3-4+5')
+          end
+        end
+      end
+
+      context 'when mapping the value' do
+        let(:result) do
+          mapper = proc { |value| value.to_f.to_s }
+          array.procedural_join(mapper) do |_previous, nexte|
+            nexte.positive? ? ' +' : ' '
+          end
+        end
+
+        it 'maps the value on the output' do
+          expect(result).to eq('1.0 +2.0 -3.0 -4.0 +5.0')
+        end
+      end
+    end
+
+    describe '#chain_main' do
+      let(:words) { %w[big_word tiny oh_my_god_such_a_big_word] }
+
+      context 'when not passing a block' do
+        let(:words) { %w[big_word tiny oh_my_god_such_a_big_word] }
+
+        it 'calls the methods in a succession to map' do
+          output = words.chain_map(:size, :to_f, :to_s)
+          expect(output).to eq(%w[8.0 4.0 25.0])
+        end
+      end
+
+      context 'when passing a block' do
+        it 'mapps with the block at the end' do
+          output = words.chain_map(:size) do |size|
+            (size % 2).zero? ? 'even size' : 'odd size'
+          end
+          expect(output).to eq(['even size', 'even size', 'odd size'])
+        end
+      end
+    end
+
+    describe '#as_hash' do
+      let(:array) { %w[each word one key] }
+      let(:keys)  { %i[a b c d] }
+
+      it 'Uses the keys arra as keys of the hash' do
+        expect(array.as_hash(keys)).to eq(
+          a: 'each', b: 'word', c: 'one', d: 'key'
+        )
+      end
+    end
+
+    describe '#random' do
+      let(:array) { [10, 20, 30] }
+
+      it 'returns an element of the array' do
+        expect(array).to include(array.random)
+      end
+
+      it do
+        expect { array.random }.not_to(change { array })
+      end
+    end
+
+    describe '#random!' do
+      let(:array) { [10, 20, 30] }
+
+      it 'returns an element of the array' do
+        expect(array.dup).to include(array.random!)
+      end
+
+      it do
+        expect { array.random! }.to(change { array })
+      end
+    end
+  end
+end

data/spec/integration/yard/class/default_value_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe Class do
+  describe 'yard' do
+    describe '#default_value' do
+      subject { klass.new }
+
+      let(:klass) do
+        Class.new do
+          default_value :name, 'John'
+        end
+      end
+
+      context 'when calling method' do
+        it 'returns the same value always' do
+          expect(subject.name).to eq('John')
+        end
+
+        it 'returns the same instance accros instances of the class' do
+          expect(subject.name).not_to be_equal('John')
+          expect(subject.name).to be_equal(klass.new.name)
+        end
+      end
+    end
+
+    describe '#default_values' do
+      subject { klass.new }
+
+      let(:klass) do
+        Class.new do
+          default_values :name, :nick_name, 'John'
+        end
+      end
+
+      context 'when calling method' do
+        it 'returns the same value always' do
+          expect(subject.name).to eq('John')
+        end
+
+        it 'returns the same value always' do
+          expect(subject.nick_name).to eq('John')
+        end
+
+        it 'returns the same instance accros instances of the class' do
+          expect(subject.name).not_to be_equal('John')
+          expect(subject.name).to be_equal(klass.new.name)
+        end
+
+        it 'returns the same instance for all methods' do
+          expect(subject.nick_name).not_to be_equal('John')
+          expect(subject.name).to be_equal(subject.nick_name)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/date/days_between_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Date do
+  describe 'yard' do
+    describe '#days_between' do
+      subject { Date.new(2018, 11, 21) }
+
+      context 'when checking against another date' do
+        let(:other_date) { Date.new(2019, 11, 21) }
+
+        it 'returns the days between' do
+          expect(subject.days_between(other_date)).to eq(365)
+        end
+      end
+
+      context 'when cheking agains a 4 years apart date' do
+        let(:other_date) { Date.new(2014, 11, 21) }
+
+        it 'returns the days between' do
+          expect(subject.days_between(other_date)).to eq(1461)
+        end
+      end
+
+      context 'when checking against time' do
+        let(:time) { Time.new(2017, 11, 21, 12, 0, 0) }
+
+        it 'ignores the hours' do
+          expect(subject.days_between(time)).to eq(365)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/enumerable_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Enumerable do
+  describe 'yard' do
+    describe '#clean!' do
+      context 'when subject is a hash' do
+        subject(:hash) do
+          {
+            keep: 'value',
+            nil_value: nil,
+            empty_array: [],
+            empty_string: '',
+            empty_hash: {}
+          }
+        end
+
+        it 'removes empty values' do
+          expect { hash.clean! }.to change { hash }.to(keep: 'value')
+        end
+      end
+
+      context 'when subject is an array' do
+        subject(:array) do
+          ['value', nil, [], '', {}]
+        end
+
+        it 'removes empty values' do
+          expect { array.clean! }.to change { array }.to(['value'])
+        end
+      end
+    end
+
+    describe '#map_and_find' do
+      subject(:keys) { %i[a b c d e] }
+
+      let(:service_values) do
+        {
+          a: nil,
+          b: false,
+          c: 'found me',
+          d: nil,
+          e: 'didnt find me'
+        }
+      end
+
+      it 'returns the first non false value' do
+        value = keys.map_and_find { |key| service_values.delete(key) }
+        expect(value).to eq('found me')
+      end
+
+      it 'stops running when value is found' do
+        expect do
+          keys.map_and_find { |key| service_values.delete(key) }
+        end.to change { service_values }.to(d: nil, e: 'didnt find me')
+      end
+    end
+
+    describe '#map_and_select' do
+      subject(:hash) do
+        {
+          a: nil,
+          b: 'aka',
+          c: 'a'
+        }
+      end
+
+      it 'returns the first non false value' do
+        array = hash.map_and_select { |_key, value| value&.size }
+        expect(array).to eq([3, 1])
+      end
+    end
+
+    describe 'map_to_hash' do
+      subject(:strings) { %w[word big_word] }
+
+      it 'returns a hash with the mapped values' do
+        hash = strings.map_to_hash(&:size)
+        expect(hash).to eq('word' => 4, 'big_word' => 8)
+      end
+    end
+  end
+end

data/spec/integration/yard/hash/transformable_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Hash do
+  describe 'yard' do
+    describe '#exclusive_merge' do
+      subject(:hash) { { a: 1, b: 2, c: 3 } }
+      let(:other)    { { b: 4, 'c' => 5, e: 6 } }
+
+      it 'merges only the existing keys' do
+        expect(hash.exclusive_merge(other)).to eq(a: 1, b: 4, c: 3)
+      end
+
+      it 'does not change original hash' do
+        expect do
+          hash.exclusive_merge(other)
+        end.not_to(change { hash })
+      end
+    end
+
+    describe '#exclusive_merge' do
+      subject(:hash) { { a: 1, b: 2, c: 3 } }
+      let(:other)    { { b: 4, 'c' => 5, e: 6 } }
+
+      it 'merges only the existing keys' do
+        expect(hash.exclusive_merge!(other)).to eq(a: 1, b: 4, c: 3)
+      end
+
+      it 'does not change original hash' do
+        expect do
+          hash.exclusive_merge!(other)
+        end.to change { hash }.to(a: 1, b: 4, c: 3)
+      end
+    end
+  end
+
+  describe '#map_to_hash' do
+    subject(:hash) { { a: 'word', b: 'bigword', c: 'c' } }
+
+    it 'remaps the values keeping the original keys' do
+      new_hash = hash.map_to_hash do |key, value|
+        "#{key}->#{value.size}"
+      end
+
+      expect(new_hash).to eq(
+        a: 'a->4',
+        b: 'b->7',
+        c: 'c->1'
+      )
+    end
+  end
+
+  describe '#squash' do
+    subject(:hash) { { name: { first: 'John', last: 'Doe' } } }
+
+    it 'squash the hash into a one level hash' do
+      expect(hash.squash).to eq('name.first' => 'John', 'name.last' => 'Doe')
+    end
+
+    context 'when squashing the result of a deep hash' do
+      let(:person_data) { { 'person.name' => 'John', 'person.age' => 23 } }
+      let(:person) { person_data.to_deep_hash }
+
+      it 'is the reverse operation' do
+        expect(person.squash).to eq(person_data)
+      end
+    end
+  end
+
+  describe '#to_deep_hash' do
+    subject(:hash) { { 'name_first' => 'John', 'name_last' => 'Doe' } }
+
+    it 'with custom separator' do
+      expect(hash.to_deep_hash('_')).to eq(
+        'name' => { 'first' => 'John', 'last' => 'Doe' }
+      )
+    end
+
+    context 'when squashing the result of a deep hash' do
+      let(:person) do
+        {
+          'person' => {
+            'name' => 'John',
+            'age' => 23
+          }
+        }
+      end
+      let(:person_data) { person.squash }
+
+      it 'is the reverse operation' do
+        expect(person_data.to_deep_hash).to eq(person)
+      end
+    end
+  end
+end

data/spec/lib/array_spec.rb

@@ -11,6 +11,18 @@ describe Array do
     it 'maps using the keys given as arguments' do
       expect(array.mapk(:a, :b)).to eq([1, 3])
     end
+
+    describe 'when fetching a non existing key' do
+      it 'returns nil for value' do
+        expect(array.mapk(:c)).to eq([nil, nil])
+      end
+    end
+
+    describe 'when element is not a hash' do
+      it do
+        expect(array.mapk(:c, :d)).to eq([nil, nil])
+      end
+    end
   end
 
   describe '#procedural_join' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: darthjee-core_ext
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-06 00:00:00.000000000 Z
+date: 2018-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -84,14 +84,14 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.58.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.58.1
 - !ruby/object:Gem::Dependency
@@ -172,6 +172,12 @@ files:
 - lib/darthjee/core_ext/time.rb
 - lib/darthjee/core_ext/version.rb
 - mech.jpg
+- spec/integration/yard/array/hash_builder_spec.rb
+- spec/integration/yard/array_spec.rb
+- spec/integration/yard/class/default_value_spec.rb
+- spec/integration/yard/date/days_between_spec.rb
+- spec/integration/yard/enumerable_spec.rb
+- spec/integration/yard/hash/transformable_spec.rb
 - spec/lib/array_spec.rb
 - spec/lib/class_spec.rb
 - spec/lib/darthjee/core_ext/hash/chain_fetcher_spec.rb
@@ -232,6 +238,12 @@ signing_key:
 specification_version: 4
 summary: Core Extensions
 test_files:
+- spec/integration/yard/array/hash_builder_spec.rb
+- spec/integration/yard/array_spec.rb
+- spec/integration/yard/class/default_value_spec.rb
+- spec/integration/yard/date/days_between_spec.rb
+- spec/integration/yard/enumerable_spec.rb
+- spec/integration/yard/hash/transformable_spec.rb
 - spec/lib/array_spec.rb
 - spec/lib/class_spec.rb
 - spec/lib/darthjee/core_ext/hash/chain_fetcher_spec.rb