camel_snake_keys 0.0.3 → 0.0.7

data/.ruby-version

@@ -0,0 +1 @@
+3.0.1

data/.travis.yml

@@ -0,0 +1,31 @@
+language: ruby
+before_install:
+  - gem install bundler -v 1.17.3
+  - gem install rspec
+install: bundle install --jobs=1 --retry=1
+script:
+  - bundle install
+  - bundle exec rspec
+
+rvm:
+  - 2.3.1
+#  - 2.4.0
+#  - 2.5.0
+#  - ruby-head
+#  - jruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+env:
+  global:
+    - JRUBY_OPTS="-J-Xmx1024m --debug"
+
+notifications:
+  email:
+    recipients:
+    - buermann@gmail.com
+    on_success: change
+    on_failure: always

data/CHANGELOG.md

@@ -1,4 +1,17 @@
+0.0.7 2/08/2022
+==============
+
+Support Ruby 3+
+
+0.0.6 4/07/2020
+==============
+
+### Bug fix
+
+Pass the indifferent access flag down the recursion.
+
 0.0.3 5/11/2016
+==============
 
 ### Features
 

data/Gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
-gem 'rspec'
-gem 'rake'
 gem 'activesupport'
+gem 'coveralls'
 gem 'hashie'
-gem 'coveralls', require: false
+gem 'rake'
+gem 'rspec'
+gem 'rspec-core'

data/README.md

@@ -1,20 +1,31 @@
 # camel_snake_keys
 
-Add recursive with_snake_keys and with_camel_keys to Enumerable without converting everything into a string.
+[![Gem Version][GV img]][Gem Version]
+[![Build Status][BS img]][Build Status]
+[![Coverage Status][CS img]][Coverage Status]
 
-## Documentation
+[Gem Version]: https://rubygems.org/gems/camel_snake_keys
+[Build Status]: https://travis-ci.org/buermann/camel_snake_keys
+[travis pull requests]: https://travis-ci.org/buermann/camel_snake_keys/pull_requests
+[Coverage Status]: https://coveralls.io/r/buermann/camel_snake_keys
+
+[GV img]: https://badge.fury.io/rb/camel_snake_keys.png
+[BS img]: https://travis-ci.org/buermann/camel_snake_keys.png
+[CS img]: https://coveralls.io/repos/buermann/camel_snake_keys/badge.png?branch=master
 
-Add gem 'camel_snake_keys' to your gemfile or gem install camel_snake_keys.
 
-Enumerables will be monkey patched the following methods:
+Add recursive with_snake_keys and with_camel_keys refinements to Array and Hash. Preserve strings and symbols and treat hash descendents such as ActiveSupport::HashWithIndifferentAccess and Hashie::Mash agnostically.
 
-with_snake_keys(with_indifferent=false) 
-with_camel_keys(with_indifferent=false)
+## Documentation
+
+Add `gem 'camel_snake_keys'` to your Gemfile or gem install camel_snake_keys. Where you want to add `with_snake_keys` and `with_camel_keys` to your objects invoke `using CamelSnakeKeys`, or invoke the class methods, `CamelSnakeKeys.camel_keys(object, with_indifference)` and `CamelSnakeKeys.snake_keys(object, with_indifference)`.
 
 If with_indifference is set to a true value hashes will be returned as ActiveSupport's HashWithIndifferentAccess.
 
 ```
-require './lib/camel_snake_keys'
+require 'camel_snake_keys'
+
+using CamelSnakeKeys
 
 {fooBar: "Frob"}.with_snake_keys
 => {:foo_bar=>"Frob"}

data/Rakefile

@@ -15,4 +15,3 @@ RDoc::Task.new(:rdoc) do |rdoc|
 end
 
 Bundler::GemHelper.install_tasks
-

data/camel_snake.gemspec

@@ -1,24 +1,25 @@
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path('lib', __dir__)
 
 # Maintain your gem's version:
-require "version"
+require 'version'
 
 # Describe your gem and declare its dependencies:
 Gem::Specification.new do |s|
-  s.name        = "camel_snake_keys"
+  s.name        = 'camel_snake_keys'
   s.version     = CamelSnakeKeys::VERSION
-  s.authors     = ["Josh Buermann"]
-  s.email       = ["buermann@gmail.com"]
-  s.homepage    = "https://github.com/buermann/camel_snake_keys"
-  s.summary     = "Convert nested data structure hash keys between camel and snake case."
-  s.description = ""
-  s.license     = "MIT"
+  s.authors     = ['Josh Buermann']
+  s.email       = ['buermann@gmail.com']
+  s.homepage    = 'https://github.com/buermann/camel_snake_keys'
+  s.summary     = 'Convert nested data structure hash keys between camel and snake case.'
+  s.description = ''
+  s.license     = 'MIT'
 
   s.files         = `git ls-files`.split("\n").sort
   s.test_files    = `git ls-files -- spec/*`.split("\n")
 
-  s.required_ruby_version = '~> 2.0'
-  s.add_dependency "activesupport"
+  s.required_ruby_version = '> 2.0'
+  s.add_dependency 'activesupport'
 
-  s.add_development_dependency "rspec-rails", '>= 3.0'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'activesupport'
 end

data/lib/camel_snake_keys.rb

@@ -1,61 +1,66 @@
-require 'active_support/core_ext/hash'
-require 'active_support/core_ext/string/inflections'
-require 'hashie/mash'
+require 'active_support'
+require 'active_support/core_ext'
 
 module CamelSnakeKeys
+  [Hash, Array].each do |klass|
+    refine klass do
+      def with_camel_keys(indifference=false)
+        CamelSnakeKeys.camel_keys(self, indifference)
+      end
+
+      def with_snake_keys(indifference=false)
+        CamelSnakeKeys.snake_keys(self, indifference)
+      end
+    end
+  end
+
   class << self
-    def if_underscore(v)
-      if v.is_a? Symbol
-        v.to_s.underscore.to_sym
-      elsif v.is_a? String
-        v.underscore
+    def if_underscore(obj)
+      case obj
+      when Symbol
+        obj.to_s.underscore.to_sym
+      when String
+        obj.underscore
       else
-        v
+        obj
       end
     end
 
-    def if_camelize(v)
-      if v.is_a? Symbol
-        v.to_s.camelize(:lower).to_sym
-      elsif v.is_a? String
-        v.camelize(:lower)
+    def if_camelize(obj)
+      case obj
+      when Symbol
+        obj.to_s.camelize(:lower).to_sym
+      when String
+        obj.camelize(:lower)
       else
-        v
+        obj
       end
     end
 
     def snake_keys(data, indifference=false)
-      if data.kind_of? Array
-        data.map { |v| snake_keys(v) }
-      elsif data.kind_of? Hash
-        hash = Hash[data.map {|k, v| [if_underscore(k), snake_keys(v)] }]
+      case data
+      when Array
+        data.map { |v| snake_keys(v, indifference) }
+      when Hash
+        hash = data.sort_by {|k, _v| k =~ /_/ ? 0 : 1 }.map {|k, v| [if_underscore(k), snake_keys(v, indifference)] }.to_h
         hash = hash.with_indifferent_access if indifference
-        data.class == Hash ? hash : data.class.new(hash)
+        data.instance_of?(Hash) ? hash : data.class.new(hash)
       else
         data
       end
     end
 
     def camel_keys(data, indifference=false)
-      if data.kind_of? Array
-        data.map { |v| camel_keys(v) }
-      elsif data.kind_of? Hash
-        hash = Hash[data.map {|k, v| [if_camelize(k), camel_keys(v)] }]
+      case data
+      when Array
+        data.map { |v| camel_keys(v, indifference) }
+      when Hash
+        hash = data.sort_by {|k, _v| k =~ /_/ ? 1 : 0 }.map {|k, v| [if_camelize(k), camel_keys(v, indifference)] }.to_h
         hash = hash.with_indifferent_access if indifference
-        data.class == Hash ? hash : data.class.new(hash)
+        data.instance_of?(Hash) ? hash : data.class.new(hash)
       else
         data
       end
     end
   end
 end
-
-module Enumerable
-  def with_camel_keys(indifference=false)
-    CamelSnakeKeys.camel_keys(self, indifference)
-  end
-
-  def with_snake_keys(indifference=false)
-    CamelSnakeKeys.snake_keys(self, indifference)
-  end
-end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module CamelSnakeKeys
-  VERSION = "0.0.3".freeze
+  VERSION = '0.0.7'.freeze
 
   def self.version
     VERSION

data/spec/lib/camel_snake_keys_spec.rb

@@ -1,4 +1,7 @@
 require 'test_helper'
+require 'hashie/mash'
+
+using CamelSnakeKeys
 
 RSpec.describe Enumerable do
 
@@ -13,6 +16,7 @@ RSpec.describe Enumerable do
     it "should camel case keys of hashes" do
       snaked.with_camel_keys.should eq camelized
     end
+
   end
 
   context "hashes" do
@@ -21,94 +25,154 @@ RSpec.describe Enumerable do
 
     it "should snake case keys of hashes" do
       hash = camelized.with_snake_keys
-      hash.class.should == Hash
+      hash.class.should eq Hash
       hash.should eq snaked
     end
 
     it "should camel case keys of hashes" do
       hash = snaked.with_camel_keys
-      hash.class.should == Hash
+      hash.class.should eq Hash
       hash.should eq camelized
     end
 
+    it "should preserve symbol keys" do
+      camelized.with_snake_keys[:foo_bar].should_not be_nil
+      camelized.with_snake_keys['foo_bar'].should be_nil
+      snaked.with_camel_keys[:fooBar].should be_present
+      snaked.with_camel_keys['fooBar'].should be_nil
+    end
+
+    it "should preserve string keys" do
+      camelized.with_snake_keys['dark_matter'].should be_present
+      camelized.with_snake_keys[:dark_matter].should be_nil
+      snaked.with_camel_keys['darkMatter'].should be_present
+      snaked.with_camel_keys[:darkMatter].should be_nil
+    end
+
     it "should snake case keys of hashes with indifference" do
       hash = camelized.with_snake_keys(true)
-      hash.class.should == HashWithIndifferentAccess
+      hash.class.should eq HashWithIndifferentAccess
       hash.should eq snaked.with_indifferent_access
       hash[:foo_bar].should eq hash["foo_bar"]
     end
 
     it "should camel case keys of hashes with indifference" do
       hash = snaked.with_camel_keys(true)
-      hash.class.should == HashWithIndifferentAccess
+      hash.class.should eq HashWithIndifferentAccess
       hash.should eq camelized.with_indifferent_access
       hash["fooBar"].should eq hash[:fooBar]
     end
 
   end
 
-  context "hashes with indifferent access" do 
+  context "hashes with indifferent access" do
     let(:snaked) { {1.2=>1, 1=>1.2, nil=>2, :foo_bar=>1, "dark_matter"=>[{:dark_energy=>"aBc", "baz_qux"=>"Frob."}]}.with_indifferent_access }
     let(:camelized) { { 1.2=>1, 1=>1.2, nil=>2, :fooBar=>1, "darkMatter"=>[{:darkEnergy=>"aBc", "bazQux"=>"Frob."}]}.with_indifferent_access }
 
     it "should snake case keys of hashes" do
       hash = camelized.with_snake_keys
-      hash.class.should == HashWithIndifferentAccess
+      hash.class.should eq HashWithIndifferentAccess
       hash.should eq snaked
     end
 
     it "should camel case keys of hashes" do
       hash = snaked.with_camel_keys
-      hash.class.should == HashWithIndifferentAccess
+      hash.class.should eq HashWithIndifferentAccess
       hash.should eq camelized
     end
 
     it "should snake case keys of hashes with indifference" do
       hash = camelized.with_snake_keys(true)
-      hash.class.should == HashWithIndifferentAccess
+      hash.class.should eq HashWithIndifferentAccess
       hash.should eq snaked
     end
 
     it "should camel case keys of hashes with indifference" do
       hash = snaked.with_camel_keys(true)
-      hash.class.should == HashWithIndifferentAccess
+      hash.class.should eq HashWithIndifferentAccess
       hash.should eq camelized
     end
 
   end
 
-  context "mashes" do 
+  context "mashes" do
     let(:snaked) { Hashie::Mash.new({1.2=>1, 1=>1.2, nil=>2, :foo_bar=>1, "dark_matter"=>[{:dark_energy=>"aBc", "baz_qux"=>"Frob."}]}) }
     let(:camelized) { Hashie::Mash.new({ 1.2=>1, 1=>1.2, nil=>2, :fooBar=>1, "darkMatter"=>[{:darkEnergy=>"aBc", "bazQux"=>"Frob."}]}) }
 
     it "should snake case keys of hashes" do
       hash = camelized.with_snake_keys
-      hash.class.should == Hashie::Mash
+      hash.class.should eq Hashie::Mash
       hash.should eq snaked
-      hash["fooBar"].should == hash[:fooBar]
+      hash["fooBar"].should eq hash[:fooBar]
     end
 
     it "should camel case keys of hashes" do
       hash = snaked.with_camel_keys
-      hash.class.should == Hashie::Mash
+      hash.class.should eq Hashie::Mash
       hash.should eq camelized
-      hash["foo_bar"].should == hash[:foo_bar]
+      hash["foo_bar"].should eq hash[:foo_bar]
     end
- 
+
     it "should snake case keys of hashes with redundant indifference" do
       hash = camelized.with_snake_keys(true)
-      hash.class.should == Hashie::Mash
+      hash.class.should eq Hashie::Mash
       hash.should eq snaked
-      hash["foo_bar"].should == hash[:foo_bar]
+      hash["foo_bar"].should eq hash[:foo_bar]
     end
 
     it "should camel case keys of hashes with redundant indifference" do
       hash = snaked.with_camel_keys(true)
-      hash.class.should == Hashie::Mash
+      hash.class.should eq Hashie::Mash
       hash.should eq camelized
-      hash["foo_bar"].should == hash[:foo_bar]
+      hash["foo_bar"].should eq hash[:foo_bar]
     end
- 
+
   end
 
+  context "hash merge conflicts should be resolved predictably" do
+    it "should give camel case key values priority when snake casing" do
+      hash   = { foo_bar: 1, fooBar: 2 }
+      result = { foo_bar: 2 }
+      hash.with_snake_keys.should eq result
+
+      hash = { fooBar: 2, foo_bar: 1 }
+      hash.with_snake_keys.should eq result
+    end
+
+    it "should give snake case key values priority when camel casing" do
+      hash   = { foo_bar: 1, fooBar: 2 }
+      result = { fooBar: 1 }
+      hash.with_camel_keys.should eq result
+
+      hash = { fooBar: 2, foo_bar: 1 }
+      hash.with_camel_keys.should eq result
+    end
+  end
+
+  context "it should pass indifference down deeply nested structures" do
+    it "camelizing an array of hashes" do
+      camelized = [ a: { b: [{c: :d}] } ].with_camel_keys(true)
+      camelized.first[:a].is_a?(HashWithIndifferentAccess).should be_truthy
+      camelized.first[:a][:b].first.is_a?(HashWithIndifferentAccess).should be_truthy
+    end
+
+    it "cazemlizing a hashes of arrays" do
+      camelized = { a: [{b: {c: :d}}]}.with_camel_keys(true)
+      camelized.is_a?(HashWithIndifferentAccess).should be_truthy
+      camelized[:a].first[:b].is_a?(HashWithIndifferentAccess).should be_truthy
+    end
+
+    it "snaking an array of hashes" do
+      snaked = [ a: { b: [{c: :d}] } ].with_snake_keys(true)
+      snaked.first[:a].is_a?(HashWithIndifferentAccess).should be_truthy
+      snaked.first[:a][:b].first.is_a?(HashWithIndifferentAccess).should be_truthy
+    end
+
+    it "snaking a hashes of arrays" do
+      snaked = { a: [{b: {c: :d}}]}.with_snake_keys(true)
+      snaked.is_a?(HashWithIndifferentAccess).should be_truthy
+      snaked[:a].first[:b].is_a?(HashWithIndifferentAccess).should be_truthy
+    end
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: camel_snake_keys
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.7
 platform: ruby
 authors:
 - Josh Buermann
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-12 00:00:00.000000000 Z
+date: 2022-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,19 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 description: ''
 email:
 - buermann@gmail.com
@@ -48,6 +62,8 @@ files:
 - ".coveralls.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -61,13 +77,13 @@ homepage: https://github.com/buermann/camel_snake_keys
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">"
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -76,9 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Convert nested data structure hash keys between camel and snake case.
 test_files: