darthjee-core_ext 1.2.6

data/lib/hash.rb

@@ -0,0 +1,195 @@
+require 'hash/value_changer'
+require 'hash/deep_hash_constructor'
+require 'hash/key_changer'
+
+class Hash
+  def chain_fetch(*keys)
+    value = self
+
+    if block_given?
+      value = value.fetch(keys.shift) do |*args|
+        missed_keys = keys
+        keys = []
+        yield(*(args + [missed_keys]))
+      end until keys.empty?
+    else
+      value = value.fetch(keys.shift) until keys.empty?
+    end
+
+    value
+  end
+
+  def squash
+    {}.tap do |hash|
+      each do |key, value|
+        if value.is_a? Hash
+          value.squash.each do |k, v|
+            new_key = [key, k].join('.')
+            hash[new_key] = v
+          end
+        else
+          hash[key] = value
+        end
+      end
+    end
+  end
+
+  def map_to_hash
+    {}.tap do |hash|
+      each do |k, v|
+        hash[k] = yield(k, v)
+      end
+    end
+  end
+
+  def remap_keys(remap)
+    dup.remap_keys!(remap)
+  end
+
+  def remap_keys!(remap)
+    new_hash = {}
+    remap.each do |o, n|
+      new_hash[n] = delete o
+    end
+    merge! new_hash
+  end
+
+  def lower_camelize_keys(options = {})
+    dup.lower_camelize_keys!(options)
+  end
+
+  def lower_camelize_keys!(options = {})
+    options = options.merge({ uppercase_first_letter: false })
+
+    camelize_keys!(options)
+  end
+
+  def camelize_keys(options = {})
+    dup.camelize_keys!(options)
+  end
+
+  def camelize_keys!(options = {})
+    Hash::KeyChanger.new(self).camelize_keys(options)
+  end
+
+  def underscore_keys(options = {})
+    dup.underscore_keys!(options)
+  end
+
+  def underscore_keys!(options = {})
+    Hash::KeyChanger.new(self).underscore_keys(options)
+  end
+
+  def exclusive_merge(hash)
+    dup.exclusive_merge!(hash)
+  end
+
+  def exclusive_merge!(hash)
+    merge!(hash.slice(*keys))
+  end
+
+  # change all keys returning the new map
+  # options: { recursive: true }
+  # ex: { "a" =>1 }.change_keys{ |key| key.upcase } == { "A" => 1 }
+  def change_keys(options = {}, &block)
+    deep_dup.change_keys!(options, &block)
+  end
+
+  # change all keys returning the new map
+  # options: { recursive: true }
+  # ex: { "a":1 }.change_keys{ |key| key.upcase } == { "A":1 }
+  def change_keys!(options = {}, &block)
+    Hash::KeyChanger.new(self).change_keys(options, &block)
+  end
+
+  # change all publicaly sending method calls
+  # options: { recursive: true }
+  # ex: { a: 1 }.chain_change_keys(:to_s, :upcase) == { "A" =>1 }
+  def chain_change_keys(*calls)
+    deep_dup.chain_change_keys!(*calls)
+  end
+
+  # change all publicaly sending method calls
+  # options: { recursive: true }
+  # ex: { a: 1 }.chain_change_keys(:to_s, :upcase) == { "A" =>1 }
+  def chain_change_keys!(*calls)
+    options = calls.extract_options!
+
+    calls.inject(self) do |h, m|
+      h.change_keys!(options, &m)
+    end
+  end
+
+  # prepend a string to all keys
+  # options {
+  #  recursive: true,
+  #  type: :keep [keep, string, symbol] (key type to be returned)
+  # }
+  # ex: { :a => 1, "b"=> 2 }.prepend_to_keys("foo_") == { :foo_a => 1, "foo_b"=> 2 }
+  def prepend_to_keys(str, options = {})
+    change_key_text(options) do |key|
+      "#{str}#{key}"
+    end
+  end
+
+  # append a string to all keys
+  # options {
+  #  recursive: true,
+  #  type: :keep [keep, string, symbol] (key type to be returned)
+  # }
+  # ex: { :a => 1, "b"=> 2 }.append_to_keys("_bar") == { :a_bar => 1, "b_bar"=> 2 }
+  def append_to_keys(str, options = {})
+    change_key_text(options) do |key|
+      "#{key}#{str}"
+    end
+  end
+
+  # sorts keys for hash
+  # options: { recursive: true }
+  # ex: { b:1, a:2 }.sort_keys == { a:2, b:1 }
+  def sort_keys(options = {})
+    options = {
+      recursive: true
+    }.merge(options)
+
+    {}.tap do |hash|
+      keys.sort.each do |key|
+        value = self[key]
+        hash[key] = value unless value.is_a?(Hash) && options[:recursive]
+        hash[key] = value.sort_keys(options) if value.is_a?(Hash) && options[:recursive]
+      end
+    end
+  end
+
+  # creates a new hash with changes in its values
+  # options: {
+  #   recursive: true,
+  #   skip_hash:true
+  # }
+  # ex: { a:1, b:2 }.change_values{ |v| v+1 } == { a:2, b:3 }
+  # ex: { a:1, b:{ c:1 } }.change_values(skip_hash:false) { |v| v.to_s } == { a:"1", b:"{ c=>1 }
+  # ex: { a:1, b:{ c:1 } }.change_values(skip_hash:true) { |v| v.to_s } == { a:"1", b:{ c=>"1" } }
+  def change_values(options = {}, &block)
+    deep_dup.change_values!(options, &block)
+  end
+
+  def change_values!(options = {}, &block)
+    Hash::ValueChanger.new(options, &block).change(self)
+  end
+
+  def to_deep_hash(separator = '.')
+    Hash::DeepHashConstructor.new(separator).deep_hash(self)
+  end
+
+  private
+
+  # changes the text of the keys
+  # options {
+  #  recursive: true,
+  #  type: :keep [keep, string, symbol] (key type to be returned)
+  # }
+  # ex: { :a => 1, "b"=> 2 }.change_key_text{ |key| key.upcase } == { :A => 1, "B"=> 2 }
+  def change_key_text(options = {}, &block)
+    Hash::KeyChanger.new(self).change_text(options, &block)
+  end
+end

data/lib/hash/deep_hash_constructor.rb

@@ -0,0 +1,83 @@
+class Hash::DeepHashConstructor
+  attr_accessor :separator
+
+  def initialize(separator)
+    @separator = separator
+  end
+
+  def deep_hash(object)
+    if object.is_a? Array
+      array_deep_hash(object)
+    elsif object.is_a? Hash
+      hash_deep_hash(object)
+    else
+      object
+    end
+  end
+
+  private
+
+  def array_deep_hash(array)
+    array.map { |v| v.is_a?(Hash) ? deep_hash(v) : v }
+  end
+
+  def hash_deep_hash(hash)
+    {}.tap do |new_hash|
+      hash.each do |k, v|
+        base_key, child_key = split_key(k, separator)
+        set_deep_hash_positioned_value(new_hash, base_key, v, child_key)
+      end
+
+      new_hash.each do |k, v|
+        new_hash[k] = deep_hash(v)
+      end
+    end
+  end
+
+  def split_key(key, separator)
+    separator_rxp = (separator == '.') ? "\\#{separator}" : separator
+    skipper = "[^#{separator}]"
+    regexp = Regexp.new("^(#{skipper}*)#{separator_rxp}(.*)")
+    match = key.match(regexp)
+
+    match ? match[1..2] : key
+  end
+
+  def set_deep_hash_array_value(hash, base_key, index, value, key = nil)
+    key_without_index = base_key.gsub("[#{index}]", '')
+    hash[key_without_index] ||= []
+
+    if key.nil?
+      hash[key_without_index][index] = value
+    else
+      hash[key_without_index][index] ||= {}
+      hash[key_without_index][index][key] = value
+    end
+  end
+
+  def set_deep_hash_positioned_value(new_hash, base_key, v, child_key)
+    index = array_index(base_key)
+
+    if index
+      set_deep_hash_array_value(new_hash, base_key, index, v, child_key)
+    else
+      set_deep_hash_value(new_hash, base_key, v, child_key)
+    end
+  end
+
+  def array_index(key)
+    match = key.match(/\[([^)]+)\]/)
+    if match
+      match[1].to_i
+    end
+  end
+
+  def set_deep_hash_value(hash, base_key, value, key = nil)
+    if key.nil?
+      hash[base_key] = value
+    else
+      hash[base_key] ||= {}
+      hash[base_key][key] = value
+    end
+  end
+end

data/lib/hash/key_changer.rb

@@ -0,0 +1,76 @@
+class Hash::KeyChanger
+  attr_reader :hash, :block
+
+  def initialize(hash)
+    @hash = hash
+  end
+
+  def change_keys(settings = {}, &block)
+    merge_options({
+      recursive: true
+    }, settings)
+
+    if options[:recursive]
+      hash.deep_transform_keys!(&block)
+    else
+      hash.transform_keys!(&block)
+    end
+  end
+
+  def camelize_keys(settings = {})
+    merge_options({
+      uppercase_first_letter: true
+    }, settings)
+
+    type = options[:uppercase_first_letter] ? :upper : :lower
+
+    change_keys do |k|
+      k.camelize(type)
+    end
+  end
+
+  def underscore_keys(settings = {})
+    merge_options({}, settings)
+
+    change_keys do |k|
+      k.underscore
+    end
+  end
+
+  def change_text(options = {}, &block)
+    merge_options({
+      type: :keep
+    }, options)
+
+    change_keys do |key|
+      cast_new_key block.call(key), key.class
+    end
+  end
+
+  private
+
+  def merge_options(default, custom)
+    @options = {}.merge!(default).merge!(custom).merge!(options)
+  end
+
+  def options
+    @options ||= {}
+  end
+
+  def cast_new_key(key, old_clazz)
+    case class_cast(old_clazz)
+    when :symbol then
+      key.to_sym
+    when :string then
+      key.to_s
+    end
+  end
+
+  def keep_class?
+    options[:type] == :keep
+  end
+
+  def class_cast(old_clazz)
+    keep_class? && old_clazz.to_s.downcase.to_sym || options[:type]
+  end
+end

data/lib/hash/value_changer.rb

@@ -0,0 +1,61 @@
+class Hash::ValueChanger
+  attr_accessor :options, :block
+
+  def initialize(options, &block)
+    @options = {
+      recursive: true,
+      skip_inner: true
+    }.merge(options)
+
+    @block = block
+  end
+
+  def change(object)
+    if object.respond_to?(:change_values)
+      change_hash(object)
+    elsif is_iterable?(object)
+      change_array(object)
+    end
+  end
+
+  private
+
+  def change_hash(original_hash)
+    original_hash.tap do |hash|
+      original_hash.each do |key, value|
+        value = new_value(value)
+        hash[key] = value
+      end
+    end
+  end
+
+  def change_array(array)
+    array = array.to_a
+
+    array.each.with_index do |value, index|
+      if value.respond_to?(:change_values)
+        value = value.change_values(options, &block)
+      elsif is_iterable?(value)
+        value = change_array(value)
+      end
+      array[index] = value
+    end
+  end
+
+  def change_value?(value)
+    !is_iterable?(value) || !options[:skip_inner]
+  end
+
+  def is_iterable?(value)
+    value.respond_to?(:each)
+  end
+
+  def new_value(value)
+    value = block.call(value) if change_value?(value)
+    apply_recursion?(value) ? change(value) : value
+  end
+
+  def apply_recursion?(value)
+    is_iterable?(value) && options[:recursive]
+  end
+end

data/lib/numeric.rb

@@ -0,0 +1,6 @@
+class Numeric
+  def percent_of(n)
+    return Float::INFINITY if n == 0
+    (to_f / n.to_f) * 100.0
+  end
+end

data/lib/symbol.rb

@@ -0,0 +1,9 @@
+class Symbol
+  def camelize(type = :upper)
+    to_s.camelize(type).to_sym
+  end
+
+  def underscore
+    to_s.underscore.to_sym
+  end
+end

data/spec/lib/array_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe Array do
+  describe '#chain_map' do
+    let(:array) { [ :a, :long_name, :sym ] }
+    let(:mapped) { array.chain_map(:to_s, :size, :to_s) }
+
+    it 'calls each argument as method of the mapped result' do
+      expect(mapped).to eq([ '1', '9', '3' ])
+    end
+
+    context 'when an extra block is given' do
+      let(:mapped) do
+        array.chain_map(:to_s, :size) do |v|
+          "final: #{v}"
+        end
+      end
+
+      it 'calls each argument as method of the mapped result' do
+        expect(mapped).to eq([ 'final: 1', 'final: 9', 'final: 3' ])
+      end
+    end
+  end
+
+  describe '#as_hash' do
+    let(:array) { [1, 2, 3] }
+    let(:keys) { %w(a b c) }
+    let(:expected) { { 'a' => 1, 'b' => 2, 'c' => 3 } }
+
+    it 'creates a hash using the array as value and the argument as keys' do
+      expect(array.as_hash(keys)).to eq(expected)
+    end
+
+    context 'when there are more keys than values' do
+      let(:keys) { %w(a b c d e f) }
+      let(:expected) { { 'a' => 1, 'b' => 2, 'c' => 3, 'd' => nil, 'e' => nil, 'f' => nil } }
+
+      it 'creates a hash with nil values for the extra keys' do
+        expect(array.as_hash(keys)).to eq(expected)
+      end
+
+      it { expect { array.as_hash(keys) }.not_to change { keys } }
+      it { expect { array.as_hash(keys) }.not_to change { array } }
+    end
+
+    context 'when there are more values than keys' do
+      let(:array) { [1, 2, 3, 4, 5, 6, 7] }
+
+      it { expect { array.as_hash(keys) }.to raise_error(IndexError) }
+
+      it { expect { array.as_hash(keys) rescue nil }.not_to change { keys } }
+      it { expect { array.as_hash(keys) rescue nil }.not_to change { array } }
+    end
+  end
+
+  describe '#map_and_find' do
+    let(:array) { [1, 2, 3, 4] }
+    let(:value) { array.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
+
+    context 'when block returns a true evaluated value' do
+      let(:block) { proc(&:to_s) }
+
+      it { expect(value).to eq('1') }
+
+      context 'but not for the first value' do
+        let(:transformer) { double(:transformer) }
+        let(:block) { proc { |v| transformer.transform(v) } }
+
+        before do
+          allow(transformer).to receive(:transform) do |v|
+            v.to_s if v > 1
+          end
+          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
+      end
+    end
+  end
+
+  describe '#random' do
+    it_behaves_like 'a method that returns a random element', :random
+  end
+
+  describe '#random!' do
+    it_behaves_like 'a method that returns a random element', :random!
+
+    let(:array) { [ 8,4,2 ] }
+
+    it 'removes an the returned element' do
+      expect do
+        array.random!
+      end.to change { array.size }.by(-1)
+    end
+  end
+
+  describe '#map_and_select' do
+    let(:array) { [1, 2, 3, 4].map { |i| { value: i} } }
+    let(:filtered) { array.map_and_select(&block) }
+
+    context 'when block returns nil' do
+      let(:block) { proc {} }
+      it { expect(filtered).to be_empty }
+    end
+
+    context 'when block returns false' do
+      let(:block) { proc { false } }
+      it { expect(filtered).to be_empty }
+    end
+
+    context 'when block returns a true evaluated value' do
+      let(:block) { proc(&:to_s) }
+
+      it { expect(filtered).to eq(array.map(&:to_s)) }
+
+      context 'but not for the first value' do
+        let(:transformer) { double(:transformer) }
+        let(:block) { proc { |v| transformer.transform(v) } }
+
+        before do
+          allow(transformer).to receive(:transform) do |v|
+            v.to_s if v[:value] > 1
+          end
+          filtered
+        end
+
+        it { expect(filtered).to eq(array[1..-1].map(&:to_s)) }
+
+        it 'calls the mapping only once per element' do
+          expect(transformer).to have_received(:transform).exactly(4)
+        end
+      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