bidu-core_ext 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a917ec3ef22ae183e9cbb569e438a80456800ad
+  data.tar.gz: dc600d8c5f69a6776e77e8aacddbef83d446cd52
+SHA512:
+  metadata.gz: 97f018e78cf3b0eeff67540fc48c4c2e0b19a99db46edde05fe4e22708e4856b8e0cf1314f7b2a97f538d55e38ed527c0b12dad122f46208775f91e8a71a6560
+  data.tar.gz: f3825dd7fd3d241a4daa9312d8748bfa580d8e1b37160b8be2bc183050239bd90f423790b1e1880b5fa09bf78d9380ee3317708a0bf5fb3bd98df066f1dbef35

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in credential_builder.gemspec
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    bidu-core_ext (1.0.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    i18n (0.7.0)
+    json (1.8.2)
+    minitest (5.6.1)
+    multi_json (1.10.1)
+    rake (10.3.2)
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.2)
+    rspec-expectations (2.99.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.99.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bidu-core_ext!
+  bundler (~> 1.6)
+  rake
+  rspec (~> 2.14)
+  rspec-mocks
+  simplecov

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Bidu.com.br
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,143 @@
+Core_Ext
+========
+
+This project adds some new methods to the core ruby classes
+
+## Array
+### 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 } }
+```
+
+## Hash
+### 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 }
+```
+
+### 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 }
+```
+
+## 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/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task default: :spec
+task test: :spec

data/core_ext.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bidu/core_ext/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'bidu-core_ext'
+  spec.version = Bidu::CoreExt::VERSION
+  spec.authors = ['Bidu Developers']
+  spec.email = ['dev@bidu.com.br']
+  spec.summary = 'Core Extensions'
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activesupport'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'rspec-mocks'
+  spec.add_development_dependency 'simplecov'
+end

data/lib/array.rb

@@ -0,0 +1,15 @@
+require 'array/hash_builder'
+
+class Array
+  def chain_map(*methods)
+    result = self
+    result = result.map(&(methods.shift)) until methods.empty?
+
+    return result unless block_given?
+    result.map { |*args| yield(*args) }
+  end
+
+  def as_hash(keys)
+    Array::HashBuilder.new(self, keys).build
+  end
+end

data/lib/array/hash_builder.rb

@@ -0,0 +1,20 @@
+class Array::HashBuilder
+  attr_accessor :values, :keys
+
+  def initialize(values, keys)
+    @values = values.dup
+    @keys = keys.dup
+  end
+
+  def build
+    fixes_sizes
+
+    Hash[[keys, values].transpose]
+  end
+
+  private
+
+  def fixes_sizes
+    values.concat Array.new(keys.size - values.size) if keys.size > values.size
+  end
+end

data/lib/bidu.rb

@@ -0,0 +1,4 @@
+module Bidu
+  require 'bidu/core_ext'
+end
+

data/lib/bidu/core_ext.rb

@@ -0,0 +1,12 @@
+require 'enumerable'
+require 'active_support/all'
+require 'hash'
+require 'symbol'
+require 'array'
+require 'numeric'
+
+module Bidu
+  module CoreExt
+    require 'bidu/core_ext/version'
+  end
+end

data/lib/bidu/core_ext/version.rb

@@ -0,0 +1,5 @@
+module Bidu
+  module CoreExt
+    VERSION = '1.0.0'
+  end
+end

data/lib/enumerable.rb

@@ -0,0 +1,30 @@
+module Enumerable
+  def clean
+    deep_dup.clean!
+  end
+
+  # delete hash or array values if value is nil
+  # ex: { a: nil, b: 2 }.clean! => { b: 2 }
+  def clean!
+    if is_a?(Hash)
+      delete_if { |_k, v| empty_value?(v) }
+    else
+      delete_if { |v| empty_value?(v) }
+    end
+  end
+
+  def map_and_find
+    mapped = nil
+    find do |*args|
+      mapped = yield(*args)
+    end
+    mapped || nil
+  end
+
+  private
+
+  def empty_value?(v)
+    v.nil? || v.try(:empty?) ||
+      ((v.is_a?(Hash) || v.is_a?(Array)) && v.clean!.empty?)
+  end
+end

data/lib/hash.rb

@@ -0,0 +1,161 @@
+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 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 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
+
+  # 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