♻️ Refactor to support either string or symbol keyed Snakes

Author: pboling

Gemfile.lock

@@ -35,6 +35,8 @@ GEM
       rspec-core (~> 3.11.0)
       rspec-expectations (~> 3.11.0)
       rspec-mocks (~> 3.11.0)
+    rspec-block_is_expected (1.0.2)
+      rspec-core
     rspec-core (3.11.0)
       rspec-support (~> 3.11.0)
     rspec-expectations (3.11.0)
@@ -97,6 +99,7 @@ DEPENDENCIES
   rake (~> 13.0)
   redcarpet
   rspec (~> 3.0)
+  rspec-block_is_expected
   rubocop-lts (~> 8.0)
   rubocop-md
   rubocop-performance

lib/snaky_hash.rb

@@ -6,7 +6,10 @@
 
 require_relative "snaky_hash/version"
 require_relative "snaky_hash/snake"
+require_relative "snaky_hash/string_keyed"
+require_relative "snaky_hash/symbol_keyed"
 
+# This is the namespace for this gem
 module SnakyHash
 end
 

lib/snaky_hash/snake.rb

@@ -1,51 +1,72 @@
-require "hashie/mash"
-
+# This is a module-class hybrid.
+#
+# Hashie's standard SymbolizeKeys is similar to the functionality we want.
+# ... but not quite.  We need to support both String (for oauth2) and Symbol keys (for oauth).
+# include Hashie::Extensions::Mash::SymbolizeKeys
 module SnakyHash
-  class Snake < Hashie::Mash
-    # This is similar to the functionality we want.
-    # include Hashie::Extensions::Mash::SymbolizeKeys
-
-    protected
-
-    # Converts a key to a string,
-    #   but only if it is able to be converted to a symbol.
-    #
-    # @api private
-    # @param [<K>] key the key to attempt convert to a symbol
-    # @return [String, K]
-    def convert_key(key)
-      key.respond_to?(:to_sym) ? underscore_string(key.to_s) : key
+  class Snake < Module
+    def initialize(key_type: :string)
+      super()
+      @key_type = key_type
     end
 
-    # Unlike its parent Mash, a SnakyHash::Snake will convert other
-    #   Hashie::Hash values to a SnakyHash::Snake when assigning
-    #   instead of respecting the existing subclass
-    def convert_value(val, duping = false) #:nodoc:
-      case val
-      when self.class
-        val.dup
-      when ::Hash
-        val = val.dup if duping
-        self.class.new(val)
-      when ::Array
-        val.collect { |e| convert_value(e) }
-      else
-        val
-      end
+    def included(base)
+      conversions_module = SnakyModulizer.to_mod(@key_type)
+      base.include(conversions_module)
     end
 
-    # converts a camel_cased string to a underscore string
-    # subs spaces with underscores, strips whitespace
-    # Same way ActiveSupport does string.underscore
-    def underscore_string(str)
-      str.to_s.strip
-         .tr(" ", "_")
-         .gsub(/::/, "/")
-         .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-         .tr("-", "_")
-         .squeeze("_")
-         .downcase
+    module SnakyModulizer
+      def self.to_mod(key_type)
+        Module.new do
+          # Converts a key to a symbol, or a string, depending on key_type,
+          #   but only if it is able to be converted to a symbol,
+          #   and after underscoring it.
+          #
+          # @api private
+          # @param [<K>] key the key to attempt convert to a symbol
+          # @return [Symbol, K]
+
+          case key_type
+          when :string then
+            define_method(:convert_key) { |key| key.respond_to?(:to_sym) ? underscore_string(key.to_s) : key }
+          when :symbol then
+            define_method(:convert_key) { |key| key.respond_to?(:to_sym) ? underscore_string(key.to_s).to_sym : key }
+          else
+            raise ArgumentError, "SnakyHash: Unhandled key_type: #{key_type}"
+          end
+
+          # Unlike its parent Mash, a SnakyHash::Snake will convert other
+          #   Hashie::Hash values to a SnakyHash::Snake when assigning
+          #   instead of respecting the existing subclass
+          define_method :convert_value do |val, duping = false| #:nodoc:
+            case val
+            when self.class
+              val.dup
+            when ::Hash
+              val = val.dup if duping
+              self.class.new(val)
+            when ::Array
+              val.collect { |e| convert_value(e) }
+            else
+              val
+            end
+          end
+
+          # converts a camel_cased string to a underscore string
+          # subs spaces with underscores, strips whitespace
+          # Same way ActiveSupport does string.underscore
+          define_method :underscore_string do |str|
+            str.to_s.strip
+               .tr(" ", "_")
+               .gsub(/::/, "/")
+               .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+               .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+               .tr("-", "_")
+               .squeeze("_")
+               .downcase
+          end
+        end
+      end
     end
   end
 end

lib/snaky_hash/string_keyed.rb

@@ -0,0 +1,5 @@
+module SnakyHash
+  class StringKeyed < Hashie::Mash
+    include SnakyHash::Snake.new(key_type: :string)
+  end
+end

lib/snaky_hash/symbol_keyed.rb

@@ -0,0 +1,5 @@
+module SnakyHash
+  class SymbolKeyed < Hashie::Mash
+    include SnakyHash::Snake.new(key_type: :symbol)
+  end
+end

snaky_hash.gemspec

@@ -41,4 +41,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", ">= 12"
   spec.add_development_dependency "rspec", ">= 3"
   spec.add_development_dependency "rubocop-lts", "~> 8.0"
+  spec.add_development_dependency "rspec-block_is_expected"
 end

spec/shared_contexts/base_hash.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.shared_context "base hash" do
+  let(:base_hash) do
+    {
+      "varOne" => 1,
+      "two" => 2,
+      :three => 3,
+      :varFour => 4,
+      "fiveHumpHumps" => 5,
+      :nested => {
+        "NestedOne" => "One",
+        :two => "two",
+        "nested_three" => "three"
+      },
+      "nestedTwo" => {
+        "nested_two" => 22,
+        :nestedThree => 23
+      },
+      :nestedThree => [
+        { nestedFour: 4 },
+        { "nestedFour" => 4 }
+      ],
+      "spaced Key" => "When would this happen?",
+      "trailing spaces " => "better safe than sorry",
+      "extra   spaces" => "hopefully this never happens",
+      4 => "not symbolizable"
+    }
+  end
+end

spec/shared_examples/a_snaked_hash.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples_for "a snaked hash" do
+  include_context "base hash"
+
+  it { is_expected.to be_a(Hashie::Mash) }
+
+  it "creates a new rash where all the keys are underscored instead of camelcased" do
+    expect(subject.var_one).to eq(1)
+    expect(subject.two).to eq(2)
+    expect(subject.three).to eq(3)
+    expect(subject.var_four).to eq(4)
+    expect(subject.five_hump_humps).to eq(5)
+    expect(subject.nested).to be_a(subject.class)
+    expect(subject.nested.nested_one).to eq("One")
+    expect(subject.nested.two).to eq("two")
+    expect(subject.nested.nested_three).to eq("three")
+    expect(subject.nested_two).to be_a(subject.class)
+    expect(subject.nested_two.nested_two).to eq(22)
+    expect(subject.nested_two.nested_three).to eq(23)
+    expect(subject.spaced_key).to eq("When would this happen?")
+    expect(subject.trailing_spaces).to eq("better safe than sorry")
+    expect(subject.extra_spaces).to eq("hopefully this never happens")
+  end
+
+  it "allows camelCased accessors" do
+    # avoiding hashie v5- warnings
+    subject.class.disable_warnings(:varOne) if Gem::Version.new(Hashie::VERSION) >= Gem::Version.new("5.0.0")
+
+    expect(subject.varOne).to eq(1)
+    subject.varOne = "once"
+    expect(subject.varOne).to eq("once")
+    expect(subject.var_one).to eq("once")
+  end
+
+  it "allows camelCased accessors on nested hashes" do
+    # avoiding hashie v5-  warnings
+    subject.class.disable_warnings(:nestedOne) if Gem::Version.new(Hashie::VERSION) >= Gem::Version.new("5.0.0")
+
+    expect(subject.nested.nestedOne).to eq("One")
+    subject.nested.nestedOne = "once"
+    expect(subject.nested.nested_one).to eq("once")
+  end
+
+  it "merges well with a Mash" do
+    merged = subject.merge Hashie::Mash.new(
+      nested: { fourTimes: "a charm" },
+      nested3: { helloWorld: "hi" }
+    )
+
+    expect(merged.nested.four_times).to eq("a charm")
+    expect(merged.nested.fourTimes).to eq("a charm")
+    expect(merged.nested3).to be_a(subject.class)
+    expect(merged.nested3.hello_world).to eq("hi")
+    expect(merged.nested3.helloWorld).to eq("hi")
+    expect(merged[:nested3][:helloWorld]).to eq("hi")
+  end
+
+  it "updates well with a Mash" do
+    subject.update Hashie::Mash.new(
+      nested: { fourTimes: "a charm" },
+      nested3: { helloWorld: "hi" }
+    )
+
+    expect(subject.nested.four_times).to eq("a charm")
+    expect(subject.nested.fourTimes).to eq("a charm")
+    expect(subject.nested3).to be_a(subject.class)
+    expect(subject.nested3.hello_world).to eq("hi")
+    expect(subject.nested3.helloWorld).to eq("hi")
+    expect(subject[:nested3][:helloWorld]).to eq("hi")
+  end
+
+  it "merges well with a Hash" do
+    merged = subject.merge(
+      nested: { fourTimes: "work like a charm" },
+      nested3: { helloWorld: "hi" }
+    )
+
+    expect(merged.nested.four_times).to eq("work like a charm")
+    expect(merged.nested.fourTimes).to eq("work like a charm")
+    expect(merged.nested3).to be_a(subject.class)
+    expect(merged.nested3.hello_world).to eq("hi")
+    expect(merged.nested3.helloWorld).to eq("hi")
+    expect(merged[:nested3][:helloWorld]).to eq("hi")
+  end
+
+  it "handles assigning a new Hash and convert it to a rash" do
+    subject.nested3 = { helloWorld: "hi" }
+
+    expect(subject.nested3).to be_a(subject.class)
+    expect(subject.nested3.hello_world).to eq("hi")
+    expect(subject.nested3.helloWorld).to eq("hi")
+    expect(subject[:nested3][:helloWorld]).to eq("hi")
+  end
+
+  it "converts an array of Hashes" do
+    expect(subject.nested_three).to be_a(Array)
+    expect(subject.nested_three[0]).to be_a(subject.class)
+    expect(subject.nested_three[0].nested_four).to eq(4)
+    expect(subject.nested_three[1]).to be_a(subject.class)
+    expect(subject.nested_three[1].nested_four).to eq(4)
+  end
+
+  it "allows initializing reader" do
+    subject.nested3!.helloWorld = "hi"
+    expect(subject.nested3.hello_world).to eq("hi")
+  end
+
+  it "does not transform non-Symbolizable keys" do
+    expect(subject[4]).to eq("not symbolizable")
+    expect(subject[:"4"]).to be_nil
+    expect(subject["4"]).to be_nil
+    expect(subject.key?("4")).to be false
+    expect(subject.key?(:"4")).to be false
+    expect(subject.key?(4)).to be true
+  end
+end

spec/snaky_hash/bad_snake_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe "a bad one" do
+
+  subject(:bad_snake) do
+    Class.new(Hashie::Mash) do
+      include SnakyHash::Snake.new(key_type: :slartibartfarst)
+    end
+  end
+
+  it "raises an error" do
+    block_is_expected.to raise_error(ArgumentError)
+  end
+end