darthjee-core_ext 1.2.6 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d36ee33e60a4897dde6c91aa95e63d8644253493
-  data.tar.gz: e5f8f6d6ff67007a00486e40fa6dc72b472241f1
+  metadata.gz: e119db2a6c2d8eb97f42b48b82500d93f81665fb
+  data.tar.gz: 9fa9cbda6ad8a1feef1f57eb917df0b0391d8a52
 SHA512:
-  metadata.gz: 0d0dea263e737fb1838163f640681dcba2f7cee1b9ddedcc6518d0aa68cf95c8b6a0e6f227508174b997a58f79b79ecd095debf8f16e6496d731bc7a648743de
-  data.tar.gz: '03768926ec5377779a98c52326f93cf7e0bacee374b7be6228e01fdaf56cf342ac80bb1aad6a624ec2394cfbff38af90c225068672a46be81dcf3d625098baf5'
+  metadata.gz: 4f904ea861ca6e47029632718356f0802d4f828bb4343ea5fd14db142406a6ec95c4462c28b2010bab2eb410af6b71539a08e87e34ec5cc849062239f8f05529
+  data.tar.gz: 90afdb065d5f08e91ee76927ff2487d0f848ae903af8c036f42ac89e318a1b34b2b24f2343165b2aff9059197a6a066012763252159028642e57518a7039af8f

data/ARRAY_README.md

@@ -0,0 +1,35 @@
+## Array
+### #map_to_hash
+map returning a hash with the original array for keys
+
+```ruby
+array = %w(a ab)
+arrays.map_to_hash { |val| val.length }
+{ 'a' => 1, 'b' => 2 }
+```
+
+### #chain_map
+applies map in a chain
+
+```ruby
+array = [ :a, :long_name, :sym ]
+array.chain_map(:to_s, :size, :to_s)
+[ '1', '9', '3' ]
+```
+
+```ruby
+array = [ :a, :long_name, :sym ]
+array.chain_map(:to_s, :size) { |v| "final: #{v}" }
+[ 'final: 1', 'final: 9', 'final: 3' ]
+```
+
+### #as_hash
+Creates a hash from the array using the argumen array as keys
+
+```ruby
+  [1, 2, 3].as_hash %w(a b c)
+```
+returns
+```ruby
+  { 'a' => 1, 'b' => 2, 'c' => 3 } }
+```

data/ENUMERABLE_README.md

@@ -0,0 +1,12 @@
+## Enumerable
+
+### #clean!
+Cleans empty values from a hash
+```ruby
+{ a: 1, b: [], c: nil, d: {}, e: '', f: { b: [], c: nil, d: {}, e: '' } }.clean!
+```
+returns
+```ruby
+  {}
+```
+

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    darthjee-core_ext (1.2.6)
+    darthjee-core_ext (1.3.0)
       activesupport (~> 5.1.1)
 
 GEM

data/HASH_README.md

@@ -0,0 +1,252 @@
+## Hash
+### #map_to_hash
+map returning a hash with the original keys
+
+```ruby
+hash = { a: 1, b: 2 }
+hash.map_to_hash { |k, v| "#{k}_#{v}" }
+{ a: "a_1", b: "b_2" }
+```
+
+### #chain_fetch
+Applies fetch in a chain
+
+```ruby
+{ a: { b: { c: { d: 10 } } } }.chain_fetch(:a, :b, :c, :d)
+10
+```
+
+A block can be passed so that when a key is not found, the block will define the value to be returned
+
+```ruby
+h = { a: { b: { c: { d: 10 } } } }
+h.chain_fetch(:a, :x, :y, :z) { |key, missed_keys| "returned #{key}" }
+'returned x'
+```
+
+### #squash
+Squash a deep hash into a simple level hash
+
+```ruby
+  { a: { b:1 } }.squash
+```
+returns
+```ruby
+  { 'a.b' => 1 }
+```
+
+### #to_deep_hash
+Changes a hash spliting keys into inner hashs
+
+```ruby
+  { 'a.b' => 1 }.to_deep_hash
+```
+returns
+```ruby
+  { 'a' => { 'b' => 1 } }
+```
+
+### #change_keys
+Change the array keys using a block accepting parameters:
+ - recursive: when true, does it recursivly through inner arrays (default: true)
+
+```ruby
+  { ca_b: 1, k: [{ a_b: 1 }] }.change_keys { |k| k.to_s.upcase }
+```
+returns
+```ruby
+  {"CA_B"=>1, "K"=>[{"A_B"=>1}]}
+```
+
+```ruby
+  { ca_b: 1, k: [{ a_b: 1 }] }.change_keys(recursive: false) { |k| k.to_s.upcase }
+```
+returns
+```ruby
+  {"CA_B"=>1, "K"=>[{:a_b=>1}]}
+```
+
+### #chain_change_keys
+Change the hash keys usin a chained method call
+
+```ruby
+  { ca_b: 1 }.chain_change_keys(:to_s, :upcase, :to_sym)
+```
+returns
+```ruby
+  { CA_B: 1 }
+```
+
+### #camelize_keys
+Change the keys camelizing them and accepting parameters:
+- uppercase_first_letter: Use the java or javascript format (default: true)
+- recursive: when true, does it recursivly through inner arrays (default: true)
+
+```ruby
+  { ca_b: 1, k: [{ a_b: 1 }] }.camelize_keys
+```
+returns
+```ruby
+  {:CaB=>1, :K=>[{:AB=>1}]}
+```
+
+```ruby
+  { ca_b: 1, k: [{ a_b: 1 }] }.camelize_keys(recursive: false)
+```
+returns
+```ruby
+  {:CaB=>1, :K=>[{:a_b=>1}]}
+```
+
+```ruby
+  { ca_b: 1, k: [{ a_b: 1 }] }.camelize_keys(uppercase_first_letter: false)
+```
+returns
+```ruby
+  {:caB=>1, :k=>[{:aB=>1}]}
+```
+
+### #lower_camelize_keys
+Alias for [#camelize_keys](camelize_keys)(uppercase_first_letter: false)
+
+```ruby
+  { ca_b: 1, k: [{ a_b: 1 }] }.lower_camelize_keys
+```
+returns
+```ruby
+  {:caB=>1, :k=>[{:aB=>1}]}
+```
+
+### #underscore_keys
+Change the keys from camelcase to snakecase (underscore)
+ - recursive: when true, does it recursivly through inner arrays (default: true)
+
+```ruby
+  { Ca_B: 1, 'kB' => [{ KeysHash: 1 }] }.underscore_keys
+```
+returns
+```ruby
+{ca_b: 1, "k_b"=>[{keys_hash: 1}]}
+```
+
+### #change_values
+Change the values of the array accepting parametes:
+ - recursive: when true, does it recursivly through inner arrays and hashes (default: true)
+ - skip_inner: when true, do not call the block for iterators such as Hash and Arrays (default: true)
+
+```ruby
+  { a: 1, b: [{ c: 2 }] }.change_values { |v| (v+1).to_s }
+```
+returns
+```ruby
+  { a: '2' b: [{ c: '3' }] }
+```
+
+```ruby
+  { a: 1, b: [{ c: 2 }] }.change_values(recursive: false) { |v| (v+1).to_s }
+```
+returns
+```ruby
+  { a: '2' b: [{ c: 2 }] }
+```
+
+```ruby
+  { a: 1, b: [{ c: 2 }] }.change_values(skip_inner: false) do |v|
+    v.is_a?(Integer) ? (v+1).to_s : v.class
+  end
+```
+returns
+```ruby
+  { a: '2' b: Array }
+```
+
+### #prepend_to_keys
+Change each keys prepending an string
+
+```ruby
+  { key: 1 }.prepend_to_keys 'scope:'
+```
+returns
+```ruby
+  { :'scope:key' => 1 }
+```
+### #append_to_keys
+Change each keys appending an string
+
+```ruby
+  { key: 1 }.append_to_keys 's'
+```
+returns
+```ruby
+  { keys: 1 }
+```
+
+### #sort_keys
+Sort the hash usig the keys
+
+```ruby
+  { b:1, a:2 }.sort_keys
+```
+returns
+```ruby
+  { a:2, b:1 }
+```
+
+### #map_to_hash
+map returning a hash with the original keys for keys
+
+```ruby
+hash = { a: 1, b: 2 }
+hash.map_to_hash { |k, v| "#{k}_#{v}" }
+{ a: 'a_1', b: 'b_2' }
+```
+
+### #remap_keys
+Changes the keys of the hash based on a map of { old: new } value
+
+```ruby
+hash = { a: 1, b: 2 }
+hash.remap_keys(a: :c, d: :e)
+{ c: 1, b: 2, e: nil }
+```
+
+### #exclusive_merge
+Like #merge but only for existing keys
+
+```ruby
+{ a: 1, b: 2 }.exclusive_merge(b: 3, c: 4)
+{ a: 1, b: 3 }
+```
+
+### #clean
+Cleans empty values from a hash
+```ruby
+{ a: 1, b: [], c: nil, d: {}, e: '', f: { b: [], c: nil, d: {}, e: '' } }.clean
+```
+returns
+```ruby
+  {}
+```
+
+### #map_and_find
+Operates like map, but will stop as soon as a non false value is found returning the value found
+
+```ruby
+class Ob
+  attr_reader :v
+  def initialize(v = nil)
+    @v = v
+  end
+end
+hash = { a: Ob.new, b: Ob.new(false), c: Ob.new(1), d: Ob.new(3) }
+```
+
+```ruby
+hash.map_and_find { |k,o| o.v }
+1
+```
+
+```ruby
+hash.map_and_find { |k,o| o.v && k }
+:c
+```

data/README.md

@@ -1,6 +1,7 @@
 Core_Ext
 ========
 
+# Usage
 This project adds some new methods to the core ruby classes
 
 To use core-ext either intall directly
@@ -9,180 +10,21 @@ To use core-ext either intall directly
 gem install darthjee-core_ext
 ```
 
+or add it to Gemfile
+
 ```
-gem 'danica'
+gem 'darthjee-core_ext'
 ```
 
 ```console
-bundle install danica
+bundle install darthjee-core_ext
 ```
 
+#methods added
 
 ## Array
-### map_to_hash
-map returning a hash with the original array for keys
-
-```ruby
-array = %w(a ab)
-arrays.map_to_hash { |val| val.length }
-{ 'a' => 1, 'b' => 2 }
-```
-
-### chain_map
-applies map in a chain
-
-```ruby
-array = [ :a, :long_name, :sym ]
-array.chain_map(:to_s, :size, :to_s)
-[ '1', '9', '3' ]
-```
-
-```ruby
-array = [ :a, :long_name, :sym ]
-array.chain_map(:to_s, :size) { |v| "final: #{v}" }
-[ 'final: 1', 'final: 9', 'final: 3' ]
-```
-
-### as_hash
-Creates a hash from the array using the argumen array as keys
-
-```ruby
-  [1, 2, 3].as_hash %w(a b c)
-```
-returns
-```ruby
-  { 'a' => 1, 'b' => 2, 'c' => 3 } }
-```
-
+[ARRAY_README.md](ARRAY_README.md)
 ## Hash
-### map_to_hash
-map returning a hash with the original keys
-
-```ruby
-hash = { a: 1, b: 2 }
-hash.map_to_hash { |k, v| "#{k}_#{v}" }
-{ a: "a_1", b: "b_2" }
-```
-
-### chain_fetch
-Applies fetch in a chain
-
-```ruby
-{ a: { b: { c: { d: 10 } } } }.chain_fetch(:a, :b, :c, :d)
-10
-```
-```ruby
-h = { a: { b: { c: { d: 10 } } } }
-h.chain_fetch(:a, :x, :y, :z) { |key, missed_keys| "returned #{key}" }
-'returned x'
-```
-
-### squash
-Squash a deep hash into a simple level hash
-
-```ruby
-  { a: { b:1 } }.squash
-```
-returns
-```ruby
-  { 'a.b' => 1 }
-```
-
-### to_deep_hash
-Changes a hash spliting keys into inner hashs
-
-```ruby
-  { 'a.b' => 1 }.to_deep_hash
-```
-returns
-```ruby
-  { 'a' => { 'b' => 1 } }
-```
-
-### camelize_keys
-Change the keys camelizing them
-
-```ruby
-  { ca_b: 1 }.camelize_keys
-```
-returns
-```ruby
-  { CaB: 1 }
-```
-
-### change_keys
-Change the array keys using a block
-
-```ruby
-  { ca_b: 1 }.change_keys { |k| k.to_s.upcase }
-```
-returns
-```ruby
-  { 'CA_B' => 1 }
-```
-
-### chain_change_keys
-Change the hash keys usin a chained method call
-
-```ruby
-  { ca_b: 1 }.chain_change_keys(:to_s, :upcase, :to_sym)
-```
-returns
-```ruby
-  { CA_B: 1 }
-```
-
-### change_values
-Change the values of the array
-```ruby
-  { a: 1 }.change_keys { |v| (v+1).to_s }
-```
-returns
-```ruby
-  { a: '2' }
-```
-
-### prepend_to_keys
-Change each keys prepending an string
-
-```ruby
-  { key: 1 }.prepend_to_keys 'scope:'
-```
-returns
-```ruby
-  { :'scope:key' => 1 }
-```
-### append_to_keys
-Change each keys appending an string
-
-```ruby
-  { key: 1 }.append_to_keys 's'
-```
-returns
-```ruby
-  { keys: 1 }
-```
-
-### sort_keys
-Sort the hash usig the keys
-
-```ruby
-  { b:1, a:2 }.sort_keys
-```
-returns
-```ruby
-  { a:2, b:1 }
-```
-
+[HASH_README.md](HASH_README.md)
 ## Enumerable
-
-## clean!
-CLeans empty values from a hash
-```ruby
-{ a: 1, b: [], c: nil, d: {}, e: '', f: { b: [], c: nil, d: {}, e: '' } }.clean!
-```
-returns
-```ruby
-  {}
-```
-
+[ENUMERABLE_README.md](ENUMERABLE_README.md)

data/lib/darthjee/core_ext/version.rb

@@ -1,5 +1,5 @@
 module Darthjee
   module CoreExt
-    VERSION = '1.2.6'
+    VERSION = '1.3.0'
   end
 end

data/spec/lib/array_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Array do
+  it_behaves_like 'an array with map_to_hash method'
+
   describe '#chain_map' do
     let(:array) { [ :a, :long_name, :sym ] }
     let(:mapped) { array.chain_map(:to_s, :size, :to_s) }
@@ -145,85 +147,4 @@ describe Array do
       end
     end
   end
-
-  describe '#map_to_hash' do
-    context 'whe subject is an array' do
-      let(:subject) { %w(word1 wooord2) }
-      let(:mapping_block) { proc{ |word| word.length } }
-      let(:mapped) { subject.map_to_hash(&mapping_block) }
-      let(:expected) { { 'word1' => 5, 'wooord2' => 7 } }
-
-      it { expect(mapped).to be_a(Hash) }
-
-      it 'has the original array as keys' do
-        expect(mapped.keys).to eq(subject)
-      end
-
-      it 'has the mapped values as values' do
-        expect(mapped.values).to eq(subject.map(&mapping_block))
-      end
-
-      it 'correctly map keys to value' do
-        expect(mapped).to eq(expected)
-      end
-
-      context 'whe subject is an array' do
-        let(:subject) { [%w(w1), %w(w2 w3)] }
-        let(:mapped) { subject.map_to_hash(&mapping_block) }
-        let(:expected) { { %w(w1) => 1, %w(w2 w3) => 2 } }
-
-
-        it 'has the original array as keys' do
-          expect(mapped.keys).to eq(subject)
-        end
-
-        it 'has the mapped values as values' do
-          expect(mapped.values).to eq(subject.map(&mapping_block))
-        end
-
-        it 'correctly map keys to value' do
-          expect(mapped).to eq(expected)
-        end
-      end
-    end
-
-    context 'whe subject is a hash' do
-      let(:subject) { { a: 1, b: 2 } }
-      let(:mapping_block) { proc{ |k, v| "#{k}_#{v}" } }
-      let(:mapped) { subject.map_to_hash(&mapping_block) }
-      let(:expected) { { a: 'a_1', b: 'b_2' } }
-
-      it { expect(mapped).to be_a(Hash) }
-
-      it 'has the original keys as keys' do
-        expect(mapped.keys).to eq(subject.keys)
-      end
-
-      it 'has the mapped values as values' do
-        expect(mapped.values).to eq(subject.map(&mapping_block))
-      end
-
-      it 'correctly map keys to value' do
-        expect(mapped).to eq(expected)
-      end
-
-      context 'when hash uses arrays for keys' do
-        let(:subject) { { [:a, :b] => 1, [:c, :d] => 2 } }
-        let(:mapping_block) { proc{ |k, v| "#{k.join('_')}_#{v}" } }
-        let(:expected) { { [:a, :b]=> 'a_b_1', [:c, :d] => 'c_d_2' } }
-
-        it 'has the original keys as keys' do
-          expect(mapped.keys).to eq(subject.keys)
-        end
-
-        it 'has the mapped values as values' do
-          expect(mapped.values).to eq(subject.map(&mapping_block))
-        end
-
-        it 'correctly map keys to value' do
-          expect(mapped).to eq(expected)
-        end
-      end
-    end
-  end
 end

data/spec/lib/hash_spec.rb

@@ -9,6 +9,7 @@ describe Hash do
   it_behaves_like 'a class with change_values method'
   it_behaves_like 'a class with remap method'
   it_behaves_like 'an object with chain_fetch method'
+  it_behaves_like 'a hash with map_to_hash method'
 
   describe :squash do
     let(:hash) { { a: { b: 1, c: { d: 2 } } } }

data/spec/support/shared_examples/map_to_hash.rb

@@ -0,0 +1,86 @@
+shared_examples 'an array with map_to_hash method' do
+  describe '#map_to_hash' do
+    let(:subject) { %w(word1 wooord2) }
+    let(:mapping_block) { proc{ |word| word.length } }
+    let(:mapped) { subject.map_to_hash(&mapping_block) }
+    let(:expected) { { 'word1' => 5, 'wooord2' => 7 } }
+
+    it { expect(mapped).to be_a(Hash) }
+
+    it 'has the original array as keys' do
+      expect(mapped.keys).to eq(subject)
+    end
+
+    it 'has the mapped values as values' do
+      expect(mapped.values).to eq(subject.map(&mapping_block))
+    end
+
+    it 'correctly map keys to value' do
+      expect(mapped).to eq(expected)
+    end
+
+    context 'whe subject is an array' do
+      let(:subject) { [%w(w1), %w(w2 w3)] }
+      let(:mapped) { subject.map_to_hash(&mapping_block) }
+      let(:expected) { { %w(w1) => 1, %w(w2 w3) => 2 } }
+
+
+      it 'has the original array as keys' do
+        expect(mapped.keys).to eq(subject)
+      end
+
+      it 'has the mapped values as values' do
+        expect(mapped.values).to eq(subject.map(&mapping_block))
+      end
+
+      it 'correctly map keys to value' do
+        expect(mapped).to eq(expected)
+      end
+    end
+  end
+end
+
+shared_examples 'a hash with map_to_hash method' do
+  describe '#map_to_hash' do
+    let(:subject) { { a: 1, b: 2 } }
+    let(:mapping_block) { proc{ |k, v| "#{k}_#{v}" } }
+    let(:mapped) { subject.map_to_hash(&mapping_block) }
+    let(:expected) { { a: 'a_1', b: 'b_2' } }
+
+    it { expect(mapped).to be_a(Hash) }
+
+    it do
+      expect { subject.map_to_hash(&mapping_block) }.not_to change { subject }
+    end
+
+    it 'has the original keys as keys' do
+      expect(mapped.keys).to eq(subject.keys)
+    end
+
+    it 'has the mapped values as values' do
+      expect(mapped.values).to eq(subject.map(&mapping_block))
+    end
+
+    it 'correctly map keys to value' do
+      expect(mapped).to eq(expected)
+    end
+
+    context 'when hash uses arrays for keys' do
+      let(:subject) { { [:a, :b] => 1, [:c, :d] => 2 } }
+      let(:mapping_block) { proc{ |k, v| "#{k.join('_')}_#{v}" } }
+      let(:expected) { { [:a, :b]=> 'a_b_1', [:c, :d] => 'c_d_2' } }
+
+      it 'has the original keys as keys' do
+        expect(mapped.keys).to eq(subject.keys)
+      end
+
+      it 'has the mapped values as values' do
+        expect(mapped.values).to eq(subject.map(&mapping_block))
+      end
+
+      it 'correctly map keys to value' do
+        expect(mapped).to eq(expected)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: darthjee-core_ext
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.3.0
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-08 00:00:00.000000000 Z
+date: 2017-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -131,8 +131,11 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ARRAY_README.md
+- ENUMERABLE_README.md
 - Gemfile
 - Gemfile.lock
+- HASH_README.md
 - LICENSE
 - README.md
 - Rakefile
@@ -168,6 +171,7 @@ files:
 - spec/support/shared_examples/keys_appender.rb
 - spec/support/shared_examples/keys_camelizer.rb
 - spec/support/shared_examples/keys_underscorer.rb
+- spec/support/shared_examples/map_to_hash.rb
 - spec/support/shared_examples/remap.rb
 - spec/support/shared_examples/value_changer.rb
 homepage: 
@@ -213,5 +217,6 @@ test_files:
 - spec/support/shared_examples/keys_appender.rb
 - spec/support/shared_examples/keys_camelizer.rb
 - spec/support/shared_examples/keys_underscorer.rb
+- spec/support/shared_examples/map_to_hash.rb
 - spec/support/shared_examples/remap.rb
 - spec/support/shared_examples/value_changer.rb