ruby_core_extensions 0.0.1

data/lib/ruby_core_extensions/recursive.rb

@@ -0,0 +1,8 @@
+require 'ruby_core_extensions/recursive/array'
+require 'ruby_core_extensions/recursive/big_decimal'
+require 'ruby_core_extensions/recursive/date'
+require 'ruby_core_extensions/recursive/date_time'
+require 'ruby_core_extensions/recursive/fixnum'
+require 'ruby_core_extensions/recursive/hash'
+require 'ruby_core_extensions/recursive/object'
+require 'ruby_core_extensions/recursive/time'

data/lib/ruby_core_extensions/recursive/array.rb

@@ -0,0 +1,45 @@
+ class Array 
+   
+  def convert
+    self
+  end
+
+  def convert_keys_recursively(&converter)
+    map { |v| v.convert_keys_recursively(&converter) }
+  end
+  
+  def convert_values_recursively(&converter)
+    map { |v| v.convert_values_recursively(&converter) }
+  end
+  
+  def symbolize_keys_recursively
+    map(&:symbolize_keys_recursively)
+  end
+  
+  def stringify_values_recursively
+    map(&:stringify_values_recursively)
+  end
+  
+  def make_indifferent_access_recursively
+    map(&:make_indifferent_access_recursively)
+  end
+  
+  def recursive_blank?
+    each do |v|
+      if v.respond_to?(:recursive_blank?)
+        return false unless v.recursive_blank?
+      else
+        return false unless v.blank?
+      end
+    end
+    true
+  end
+  
+  def recursively(&block)
+    each do |element|
+      block.call(element)
+      element.recursively(&block) if element.respond_to?(:recursively)
+    end
+  end
+  
+end

data/lib/ruby_core_extensions/recursive/big_decimal.rb

@@ -0,0 +1,5 @@
+class BigDecimal
+  def stringify_values_recursively
+    self.to_s
+  end
+end

data/lib/ruby_core_extensions/recursive/date.rb

@@ -0,0 +1,8 @@
+class Date
+  
+  def stringify_values_recursively
+    self.to_s
+  end
+  
+end
+

data/lib/ruby_core_extensions/recursive/date_time.rb

@@ -0,0 +1,8 @@
+class DateTime
+  
+  def stringify_values_recursively
+    self.to_s
+  end
+  
+end
+

data/lib/ruby_core_extensions/recursive/fixnum.rb

@@ -0,0 +1,7 @@
+class Fixnum
+
+  def stringify_values_recursively
+    to_s
+  end
+
+end

data/lib/ruby_core_extensions/recursive/hash.rb

@@ -0,0 +1,86 @@
+class Hash
+
+  def recursive_blank?
+    each do |k, v|
+      if v.respond_to?(:recursive_blank?)
+        return false unless v.recursive_blank?
+      else
+        return false unless v.blank?
+      end
+    end
+    true
+  end
+  
+  def convert
+    self
+  end
+  
+  def convert_keys(&converter)
+    inject({}) do |hash, (key, value)|
+      hash[converter.call(key)] = value
+      hash
+    end
+  end
+  
+  def convert_values(*keys, &converter)
+    inject(clone) do |hash, (key, value)|
+      hash[key] = value.convert(&converter) if keys.blank? || keys.include?(key)
+      hash
+    end
+  end
+
+  def convert_keys_recursively(&converter)
+    Hash[map do |key, value|
+          k = converter.call(key)
+          v = value.convert_keys_recursively(&converter)
+          [k,v]
+        end]
+  end
+  
+  def convert_values_recursively(&converter)
+    inject({}) do |hash, (key, value)|
+      hash[key] = value.convert_values_recursively(&converter)
+      hash
+    end
+  end
+  
+  def symbolize_keys_recursively
+    Hash[map do |key, value|
+          k = key.is_a?(String) ? key.to_sym : key
+          v = value.symbolize_keys_recursively
+          [k,v]
+        end]
+  end
+  
+  def stringify_values_recursively
+    inject({}) do |options, (key, value)|
+      options[key] = value.stringify_values_recursively
+      options
+    end
+  end
+  
+  def make_indifferent_access_recursively
+    HashWithIndifferentAccess.new(inject({}) do |options, (key, value)|
+        options[key] = value.make_indifferent_access_recursively
+        options
+      end)
+  end
+  
+  def deep_dup
+    duplicate = self.dup
+    duplicate.each_pair do |k,v|
+      tv = duplicate[k]
+      duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
+    end
+    duplicate
+  end
+  
+  def recursively(&block)
+    each do |key,value|
+      block.call(key,value)
+      value.recursively(&block) if value.respond_to?(:recursively)
+    end
+  end
+  
+end
+

data/lib/ruby_core_extensions/recursive/object.rb

@@ -0,0 +1,17 @@
+class Object
+  def convert(&converter)
+    converter.call(self)
+  end
+  
+  def return_self
+    self
+  end
+  
+  alias_method :convert_values_recursively, :convert
+  alias_method :convert_recursively, :convert
+  
+  alias_method :convert_keys_recursively, :return_self
+  alias_method :symbolize_keys_recursively, :return_self
+  alias_method :stringify_values_recursively, :return_self
+  alias_method :make_indifferent_access_recursively, :return_self
+end

data/lib/ruby_core_extensions/recursive/time.rb

@@ -0,0 +1,8 @@
+class Time
+  
+  def stringify_values_recursively
+    self.to_s
+  end
+  
+end
+

data/lib/ruby_core_extensions/string.rb

@@ -0,0 +1,78 @@
+class String
+  def proper_underscore
+    self.titleize.gsub(" ","").underscore
+  end
+  
+  # Generate a phonetic code - which is the same for similar sounding names
+  def phonetic_code
+    # Currently using 'metaphone' which is more accurate than soundex
+    Text::Metaphone.metaphone(self)
+  end
+
+  # Solr requires numbers and letters to be separated
+  def separate_numbers_and_letters
+    gsub(/[a-z][0-9]|[0-9][a-z]/i){ |s| s[0].chr + ' ' + s[1].chr }
+  end
+
+  # convert newlines to breaks
+  def nl2br
+    gsub(/\n/, '<br />')
+  end
+
+  # Squash will reduce words from the end of the string to 3 characters until it
+  # fits within the limit, shrinking all words evenly.
+  # Where not all words can be shrunk evenly, the last words will be reduced by 1
+  # Until within the limit
+  # e.g.
+  # "Adelaide University".squash(30)
+  # => "Adelaide University"
+  # "Adelaide University".squash(10)
+  # => "Adela Univ"
+  # "Adelaide University".squash(7)
+  # => "Ade Uni"
+  # "Adelaide University".squash(3)
+  # => "AU"
+  # "Adelaide University".squash(2)
+  # => "AU"
+  # "Adelaide University".squash(1)
+  # => "A"
+  def squash(limit)
+    return self if size <= limit
+
+    words = split(' ')
+
+    # Return first letter of <limit> words
+    return words.first(limit).map{|w| w.chars.first}.join if (words.size * 2 - 1) >= limit
+
+    spaces = words.size - 1
+    word_char_min = (limit - spaces) / words.size
+    word_char_max = word_char_min + 1
+
+    words = words.map{|word| word[0..(word_char_max - 1)]}
+
+    words.reverse.each.with_index do |word, index|
+      letters_to_remove = words.join(' ').size - limit
+
+      letters_to_keep = if (last_case = (letters_to_remove <= (word.size - word_char_min)))
+        word.size - letters_to_remove # Removing final characters
+      else
+        word_char_min
+      end
+
+      # Replace word
+      words[words.size -  index - 1] = word[0..(letters_to_keep - 1)]
+
+      break if last_case
+    end
+
+    words.join(' ')
+  end
+  
+  
+  def to_bool
+    return true if self == true || self =~ (/(true|t|yes|y|1)$/i)
+    return false if self == false || self.blank? || self =~ (/(false|f|no|n|0)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+  end
+end
+

data/lib/ruby_core_extensions/version.rb

@@ -0,0 +1,3 @@
+module RubyCoreExtensions
+  VERSION = '0.0.1'
+end

data/ruby_core_extensions.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_core_extensions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby_core_extensions'
+  spec.version       = RubyCoreExtensions::VERSION
+  spec.authors       = ['Michael Noack', 'Alessandro Berardi']
+  spec.email         = 'development@travellink.com.au'
+  spec.description   = 'These are extensions from core ruby classes.'
+  spec.summary       = 'Set of extensions to core ruby libraries used by TravelLink Technology.'
+  spec.homepage      = 'http://github.com/sealink/ruby_core_extensions'
+
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency 'activesupport', '>= 2.0'
+  spec.add_dependency 'tzinfo'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-rcov'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'travis'
+end

data/spec/array_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Array do
+
+  it "should allow converting all values to strings recursively" do
+    @now = Time.now
+    expect([1, 2, @now, [3, 4]].stringify_values_recursively).to eq ['1', '2', @now.to_s, ['3', '4']]
+  end
+
+  it "should allow removing all blank values" do
+    a = [1, nil, 3, '']
+    a.compact_blank!
+    expect(a).to eq [1, 3]
+  end
+
+  it "should allow removing all blank values recursively" do
+    a = [1, 2, [" Kan", {}], nil, {:a => "", :b => {}}, ["garoos", " "]]
+    a.recursive_compact_blank!
+    expect(a.join).to eq "12 Kangaroos"
+  end
+
+  it "should allow verifying if all elements are blank recursively" do
+    expect(['',nil,[nil,['']]]).to be_recursive_blank
+    expect(['',nil,[nil,['',1]]]).to_not be_recursive_blank
+  end
+
+  it "should allow converting to hash given a key" do
+    expect([1,2,3].hash_by(:ordinalize)).to eq({'1st' => 1, "2nd" => 2, "3rd" => 3})
+    expect([1,2,3].hash_by(:ordinalize, :to_s)).to eq({'1st' => '1', "2nd" => '2', "3rd" => '3'})
+    expect([1,2,3].hash_by(:ordinalize){ |v| v + 1 }).to eq({'1st' => 2, "2nd" => 3, "3rd" => 4})
+    expect([1,2,3].hash_by{|k| k * 2}).to eq({2 => 1, 4 => 2, 6 => 3})
+  end
+
+  it "should allow executing blocks recursively" do
+    array = [1,[2,3],[4,[5,6],7,[8]],9,[[10]]]
+    result = []
+    array.recursively do |e|
+      result << e unless e.is_a?(Array)
+    end
+    expect(result).to eq [1,2,3,4,5,6,7,8,9,10]
+  end
+
+  it '#intersects?' do
+    array1 = [1, 2, 3]
+    array2 = [3, 4, 5]
+    array3 = [6, 7, 8]
+
+    expect(array1.intersects?(array2)).to be true
+    expect(array1.intersects?(array3)).to be false
+    expect(array2.intersects?(array3)).to be false
+
+    array1same = [1, 2, 3]
+    expect(array1.intersects?(array1same)).to be true
+  end
+
+  it '#first' do
+    expect(Array.first([])).to be nil
+    expect(Array.first([4, 2])).to eq 4
+    expect(Array.first(4)).to eq 4
+  end
+
+  it '#last' do
+    expect(Array.last([])).to be nil
+    expect(Array.last([4, 2])).to eq 2
+    expect(Array.last(4)).to eq 4
+  end
+end

data/spec/class_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Class do
+
+  it 'should downcase class name to symbol' do
+    class CamelCaseClass; end
+
+    expect(Object.downcase_symbol).to eq :object
+    expect(CamelCaseClass.downcase_symbol).to eq :camelcaseclass
+  end
+
+end

data/spec/compact_spec.rb

@@ -0,0 +1,49 @@
+describe Array, 'compact' do
+  it 'should compact blank' do
+    a = [1, nil, 3]
+    a.compact_blank!
+    expect(a).to eq [1, 3]
+  end
+
+  it 'should recursive compact blank' do
+    a = [1, nil, {:a => nil, :b => 2}]
+    a.recursive_compact_blank!
+    expect(a).to eq [1, {:b => 2}]
+
+    b = [1, nil, {:a => nil}]
+    b.recursive_compact_blank!
+    expect(b).to eq [1]
+  end
+end
+
+describe Hash, 'compact' do
+  it 'should compact' do
+    expect({:a => 1, :b => nil}.compact).to eq({:a => 1})
+  end
+
+  it 'should compact!' do
+    a = {:a => 1, :b => nil}
+    a.compact!
+    expect(a).to eq({:a => 1})
+  end
+
+  it 'should compact blank' do
+    expect({:a => 1, :b => ''}.compact_blank).to eq({:a => 1})
+  end
+
+  it 'should compact blank!' do
+    a = {:a => 1, :b => ''}
+    a.compact_blank!
+    expect(a).to eq({:a => 1})
+  end
+
+  it 'should recursive compact blank!' do
+    a = {:a => 1, :b => {:c => 1, :d => ''}}
+    a.recursive_compact_blank!
+    expect(a).to eq({:a => 1, :b => {:c => 1}})
+
+    a = {:a => 1, :b => {:c => [], :d => ''}}
+    a.recursive_compact_blank!
+    expect(a).to eq({:a => 1})
+  end
+end