camel_snake_keys 0.0.7 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7969aad0c0f379d148318435d02673f72be7938e6cbb33a084df50a79261f11f
-  data.tar.gz: a5841106f20246186321b692f612ee64d28cef2d8568589f769a5e8765badf0f
+  metadata.gz: 7a43ef9734380b43f45291290bb618394c59d90f5f4b4063971a43a3c3580fba
+  data.tar.gz: 23d0e08b903cf6ed0db29576f2f6fe9258b897ce93e9c2cea2c158bc0d93a142
 SHA512:
-  metadata.gz: 7f154ed7f42d8c3061a71c708e6c9265ea965698f97c6ce367433ec7d0ec472d1ee52253b71b6c9b9e80d25cd4db0ab62d8a7027bb1688685d853655dc4b996f
-  data.tar.gz: 7c97476f9e93bc057daf1e6d71f376fb681e50f12797d9862147ca8fcff8700872f641e3426e88c02c7fccc04e4d7aade342e67c1193ebf90f1ebf6ca697ca52
+  metadata.gz: a7bc99bde80faed7b2de698ade5e57b0141ad2b017f7c6d6b57f6cc038d3ca0128aded3712fd51ebb43b50debea74c8e208b167a0fa9a84f7d049881d2730f34
+  data.tar.gz: 3f8f91a41a00d89683b4309e771c788f6ff6ba6fc7a0d0faf7576b5ddfa6a13d23d813b03d6e856ddbe7e7dbbffa0fbadf4dd2ff374af9b519fbac1e15fb1519

data/.github/workflows/main.yml

@@ -0,0 +1,79 @@
+name: Verify
+on: push
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v2
+      - name: Install dependencies for the Fog gem
+        run: |
+          sudo apt-get update
+          sudo apt-get install libcurl4-openssl-dev
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7.3
+      - name: Cache Ruby Gems
+        uses: actions/cache@v2
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-gems-
+      - name: Bundle Install
+        run: |
+          gem install bundler
+          bundle config path vendor/bundle
+          bundle install --jobs 4 --retry 3
+      - name: Formatting Checks
+        run: |
+          bundle exec rubocop
+  security:
+    name: Security
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v2
+      - name: Install dependencies for the Fog gem
+        run: |
+          sudo apt-get update
+          sudo apt-get install libcurl4-openssl-dev
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7.3
+      - name: Cache Ruby Gems
+        uses: actions/cache@v2
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-gems-
+      - name: Bundle Install
+        run: |
+          gem install bundler
+          bundle config path vendor/bundle
+          bundle install --jobs 4 --retry 3
+      - name: Security Checks
+        run: |
+          bundle exec brakeman -z --force
+          gem install bundle-audit
+          bundle-audit update
+          bundle-audit
+  tests:
+    name: Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Setup Ruby and install gems
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7.3
+          bundler-cache: true
+      - name: Rspec
+        run: |
+          bundle exec rspec
+

data/.gitignore

@@ -4,3 +4,4 @@ log/*.log
 Gemfile.lock
 pkg/
 .DS_Store
+.byebug_history

data/.rubocop.yml

@@ -1,96 +1,13 @@
 AllCops:
+  TargetRubyVersion: 2.3
   NewCops: enable
   Exclude:
     - 'spec/**/*'
-    - 'db/**/*'
-    - 'bin/*'
-    - 'Gemfile'
     - 'vendor/**/*'
 
-Gemspec/OrderedDependencies:
-  Enabled: false # I like to group them, so what?
-
-Metrics/BlockLength:
-  Max: 30
-  Exclude: # Grape's DSL rather expects large blocks
-    - app/api/location_service/**/*
-
-Metrics/MethodLength:
-  Max: 30
-
-Metrics/ClassLength:
-  Max: 180
-
-Metrics/AbcSize:
-  Max: 20
-
-Metrics/PerceivedComplexity:
-  Max: 12
-
 Metrics/CyclomaticComplexity:
   Max: 12
 
-Layout/LineLength:
-  Enabled: false
-
-Layout/EndOfLine:
-  Enabled: false
-
-Layout/ExtraSpacing:
-  Enabled: false
-
-Layout/HashAlignment:
-  # I like to space repeated grammars out tabulated, defund these cops
-  Enabled: false
-
-Layout/SpaceAroundEqualsInParameterDefault:
-  Enabled: false
-
-Layout/EmptyLinesAroundExceptionHandlingKeywords:
-  Enabled: false
-
-Layout/FirstHashElementIndentation:
-  Enabled: false
-
-Layout/LeadingCommentSpace:
-  Enabled: false
-
-Layout/MultilineOperationIndentation: # works very poorly
-  Enabled: false
-
-Layout/MultilineMethodCallIndentation:
-  Enabled: false
-
-Layout/SpaceInsideBlockBraces:
-  Enabled: false
-
-Layout/SpaceInsideParens:
-  Enabled: false
-
-Layout/SpaceAroundOperators:
-  Enabled: false
-
-Layout/SpaceBeforeFirstArg:
-  Enabled: false
-
-Style/BlockDelimiters:
-  Enabled: false
-
-Style/FrozenStringLiteralComment:
-  Enabled: false
-
-Style/Documentation:
-  Enabled: false
-
-Style/ParallelAssignment:
-  Enabled: false
-
-Style/PercentLiteralDelimiters:
-  Enabled: false
-
-Style/RaiseArgs:
-  Enabled: false
-
-Style/RedundantBegin:
+Style/PerlBackrefs:
   Enabled: false
 

data/.ruby-version

@@ -1 +1 @@
-3.0.1
+3.3.0

data/CHANGELOG.md

@@ -1,24 +1,44 @@
-0.0.7 2/08/2022
-==============
+1.0.0 01/31/2024
+================
+
+Test against Ruby 3.3.0.
+
+Don't let integer hash keys unleashed the bees.
+
+Fix an introduced bug that produces leading underscores when snaking PascalCase.
+
+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 4/07/2020
-==============
+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,7 +1,13 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
+gemspec
 gem 'activesupport'
+gem 'brakeman'
+gem 'byebug'
 gem 'coveralls'
 gem 'hashie'
 gem 'rake'
 gem 'rspec'
 gem 'rspec-core'
+gem 'rubocop'

data/README.md

@@ -1,26 +1,15 @@
 # camel_snake_keys
 
 [![Gem Version][GV img]][Gem Version]
-[![Build Status][BS img]][Build 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
-[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 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

data/camel_snake.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.push File.expand_path('lib', __dir__)
 
 # Maintain your gem's version:
@@ -14,12 +16,14 @@ Gem::Specification.new do |s|
   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.required_ruby_version = '> 2.3'
   s.add_dependency 'activesupport'
 
-  s.add_development_dependency 'rspec'
   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,26 +1,41 @@
-require 'active_support'
-require 'active_support/core_ext'
+# frozen_string_literal: true
 
+# Convert the keys of hashes in nested structures to camel or snake case.
 module CamelSnakeKeys
   [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 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[0] = string[0].downcase if string[0]
+      string.gsub!(/([A-Z])/) { "_#{$1}" }
+      string.downcase!
+      string
+    end
+
     def if_underscore(obj)
       case obj
       when Symbol
-        obj.to_s.underscore.to_sym
+        snakecase(obj.to_s).to_sym
       when String
-        obj.underscore
+        snakecase(obj)
       else
         obj
       end
@@ -29,34 +44,32 @@ module CamelSnakeKeys
     def if_camelize(obj)
       case obj
       when Symbol
-        obj.to_s.camelize(:lower).to_sym
+        camelcase(obj.to_s).to_sym
       when String
-        obj.camelize(:lower)
+        camelcase(obj)
       else
         obj
       end
     end
 
-    def snake_keys(data, indifference=false)
+    def snake_keys(data)
       case data
       when Array
-        data.map { |v| snake_keys(v, indifference) }
+        data.map { |v| snake_keys(v) }
       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
+        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)
+    def camel_keys(data)
       case data
       when Array
-        data.map { |v| camel_keys(v, indifference) }
+        data.map { |v| camel_keys(v) }
       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
+        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

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.7'.freeze
+  VERSION = '1.1.0'
 
   def self.version
     VERSION

data/spec/lib/camel_snake_keys_spec.rb

@@ -1,136 +1,191 @@
 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
+
+    it "handles pascal case (destructively)" do
+      CamelSnakeKeys.camelcase("pascal_case").should eq "pascalCase"
+      CamelSnakeKeys.snakecase("PascalCase").should eq "pascal_case"
+    end
+  end
+
+  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
+    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,9 +194,10 @@ 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 }
@@ -149,30 +205,29 @@ RSpec.describe Enumerable do
     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)
+  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(true)
+    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(true)
+    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(true)
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: camel_snake_keys
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 1.1.0
 platform: ruby
 authors:
 - Josh Buermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-08 00:00:00.000000000 Z
+date: 2024-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: brakeman
+  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: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -60,10 +88,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".coveralls.yml"
+- ".github/workflows/main.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby-version"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -76,7 +104,8 @@ files:
 homepage: https://github.com/buermann/camel_snake_keys
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -85,17 +114,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Convert nested data structure hash keys between camel and snake case.
-test_files:
-- spec/lib/camel_snake_keys_spec.rb
-- spec/test_helper.rb
+test_files: []

data/.travis.yml

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