bidu-core_ext 1.0.0

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,68 @@
+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 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,52 @@
+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.is_a? Hash
+      change_hash(object)
+    elsif object.is_a? Array
+      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.each.with_index do |value, index|
+      value = value.change_values(options, &block) if value.is_a? Hash
+      value = change_array(value) if value.is_a? Array
+      array[index] = value
+    end
+  end
+
+  def change_value?(value)
+    !(value.is_a?(Hash) || value.is_a?(Array)) || !options[:skip_inner]
+  end
+
+  def new_value(value)
+    value = block.call(value) if change_value?(value)
+    apply_recursion?(value) ? change(value) : value
+  end
+
+  def apply_recursion?(value)
+    (value.is_a?(Hash) || value.is_a?(Array)) && 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,5 @@
+class Symbol
+  def camelize(type = :upper)
+    to_s.camelize(type).to_sym
+  end
+end

data/spec/lib/array_spec.rb

@@ -0,0 +1,93 @@
+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
+end

data/spec/lib/enumerable_spec.rb

@@ -0,0 +1,31 @@
+describe Enumerable do
+  describe '#clean!' do
+    it_behaves_like 'an array clean method', :clean!
+    it_behaves_like 'a hash clean method', :clean!
+
+    it 'changes the original hash' do
+      hash = { a: nil}
+      expect { hash.clean! }.to change { hash }
+    end
+
+    it 'changes original array' do
+      array = [{ a: nil}]
+      expect { array.clean! }.to change { array }
+    end
+  end
+
+  describe '#clean' do
+    it_behaves_like 'an array clean method', :clean
+    it_behaves_like 'a hash clean method', :clean
+
+    it 'does not change the original hash' do
+      hash = { a: nil}
+      expect { hash.clean }.not_to change { hash }
+    end
+
+    it 'does not change the original array' do
+      array = [{ a: nil}]
+      expect { array.clean }.not_to change { array }
+    end
+  end
+end

data/spec/lib/hash/deep_hash_constructor_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Hash::DeepHashConstructor do
+  let(:subject) { described_class.new('.') }
+  let(:deep_hash) { subject.deep_hash(hash) }
+
+  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' => Fixnum,
+          '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' => Fixnum } },
+            { 'status' => { 'clazz' => Date } }
+          ],
+          'trials' => 3
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(deep_hash).to eq(expected)
+      end
+    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
+
+      it 'build a deep hash with arrays' do
+        expect(deep_hash).to eq(expected)
+      end
+    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
+    end
+  end
+end