camel_snake_keys 0.0.6 → 1.0.0

data/.ruby-version

@@ -1 +1 @@
-2.3.0
+3.3.0

data/CHANGELOG.md

@@ -1,19 +1,40 @@
-0.0.6 4/07/2020
-==============
+1.0.0 01/31/2024
+================
+
+Don't let integer hash keys raise your enemies up. Test against Ruby 3.3.0.
+
+0.1.0 10/14/2022
+================
+
+ActiveSupport::Inflector's camelize and underscore methods convert "::" to "/" and "/" to "::", which might be useful in Rails' internals, but in the context of a Grape API it corrupts the swagger docs' "paths" objects.
+
+Implement our own camel and snake case methods that leave "::" and "/" unmolested, rather than relying on ActiveSupport, in which case we'll drop that dependency altogether by removing the (trivially re-implemented) indifferent access functionality.
+
+We are not re-implmenting ActiveSupport's acronym inflections. Yet.
+
+Replace travis etc. with github actions.
+
+0.0.7 02/08/2022
+================
+
+Support Ruby 3+
+
+0.0.6 04/07/2020
+===============
 
 ### Bug fix
 
 Pass the indifferent access flag down the recursion.
 
-0.0.3 5/11/2016
-==============
+0.0.3 05/11/2016
+================
 
 ### Features
 
 Preserve any descendent of Hash that accepts a Hash in its initialize method, as with ActiveSupport::HashWithIndifferentAccess and Hashie::Mash
 
-0.0.2 5/11/2016
-==============
+0.0.2 05/11/2016
+================
 
 ### Features
 

data/Gemfile

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
-gem 'activesupport', '~> 4.2'
-gem 'coveralls', require: false
+gemspec
+gem 'activesupport'
+gem 'brakeman'
+gem 'byebug'
+gem 'coveralls'
 gem 'hashie'
 gem 'rake'
 gem 'rspec'
+gem 'rspec-core'
+gem 'rubocop'

data/README.md

@@ -1,29 +1,15 @@
 # camel_snake_keys
 
 [![Gem Version][GV img]][Gem Version]
-[![Build Status][BS img]][Build Status]
-[![Dependency Status][DS img]][Dependency Status]
-[![Coverage Status][CS img]][Coverage Status]
-
 [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
-[Dependency Status]: https://gemnasium.com/buermann/camel_snake_keys
-[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
-[DS img]: https://gemnasium.com/buermann/camel_snake_keys.png
-[CS img]: https://coveralls.io/repos/buermann/camel_snake_keys/badge.png?branch=master
-
 
 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.
 
 ## 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)`.
+Add `gem 'camel_snake_keys'` to your Gemfile or "gem install camel_snake_keys".
 
-If with_indifference is set to a true value hashes will be returned as ActiveSupport's HashWithIndifferentAccess.
+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)` and `CamelSnakeKeys.snake_keys(object)`.
 
 ```
 require 'camel_snake_keys'

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -15,4 +17,3 @@ RDoc::Task.new(:rdoc) do |rdoc|
 end
 
 Bundler::GemHelper.install_tasks
-

data/camel_snake.gemspec

@@ -1,25 +1,29 @@
-$:.push File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+$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.files = `git ls-files`.split("\n").sort
 
-  s.required_ruby_version = '~> 2.0'
-  s.add_dependency "activesupport"
+  s.required_ruby_version = '> 2.3'
+  s.add_dependency 'activesupport'
 
-  s.add_development_dependency "rspec-rails", '>= 3.0'
-  s.add_development_dependency "activesupport", '~> 4.2'
+  s.add_development_dependency 'activesupport'
+  s.add_development_dependency 'brakeman'
+  s.add_development_dependency 'byebug'
+  s.add_development_dependency 'rspec'
+  s.metadata['rubygems_mfa_required'] = 'true'
 end

data/lib/camel_snake_keys.rb

@@ -1,64 +1,78 @@
-require 'active_support/core_ext/hash'
-require 'active_support/core_ext/string/inflections'
+# frozen_string_literal: true
 
+# Convert the keys of hashes in nested structures to camel or snake case.
 module CamelSnakeKeys
-  [Hash,Array].each do |klass|
+  [Hash, Array].each do |klass|
     refine klass do
-      def with_camel_keys(indifference=false)
-        CamelSnakeKeys.camel_keys(self, indifference)
+      def with_camel_keys
+        CamelSnakeKeys.camel_keys(self)
       end
 
-      def with_snake_keys(indifference=false)
-        CamelSnakeKeys.snake_keys(self, indifference)
+      def with_snake_keys
+        CamelSnakeKeys.snake_keys(self)
       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 camelcase(obj)
+      string = +obj.to_s # unfreeze whatever it might be with a leading +
+      string.sub!(/^([A-Z])/) { $1.downcase }
+      string.gsub!(/_([a-z\d])/) { $1.capitalize }
+      string
+    end
+
+    def snakecase(obj)
+      string = +obj.to_s
+      string.gsub!(/([A-Z])/) { "_#{$1}" }
+      string.downcase!
+      string
+    end
+
+    def if_underscore(obj)
+      case obj
+      when Symbol
+        snakecase(obj.to_s).to_sym
+      when String
+        snakecase(obj)
       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
+        camelcase(obj.to_s).to_sym
+      when String
+        camelcase(obj)
       else
-        v
+        obj
       end
     end
 
-    def snake_keys(data, indifference=false)
-      if data.kind_of? Array
-        data.map { |v| snake_keys(v, indifference) }
-      elsif data.kind_of? Hash
-        hash = Hash[data.sort_by {|k,_v| k =~ /_/ ? 0 : 1 }.map {|k, v| [if_underscore(k), snake_keys(v, indifference)] }]
-        hash = hash.with_indifferent_access if indifference
-        data.class == Hash ? hash : data.class.new(hash)
+    def snake_keys(data)
+      case data
+      when Array
+        data.map { |v| snake_keys(v) }
+      when Hash
+        hash = data.sort_by { |k, _v| k.to_s =~ /_/ ? 0 : 1 }.to_h { |k, v| [if_underscore(k), snake_keys(v)] }
+        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, indifference) }
-      elsif data.kind_of? Hash
-        hash = Hash[data.sort_by {|k,_v| k =~ /_/ ? 1 : 0 }.map {|k, v| [if_camelize(k), camel_keys(v, indifference)] }]
-        hash = hash.with_indifferent_access if indifference
-        data.class == Hash ? hash : data.class.new(hash)
+    def camel_keys(data)
+      case data
+      when Array
+        data.map { |v| camel_keys(v) }
+      when Hash
+        hash = data.sort_by { |k, _v| k.to_s =~ /_/ ? 1 : 0 }.to_h { |k, v| [if_camelize(k), camel_keys(v)] }
+        data.instance_of?(Hash) ? hash : data.class.new(hash)
       else
         data
       end
     end
   end
 end
-
-

data/lib/version.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
+# Store the version of the gem here rather than the gemspec
 module CamelSnakeKeys
-  VERSION = "0.0.6".freeze
+  VERSION = '1.0.0'
 
   def self.version
     VERSION

data/spec/lib/camel_snake_keys_spec.rb

@@ -1,136 +1,186 @@
 require 'test_helper'
+require 'byebug'
 require 'hashie/mash'
+require 'active_support/core_ext/hash/indifferent_access'
 
 using CamelSnakeKeys
 
 RSpec.describe Enumerable do
 
-  context "arrays" do
-    let(:snaked) { [[{true=>false, 1=>1.2, 1.2=>1, nil=>2, :foo_bar=>1, "dark_matter"=>[{:dark_energy=>"aBc", "baz_qux"=>"Frob."}]}]] }
-    let(:camelized) { [[{true=>false, 1=>1.2, 1.2=>1, nil=>2, :fooBar=>1, "darkMatter"=>[{:darkEnergy=>"aBc", "bazQux"=>"Frob."}]}]] }
+  context 'camelize and underscore' do
+    let(:underscore_to_camel) {
+      {
+        "product"                => "product",
+        "special_guest"          => "specialGuest",
+        "application_controller" => "applicationController",
+        "area51_controller"      => "area51Controller",
+        product:                    "product",
+        special_guest:              "specialGuest",
+        application_controller:     "applicationController",
+        area51_controller:          "area51Controller",
+        "camel_snake/keys"       => "camelSnake/keys",
+        "camel_snake::keys"      => "camelSnake::keys"
+      }
+    }
+    it "converts strings and symbols to camel and snake case strings as expected" do
+      underscore_to_camel.each do |k,v|
+        CamelSnakeKeys.camelcase(k).should eq v.to_s
+        CamelSnakeKeys.snakecase(v).should eq k.to_s
+      end
+    end
+
+    it "handles nils gracefully" do
+      CamelSnakeKeys.camelcase(nil).should eq ""
+      CamelSnakeKeys.snakecase(nil).should eq ""
+    end
+  end
 
-    it "should snake case keys of hashes" do
+  context 'arrays' do
+    let(:snaked) do
+      [[{ true => false, 1 => 1.2, 1.2 => 1, nil => 2, :foo_bar => 1,
+          'dark_matter' => [{ :dark_energy => 'aBc', 'baz_qux' => 'Frob.' }] }]]
+    end
+    let(:camelized) do
+      [[{ true => false, 1 => 1.2, 1.2 => 1, nil => 2, :fooBar => 1,
+          'darkMatter' => [{ :darkEnergy => 'aBc', 'bazQux' => 'Frob.' }] }]]
+    end
+
+    it 'should snake case keys of hashes' do
       camelized.with_snake_keys.should eq snaked
     end
 
-    it "should camel case keys of hashes" do
+    it 'should camel case keys of hashes' do
       snaked.with_camel_keys.should eq camelized
     end
-
   end
 
-  context "hashes" do
-    let(:snaked) { {false=>true, 1=>1.2, 1.2=>1, nil=>2, :foo_bar=>1, "dark_matter"=>[{:dark_energy=>"aBc", "baz_qux"=>"Frob."}]} }
-    let(:camelized) { {false=>true, 1=>1.2, 1.2=>1, nil=>2, :fooBar=>1, "darkMatter"=>[{:darkEnergy=>"aBc", "bazQux"=>"Frob."}]} }
+  context 'hashes' do
+    let(:snaked) do
+      { false => true, 1 => 1.2, 1.2 => 1, nil => 2, :foo_bar => 1,
+        'dark_matter' => [{ :dark_energy => 'aBc', 'baz_qux' => 'Frob.' }] }
+    end
+    let(:camelized) do
+      { false => true, 1 => 1.2, 1.2 => 1, nil => 2, :fooBar => 1,
+        'darkMatter' => [{ :darkEnergy => 'aBc', 'bazQux' => 'Frob.' }] }
+    end
 
-    it "should snake case keys of hashes" do
+    it 'should snake case keys of hashes' do
       hash = camelized.with_snake_keys
       hash.class.should eq Hash
       hash.should eq snaked
     end
 
-    it "should camel case keys of hashes" do
+    it 'should camel case keys of hashes' do
       hash = snaked.with_camel_keys
       hash.class.should eq Hash
       hash.should eq camelized
     end
 
-    it "should preserve symbol keys" do 
+    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 
+    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)
+    it 'should snake case keys of hashes with indifference' do
+      hash = camelized.with_indifferent_access.with_snake_keys
       hash.class.should eq HashWithIndifferentAccess
       hash.should eq snaked.with_indifferent_access
-      hash[:foo_bar].should eq hash["foo_bar"]
+      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)
+    it 'should camel case keys of hashes with indifference' do
+      hash = snaked.with_indifferent_access.with_camel_keys
       hash.class.should eq HashWithIndifferentAccess
       hash.should eq camelized.with_indifferent_access
-      hash["fooBar"].should eq hash[:fooBar]
+      hash['fooBar'].should eq hash[:fooBar]
     end
-
   end
 
-  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 }
+  context 'hashes with indifferent access' do
+    let(:snaked) do
+      { 1.2 => 1, 1 => 1.2, nil => 2, :foo_bar => 1,
+        'dark_matter' => [{ :dark_energy => 'aBc', 'baz_qux' => 'Frob.' }] }.with_indifferent_access
+    end
+    let(:camelized) do
+      { 1.2 => 1, 1 => 1.2, nil => 2, :fooBar => 1,
+        'darkMatter' => [{ :darkEnergy => 'aBc', 'bazQux' => 'Frob.' }] }.with_indifferent_access
+    end
 
-    it "should snake case keys of hashes" do
+    it 'should snake case keys of hashes' do
       hash = camelized.with_snake_keys
       hash.class.should eq HashWithIndifferentAccess
       hash.should eq snaked
     end
 
-    it "should camel case keys of hashes" do
+    it 'should camel case keys of hashes' do
       hash = snaked.with_camel_keys
       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)
+    it 'should snake case keys of hashes with indifference' do
+      hash = camelized.with_indifferent_access.with_snake_keys
       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)
+    it 'should camel case keys of hashes with indifference' do
+      hash = snaked.with_indifferent_access.with_camel_keys
       hash.class.should eq HashWithIndifferentAccess
       hash.should eq camelized
     end
-
   end
 
-  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."}]}) }
+  context 'mashes' do
+    let(:snaked) do
+      Hashie::Mash.new({ 1.2 => 1, 1 => 1.2, nil => 2, :foo_bar => 1,
+                         'dark_matter' => [{ :dark_energy => 'aBc', 'baz_qux' => 'Frob.' }] })
+    end
+    let(:camelized) do
+      Hashie::Mash.new({ 1.2 => 1, 1 => 1.2, nil => 2, :fooBar => 1,
+                         'darkMatter' => [{ :darkEnergy => 'aBc', 'bazQux' => 'Frob.' }] })
+    end
 
-    it "should snake case keys of hashes" do
+    it 'should snake case keys of hashes' do
       hash = camelized.with_snake_keys
       hash.class.should eq Hashie::Mash
       hash.should eq snaked
-      hash["fooBar"].should eq hash[:fooBar]
+      hash['fooBar'].should eq hash[:fooBar]
     end
 
-    it "should camel case keys of hashes" do
+    it 'should camel case keys of hashes' do
       hash = snaked.with_camel_keys
       hash.class.should eq Hashie::Mash
       hash.should eq camelized
-      hash["foo_bar"].should eq 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)
+
+    it 'should snake case keys of hashes with redundant indifference' do
+      hash = Hashie::Mash.new(camelized.with_snake_keys.with_indifferent_access)
       hash.class.should eq Hashie::Mash
       hash.should eq snaked
-      hash["foo_bar"].should eq 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)
+    it 'should camel case keys of hashes with redundant indifference' do
+      hash = Hashie::Mash.new(snaked.with_camel_keys.with_indifferent_access)
       hash.class.should eq Hashie::Mash
       hash.should eq camelized
-      hash["foo_bar"].should eq 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
+  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
@@ -139,13 +189,40 @@ RSpec.describe Enumerable do
       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 }
+    it 'should give snake case key values priority when camel casing' do
       result = { fooBar: 1 }
+
+      hash   = { foo_bar: 1, fooBar: 2 }
       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.map(&:with_indifferent_access)
+      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.with_indifferent_access
+      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.map(&:with_indifferent_access)
+      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.with_indifferent_access
+      snaked.is_a?(HashWithIndifferentAccess).should be_truthy
+      snaked[:a].first[:b].is_a?(HashWithIndifferentAccess).should be_truthy
+    end
+  end
 end