utilise 0.5.0.pre.42 → 0.5.0.pre.47

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDZlMDY3ZmExYWUwZTE0YjFmNjhmNTkwNzcxNTM4NGQyOTI5ODFmMA==
+    ODI4ZGIyYWRkZDlmMjQyOTRmODNiMDIxYTMxMTkyYjA3ZDcyZTgyMA==
   data.tar.gz: !binary |-
-    ZTM0OTFhMzAwYzc2ODgzMWVjM2RlNWRlZDBiOGRkNjFiNmQzY2NmMg==
+    NjQ3YzA0NjgxNDkyOGQ2ZDUxZTJiNDQzMzIwZDBmYWYyMDllYzY0Yw==
 SHA512:
   metadata.gz: !binary |-
-    NjgwMmI1ZjYwZjViYjAxYjIzZjM4OTVkNTUxNmY0NzRiOTQ1Y2MyNmUwMzU2
-    NDg1OTQ2YWFiOGUzYzdiZjA3YTQyOGM3MTlkZmY5NDlmNzY2ZjNlNjBiZTM3
-    ZmVkYTcwY2Q1NjhhNjA3YTkxMGVlZTdhYjE1NDE5ZTI1ZWYyYmE=
+    OGU3MzFkMGYwZDQxYzVhZGEwNmJmNjBjZTVhZjVhNjBkMDQxY2QxMTQ5Zjhk
+    NjY5YmNhY2Q3Y2I1MWQwOThlMGU2ZWI3OTk3NTY3NmIyNGMzOWRhMzI3ODZi
+    MzIzYzRmNDY2ZjgyZGI4NjRjMWIwYmJlMzVjNDQ2NWZkNWZlYmQ=
   data.tar.gz: !binary |-
-    ZjAyMTk2MzYyMzdkMmQ1ODA0MjUyMTQ2ODFiN2YxNzBkMTcyMDEzOWEzZDJm
-    MjUxZTIyYzNkM2IyNzgyMmYyY2ZjZWJjYmJjMzE0NDc3ZWY4ZGVmYjI2ZjVi
-    YjY1N2VlNjg4ODQyY2JiNjVmMzk0MzgzYzFjNDFhYjEzYjQxN2U=
+    MTk1YTliZDM2YmQ5ZTJmYTczMWFjMWQ0OTkzZTA5NGI2ZTE0NjY3MmFhMDlm
+    MmIwMjIyZTgwMTk4Y2RlY2QwYWRiNGI1ZDdhN2E1YmMyMDZkMmMyMmRmN2Y4
+    ODNjZGMyNmUzZDIyZmJmN2VkZjdjNTJhYTRjYTM4MjgwY2Y4Mzg=

data/lib/utilise/array.rb

@@ -1,4 +1,4 @@
-require 'utilise/augment/bool.rb'
+require 'utilise/augment/bool'
 
 # Extend existing ruby class Array
 class Array

data/lib/utilise/augment/bool.rb

@@ -41,7 +41,7 @@ module Utilise
 
       # Returns boolean value if object matches rules
       #
-      # @param array [Array] the array
+      # @param object [Object] object to bool
       # @returns [Boolean] true/false returned
       def bool_it(object)
         case object.to_s

data/lib/utilise/augment/hash.rb

@@ -0,0 +1,41 @@
+require 'utilise/string'
+
+module Utilise
+  module Augment
+    # Extends a hash to modify keys
+    module Hash
+      # Transforms all keys to snake case
+      def snake_keys
+        transform_keys(self) { |key| key.snake }
+      end
+
+      # Transforms all keys to camel case
+      def camel_keys
+        transform_keys(self) { |key| key.camel }
+      end
+
+      # Transforms all keys to space case
+      def space_keys
+        transform_keys(self) { |key| key.space }
+      end
+
+      private
+
+      # Deep transform keys
+      # An awesome piece of code from rails
+      # apidock.com/rails/v4.2.1/Hash/_deep_transform_keys_in_object%21
+      def transform_keys(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = transform_keys(value, &block)
+          end
+        when Array
+          object.map { |e| transform_keys(e, &block) }
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/utilise/augment/modify.rb

@@ -4,7 +4,8 @@ module Utilise
     module Modify
       # Return a string in modified camel case
       def camel
-        split_up.map(&:capitalize).join('')
+        array = split_up
+        array.first + array[1..-1].map(&:capitalize).join('')
       end
 
       # Return a string in snake case
@@ -21,7 +22,8 @@ module Utilise
 
       # Splits up the current string into an array and normalises it
       def split_up
-        arr = split(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?=_)|(?= )/)
+        regex = /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?=_)|(?= )/
+        arr = to_s.split(regex)
         arr.map!(&:downcase)
         arr.map!(&:strip)
         arr.map { |s| s.delete('_') }

data/lib/utilise/fixnum.rb

@@ -1,4 +1,4 @@
-require 'utilise/augment/bool.rb'
+require 'utilise/augment/bool'
 
 # Extend existing ruby class Fixnum
 class Fixnum

data/lib/utilise/hash.rb

@@ -1,6 +1,8 @@
-require 'utilise/augment/bool.rb'
+require 'utilise/augment/bool'
+require 'utilise/augment/hash'
 
 # Extend existing ruby class Hash
 class Hash
   include Utilise::Augment::Bool
+  include Utilise::Augment::Hash
 end

data/lib/utilise/hashie.rb

@@ -1,4 +1,4 @@
-require 'utilise/augment/crash.rb'
+require 'utilise/augment/crash'
 
 # Extend existing hashie module
 module Hashie

data/lib/utilise/object.rb

@@ -1,4 +1,4 @@
-require 'utilise/augment/matchers.rb'
+require 'utilise/augment/matchers'
 
 # Extend existing ruby class Object
 class Object

data/lib/utilise/string.rb

@@ -1,5 +1,5 @@
-require 'utilise/augment/bool.rb'
-require 'utilise/augment/modify.rb'
+require 'utilise/augment/bool'
+require 'utilise/augment/modify'
 
 # Extend existing ruby class String
 class String

data/lib/utilise/symbol.rb

@@ -1,6 +1,8 @@
-require 'utilise/augment/bool.rb'
+require 'utilise/augment/bool'
+require 'utilise/augment/modify'
 
 # Extend existing ruby class Symbol
 class Symbol
   include Utilise::Augment::Bool
+  include Utilise::Augment::Modify
 end

data/lib/utilise/time.rb

@@ -1,4 +1,4 @@
-require 'utilise/augment/time.rb'
+require 'utilise/augment/time'
 
 # Extend existing ruby class Time
 class Time

data/spec/spec_helper.rb

@@ -26,4 +26,3 @@ end
 Coveralls.wear!
 SimpleCov.start
 require 'utilise'
-

data/spec/utilise/hash_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Hash do
+  describe '#to_bool' do
+    it 'returns hash with true when key value is 1' do
+      expect({ 'key' => 1 }.to_bool).to eql('key' => true)
+    end
+
+    it 'returns hash with false when key value is 0' do
+      expect({ 'key' => 0 }.to_bool).to eql('key' => false)
+    end
+
+    it 'returns original hash when key value is not 0 or 1' do
+      expect({ 'key' => 2 }.to_bool).to eql('key' => 2)
+    end
+
+    it "returns hash with true when key value is 'yes'" do
+      expect({ 'key' => 'yes' }.to_bool).to eql('key' => true)
+    end
+
+    it "returns hash with false when key value is 'no'" do
+      expect({ 'key' => 'no' }.to_bool).to eql('key' => false)
+    end
+
+    it "returns hash with true when key value is 'true'" do
+      expect({ 'key' => 'true' }.to_bool).to eql('key' => true)
+    end
+
+    it "returns hash with false when key value is 'false'" do
+      expect({ 'key' => 'false' }.to_bool).to eql('key' => false)
+    end
+
+    it "returns original hash when key value is not 'yes', 'no', 'true or 'false'" do
+      expect({ 'key' => 'value' }.to_bool).to eql('key' => 'value')
+    end
+
+    it 'returns hash with true when key value is :t' do
+      expect({ 'key' => :t }.to_bool).to eql('key' => true)
+    end
+
+    it 'returns hash with false when key value is :f' do
+      expect({ 'key' => :f }.to_bool).to eql('key' => false)
+    end
+
+    it 'returns hash with true when key value is :t' do
+      expect({ 'key' => :yes }.to_bool).to eql('key' => true)
+    end
+
+    it 'returns hash with false when key value is :f' do
+      expect({ 'key' => :no }.to_bool).to eql('key' => false)
+    end
+
+    it 'returns hash with true when key value is :true' do
+      expect({ 'key' => :true }.to_bool).to eql('key' => true)
+    end
+
+    it 'returns hash with false when key value is :false' do
+      expect({ 'key' => :false }.to_bool).to eql('key' => false)
+    end
+
+    it 'returns original hash when key value is not :t or :n' do
+      expect({ 'key' => :symbol }.to_bool).to eql('key' => :symbol)
+    end
+
+    it 'returns correct hash with multiple values' do
+      expect({ 'key0' => 1, 'key1' => 0, 'key2' => 'yes', 'key3' => 'false', 'key4' => :t, 'key4' => :f, 'key5' => :true, 'key6' => :false }.to_bool).to eql('key0' => true, 'key1' => false, 'key2' => true, 'key3' => false, 'key4' => true, 'key4' => false, 'key5' => true, 'key6' => false)
+    end
+
+    it 'returns correct multi-level hash with multiple values' do
+      expect({ 'key0' => { 'key1' => 1 }, 'key2' => { 'key3' => 0 } }.to_bool).to eql('key0' => { 'key1' => true }, 'key2' => { 'key3' => false })
+    end
+  end
+
+  describe '#snake_keys' do
+    let(:hash) { { oneKey: 'aString', two_key: ['a_string'], 'red key' => { blueKey: 'testing 123' } } }
+
+    it 'coverts all keys to snake case' do
+      new_hash = hash.snake_keys
+      expect(new_hash.key?('one_key')).to be_truthy
+      expect(new_hash.key?('two_key')).to be_truthy
+      expect(new_hash.key?('red_key')).to be_truthy
+      expect(new_hash['red_key'].key?('blue_key')).to be_truthy
+    end
+
+    it 'does not transfer the old keys' do
+      new_hash = hash.snake_keys
+      expect(new_hash.key?(:oneKey)).to be_falsey
+      expect(new_hash.key?(:two_key)).to be_falsey
+      expect(new_hash.key?('red key')).to be_falsey
+    end
+
+    it 'does not convert the values' do
+      new_hash = hash.snake_keys
+      expect(new_hash['one_key']).to eql('aString')
+      expect(new_hash['two_key']).to eql(['a_string'])
+      expect(new_hash['red_key']).to be_a(Hash)
+      expect(new_hash['red_key']['blue_key']).to eql('testing 123')
+    end
+
+    it 'does not modify the original hash' do
+      old_hash = hash
+      old_hash.snake_keys
+
+      expect(old_hash.key?(:oneKey)).to be_truthy
+      expect(old_hash.key?(:two_key)).to be_truthy
+      expect(old_hash.key?('red key')).to be_truthy
+      expect(old_hash['red key'].key?(:blueKey)).to be_truthy
+
+      expect(old_hash[:oneKey]).to eql('aString')
+      expect(old_hash[:two_key]).to eql(['a_string'])
+      expect(old_hash['red key']).to be_a(Hash)
+      expect(old_hash['red key'][:blueKey]).to eql('testing 123')
+    end
+  end
+
+  describe '#camel_keys' do
+    let(:hash) { { oneKey: 'aString', two_key: ['a_string'], 'red key' => { blueKey: 'testing 123' } } }
+
+    it 'coverts all keys to camel case' do
+      new_hash = hash.camel_keys
+      expect(new_hash.key?('oneKey')).to be_truthy
+      expect(new_hash.key?('twoKey')).to be_truthy
+      expect(new_hash.key?('redKey')).to be_truthy
+      expect(new_hash['redKey'].key?('blueKey')).to be_truthy
+    end
+
+    it 'does not transfer the old keys' do
+      new_hash = hash.camel_keys
+      expect(new_hash.key?(:oneKey)).to be_falsey
+      expect(new_hash.key?(:two_key)).to be_falsey
+      expect(new_hash.key?('red key')).to be_falsey
+    end
+
+    it 'does not convert the values' do
+      new_hash = hash.camel_keys
+
+      expect(new_hash['oneKey']).to eql('aString')
+      expect(new_hash['twoKey']).to eql(['a_string'])
+      expect(new_hash['redKey']).to be_a(Hash)
+      expect(new_hash['redKey']['blueKey']).to eql('testing 123')
+    end
+
+    it 'does not modify the original hash' do
+      old_hash = hash
+      old_hash.camel_keys
+
+      expect(old_hash.key?(:oneKey)).to be_truthy
+      expect(old_hash.key?(:two_key)).to be_truthy
+      expect(old_hash.key?('red key')).to be_truthy
+      expect(old_hash['red key'].key?(:blueKey)).to be_truthy
+
+      expect(old_hash[:oneKey]).to eql('aString')
+      expect(old_hash[:two_key]).to eql(['a_string'])
+      expect(old_hash['red key']).to be_a(Hash)
+      expect(old_hash['red key'][:blueKey]).to eql('testing 123')
+    end
+  end
+
+  describe '#space_keys' do
+    let(:hash) { { oneKey: 'aString', two_key: ['a_string'], 'red key' => { blueKey: 'testing 123' } } }
+
+    it 'coverts all keys to space case' do
+      new_hash = hash.space_keys
+      expect(new_hash.key?('one key')).to be_truthy
+      expect(new_hash.key?('two key')).to be_truthy
+      expect(new_hash.key?('red key')).to be_truthy
+      expect(new_hash['red key'].key?('blue key')).to be_truthy
+    end
+
+    it 'does not transfer the old keys' do
+      new_hash = hash.space_keys
+      expect(new_hash.key?(:oneKey)).to be_falsey
+      expect(new_hash.key?(:two_key)).to be_falsey
+      expect(new_hash['red key'].key?(:blueKey)).to be_falsey
+    end
+
+    it 'does not convert the values' do
+      new_hash = hash.space_keys
+
+      expect(new_hash['one key']).to eql('aString')
+      expect(new_hash['two key']).to eql(['a_string'])
+      expect(new_hash['red key']).to be_a(Hash)
+      expect(new_hash['red key']['blue key']).to eql('testing 123')
+    end
+
+    it 'does not modify the original hash' do
+      old_hash = hash
+      old_hash.space_keys
+
+      expect(old_hash.key?(:oneKey)).to be_truthy
+      expect(old_hash.key?(:two_key)).to be_truthy
+      expect(old_hash.key?('red key')).to be_truthy
+      expect(old_hash['red key'].key?(:blueKey)).to be_truthy
+
+      expect(old_hash[:oneKey]).to eql('aString')
+      expect(old_hash[:two_key]).to eql(['a_string'])
+      expect(old_hash['red key']).to be_a(Hash)
+      expect(old_hash['red key'][:blueKey]).to eql('testing 123')
+    end
+  end
+end

data/spec/utilise/{augment/hashie_spec.rb → hashie_spec.rb}

@@ -9,7 +9,7 @@ describe Utilise::Augment::Crash::Bash do
 
   context 'a bash with keys' do
     before do
-      @hash = Hashie::Bash.new(a:1, b:{ c: 2, d: { e: 3, f: {} } })
+      @hash = Hashie::Bash.new(a: 1, b: { c: 2, d: { e: 3, f: {} } })
     end
 
     it 'has first layer keys' do

data/spec/utilise/{augment/string_spec.rb → string_spec.rb}

@@ -45,19 +45,19 @@ describe String do
 
   describe '#camel' do
     it 'returns a camel case from camel case' do
-      expect('CamelCase'.camel).to eq 'CamelCase'
+      expect('CamelCase'.camel).to eq 'camelCase'
     end
 
     it 'returns a camel case from snake case' do
-      expect('camel_case'.camel).to eq 'CamelCase'
+      expect('camel_case'.camel).to eq 'camelCase'
     end
 
     it 'returns a camel case from space case' do
-      expect('camel case'.camel).to eq 'CamelCase'
+      expect('camel case'.camel).to eq 'camelCase'
     end
 
     it 'returns a camel case from complex camel case' do
-      expect('CamelONECase'.camel).to eq 'CamelOneCase'
+      expect('CamelONECase'.camel).to eq 'camelOneCase'
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: utilise
 version: !ruby/object:Gem::Version
-  version: 0.5.0.pre.42
+  version: 0.5.0.pre.47
 platform: ruby
 authors:
 - Ben Slaughter
@@ -120,6 +120,7 @@ files:
 - lib/utilise/array.rb
 - lib/utilise/augment/bool.rb
 - lib/utilise/augment/crash.rb
+- lib/utilise/augment/hash.rb
 - lib/utilise/augment/matchers.rb
 - lib/utilise/augment/modify.rb
 - lib/utilise/augment/time.rb
@@ -132,14 +133,14 @@ files:
 - lib/utilise/time.rb
 - lib/utilise/version.rb
 - spec/spec_helper.rb
-- spec/utilise/augment/array_spec.rb
-- spec/utilise/augment/fixnum_spec.rb
-- spec/utilise/augment/hash_spec.rb
-- spec/utilise/augment/hashie_spec.rb
-- spec/utilise/augment/object_spec.rb
-- spec/utilise/augment/string_spec.rb
-- spec/utilise/augment/symbol_spec.rb
-- spec/utilise/augment/time_spec.rb
+- spec/utilise/array_spec.rb
+- spec/utilise/fixnum_spec.rb
+- spec/utilise/hash_spec.rb
+- spec/utilise/hashie_spec.rb
+- spec/utilise/object_spec.rb
+- spec/utilise/string_spec.rb
+- spec/utilise/symbol_spec.rb
+- spec/utilise/time_spec.rb
 - spec/utilise/version_spec.rb
 homepage: http://benslaughter.github.io/utilise/
 licenses:
@@ -167,12 +168,12 @@ specification_version: 4
 summary: Utilises a few extra methods
 test_files:
 - spec/utilise/version_spec.rb
-- spec/utilise/augment/time_spec.rb
-- spec/utilise/augment/symbol_spec.rb
-- spec/utilise/augment/string_spec.rb
-- spec/utilise/augment/object_spec.rb
-- spec/utilise/augment/hashie_spec.rb
-- spec/utilise/augment/hash_spec.rb
-- spec/utilise/augment/fixnum_spec.rb
-- spec/utilise/augment/array_spec.rb
+- spec/utilise/time_spec.rb
+- spec/utilise/symbol_spec.rb
+- spec/utilise/string_spec.rb
+- spec/utilise/object_spec.rb
+- spec/utilise/hashie_spec.rb
+- spec/utilise/hash_spec.rb
+- spec/utilise/fixnum_spec.rb
+- spec/utilise/array_spec.rb
 - spec/spec_helper.rb

data/spec/utilise/augment/hash_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe Hash do
-  describe '#to_bool' do
-    it 'returns hash with true when key value is 1' do
-      expect({ 'key' => 1 }.to_bool).to eql('key' => true)
-    end
-
-    it 'returns hash with false when key value is 0' do
-      expect({ 'key' => 0 }.to_bool).to eql('key' => false)
-    end
-
-    it 'returns original hash when key value is not 0 or 1' do
-      expect({ 'key' => 2 }.to_bool).to eql('key' => 2)
-    end
-
-    it "returns hash with true when key value is 'yes'" do
-      expect({ 'key' => 'yes' }.to_bool).to eql('key' => true)
-    end
-
-    it "returns hash with false when key value is 'no'" do
-      expect({ 'key' => 'no' }.to_bool).to eql('key' => false)
-    end
-
-    it "returns hash with true when key value is 'true'" do
-      expect({ 'key' => 'true' }.to_bool).to eql('key' => true)
-    end
-
-    it "returns hash with false when key value is 'false'" do
-      expect({ 'key' => 'false' }.to_bool).to eql('key' => false)
-    end
-
-    it "returns original hash when key value is not 'yes', 'no', 'true or 'false'" do
-      expect({ 'key' => 'value' }.to_bool).to eql('key' => 'value')
-    end
-
-    it 'returns hash with true when key value is :t' do
-      expect({ 'key' => :t }.to_bool).to eql('key' => true)
-    end
-
-    it 'returns hash with false when key value is :f' do
-      expect({ 'key' => :f }.to_bool).to eql('key' => false)
-    end
-
-    it 'returns hash with true when key value is :t' do
-      expect({ 'key' => :yes }.to_bool).to eql('key' => true)
-    end
-
-    it 'returns hash with false when key value is :f' do
-      expect({ 'key' => :no }.to_bool).to eql('key' => false)
-    end
-
-    it 'returns hash with true when key value is :true' do
-      expect({ 'key' => :true }.to_bool).to eql('key' => true)
-    end
-
-    it 'returns hash with false when key value is :false' do
-      expect({ 'key' => :false }.to_bool).to eql('key' => false)
-    end
-
-    it 'returns original hash when key value is not :t or :n' do
-      expect({ 'key' => :symbol }.to_bool).to eql('key' => :symbol)
-    end
-
-    it 'returns correct hash with multiple values' do
-      expect({ 'key0' => 1, 'key1' => 0, 'key2' => 'yes', 'key3' => 'false', 'key4' => :t, 'key4' => :f, 'key5' => :true, 'key6' => :false }.to_bool).to eql('key0' => true, 'key1' => false, 'key2' => true, 'key3' => false, 'key4' => true, 'key4' => false, 'key5' => true, 'key6' => false)
-    end
-
-    it 'returns correct multi-level hash with multiple values' do
-      expect({ 'key0' => { 'key1' => 1 }, 'key2' => { 'key3' => 0 } }.to_bool).to eql('key0' => { 'key1' => true }, 'key2' => { 'key3' => false })
-    end
-  end
-end