✨ Add serializer option

Author: pboling

lib/snaky_hash.rb

@@ -5,12 +5,30 @@
 require "version_gem"
 
 require_relative "snaky_hash/version"
+require_relative "snaky_hash/extensions"
+require_relative "snaky_hash/serializer"
 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
+  class Error < StandardError
+  end
+
+  class << self
+    def load_extensions
+      @load_extensions ||= Extensions.new
+    end
+
+    def dump_extensions
+      @dump_extensions ||= Extensions.new
+    end
+
+    def load_hash_extensions
+      @load_hash_extensions ||= Extensions.new
+    end
+  end
 end
 
 SnakyHash::Version.class_eval do

lib/snaky_hash/extensions.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SnakyHash
+  class Extensions
+    def initialize
+      reset
+    end
+
+    def reset
+      @extensions = {}
+    end
+
+    def add(name, &block)
+      if has?(name)
+        raise Error, "Extension already defined named '#{name}'"
+      end
+
+      @extensions[name.to_sym] = block
+    end
+
+    def has?(name)
+      @extensions.key?(name.to_sym)
+    end
+
+    def run(value)
+      @extensions.each_value do |block|
+        value = block.call(value)
+      end
+      value
+    end
+  end
+end

lib/snaky_hash/serializer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SnakyHash
+  module Serializer
+    def dump(obj)
+      hash = dump_hash(obj)
+      hash.to_json
+    end
+
+    def load(raw_hash)
+      hash = JSON.parse(presence(raw_hash) || "{}")
+      hash = load_hash(hash)
+      new(hash)
+    end
+
+  private
+
+    def blank?(value)
+      return true if value.nil?
+      return true if value.is_a?(String) && value.empty?
+
+      false
+    end
+
+    def presence(value)
+      blank?(value) ? nil : value
+    end
+
+    def dump_hash(hash)
+      hash = hash.transform_values do |value|
+        dump_value(value)
+      end
+      hash.reject { |_, v| blank?(v) }
+    end
+
+    def dump_value(value)
+      if blank?(value)
+        return
+      end
+
+      if value.is_a?(::Hash)
+        return dump_hash(value)
+      end
+
+      if value.is_a?(::Array)
+        return value.map { |v| dump_value(v) }.compact
+      end
+
+      SnakyHash.dump_extensions.run(value)
+    end
+
+    def load_hash(hash)
+      hash.transform_values do |value|
+        load_value(value)
+      end
+    end
+
+    def load_value(value)
+      if value.is_a?(::Hash)
+        hash = SnakyHash.load_hash_extensions.run(value)
+
+        # If the result is still a hash, we'll return that here
+        return load_hash(hash) if hash.is_a?(::Hash)
+
+        # If the result is not a hash, we'll just return whatever
+        # was returned as a normal value.
+        return load_value(hash)
+      end
+
+      return value.map { |v| load_value(v) } if value.is_a?(Array)
+
+      SnakyHash.load_extensions.run(value)
+    end
+  end
+end

lib/snaky_hash/snake.rb

@@ -5,14 +5,16 @@
 # include Hashie::Extensions::Mash::SymbolizeKeys
 module SnakyHash
   class Snake < Module
-    def initialize(key_type: :string)
+    def initialize(key_type: :string, serializer: false)
       super()
       @key_type = key_type
+      @serializer = serializer
     end
 
     def included(base)
       conversions_module = SnakyModulizer.to_mod(@key_type)
       base.include(conversions_module)
+      base.extend(SnakyHash::Serializer) if @serializer
     end
 
     module SnakyModulizer

lib/snaky_hash/string_keyed.rb

@@ -1,5 +1,13 @@
 module SnakyHash
+  # serialized is being introduced as an always disabled option for backwards compatibility.
+  # In snaky_hash v3 it will default to true.
+  # If you want to start using it immediately, reopen this class and add the Serializer module:
+  #
+  #   SnakyHash::StringKeyed.class_eval do
+  #     extend SnakyHash::Serializer
+  #   end
+  #
   class StringKeyed < Hashie::Mash
-    include SnakyHash::Snake.new(key_type: :string)
+    include SnakyHash::Snake.new(key_type: :string, serializer: false)
   end
 end

lib/snaky_hash/symbol_keyed.rb

@@ -1,5 +1,13 @@
 module SnakyHash
+  # serialized is being introduced as an always disabled option for backwards compatibility.
+  # In snaky_hash v3 it will default to true.
+  # If you want to start using it immediately, reopen this class and add the Serializer module:
+  #
+  #   SnakyHash::SymbolKeyed.class_eval do
+  #     extend SnakyHash::Serializer
+  #   end
+  #
   class SymbolKeyed < Hashie::Mash
-    include SnakyHash::Snake.new(key_type: :symbol)
+    include SnakyHash::Snake.new(key_type: :symbol, serializer: false)
   end
 end

spec/shared_examples/a_serialized_hash.rb

@@ -0,0 +1,133 @@
+RSpec.shared_examples_for 'a serialized hash' do
+  describe ".dump" do
+    after { SnakyHash.dump_extensions.reset }
+
+    it "returns a JSON string" do
+      value = subject.dump({hello: "World"})
+      expect(value).to eq '{"hello":"World"}'
+    end
+
+    it "removes any nil values" do
+      value = subject.dump({hello: "World", nilValue: nil})
+      expect(value).to eq '{"hello":"World"}'
+    end
+
+    it "removes empty strings" do
+      value = subject.dump({hello: "World", nilValue: ""})
+      expect(value).to eq '{"hello":"World"}'
+    end
+
+    it "does not remove false" do
+      value = subject.dump({hello: "World", falseValue: false})
+      expect(value).to eq '{"hello":"World","falseValue":false}'
+    end
+
+    it "removes any empty items from top-level arrays" do
+      value = subject.dump({hello: "World", array: [nil, 1, 2, "", false]})
+      expect(value).to eq '{"hello":"World","array":[1,2,false]}'
+    end
+
+    it "passes through any extensions that have been added" do
+      SnakyHash.dump_extensions.add(:test) { |value| value.upcase }
+      value = subject.dump({hello: "WORLD"})
+      expect(value).to eq '{"hello":"WORLD"}'
+    end
+
+    it "works with nested hashes" do
+      SnakyHash.dump_extensions.add(:test) { |value| value.is_a?(String) ? value.upcase : value }
+      value = subject.dump({hello: "world", nested: {vegetable: "potato", more_nesting: {fruit: "banana"}}})
+      expect(value).to eq '{"hello":"WORLD","nested":{"vegetable":"POTATO","more_nesting":{"fruit":"BANANA"}}}'
+    end
+
+    it "works with nested hashes in arrays" do
+      SnakyHash.dump_extensions.add(:test) { |value| value.is_a?(String) ? value.upcase : value }
+      value = subject.dump({hello: "world", nested: {vegetables: [{name: "potato"}, {name: "cucumber"}], more_nesting: {fruits: [{name: "banana"}, {name: "apple"}]}}})
+      expect(value).to eq '{"hello":"WORLD","nested":{"vegetables":[{"name":"POTATO"},{"name":"CUCUMBER"}],"more_nesting":{"fruits":[{"name":"BANANA"},{"name":"APPLE"}]}}}'
+    end
+  end
+
+  describe ".load" do
+    after do
+      SnakyHash.load_extensions.reset
+      SnakyHash.load_hash_extensions.reset
+    end
+
+    it "creates a Hashie::Mash from the given JSON" do
+      hash = subject.load('{"hello":"world"}')
+      expect(hash).to be_a Hashie::Mash
+      expect(hash["hello"]).to eq "world"
+    end
+
+    it "shuold create an empty Mash if the given value is nil" do
+      hash = subject.load(nil)
+      expect(hash).to be_a Hashie::Mash
+      expect(hash).to be_empty
+    end
+
+    it "creates an empty Mash if the JSON is an empty string" do
+      hash = subject.load("")
+      expect(hash).to be_a Hashie::Mash
+      expect(hash).to be_empty
+    end
+
+    it "passes through any extensions that have been added" do
+      SnakyHash.load_extensions.add(:test) { |value| value.upcase }
+      hash = subject.load('{"hello":"world"}')
+      expect(hash).to be_a Hashie::Mash
+      expect(hash["hello"]).to eq "WORLD"
+    end
+
+    it "works with nested hashes" do
+      SnakyHash.load_extensions.add(:test) { |value| value.is_a?(String) ? value.downcase : nil }
+      hash = subject.load('{"hello":"WORLD","nested":{"vegetable":"POTATO","more_nesting":{"fruit":"BANANA"}}}')
+      expect(hash).to be_a Hashie::Mash
+      expect(hash).to eq({"hello" => "world", "nested" => {"vegetable" => "potato", "more_nesting" => {"fruit" => "banana"}}})
+    end
+
+    it "works with nested hashes in arrays" do
+      SnakyHash.load_extensions.add(:test) { |value| value.is_a?(String) ? value.downcase : nil }
+      hash = subject.load('{"num":3,"hello":"WORLD","nested":{"vegetables":[{"name":"POTATO"},{"name":"CUCUMBER"}],"more_nesting":{"fruits":[{"name":"BANANA"},{"name":"APPLE"}]}}}')
+      expect(hash).to be_a Hashie::Mash
+      expect(hash).to eq({"num" => nil, "hello" => "world", "nested" => {"vegetables" => [{"name" => "potato"}, {"name" => "cucumber"}], "more_nesting" => {"fruits" => [{"name" => "banana"}, {"name" => "apple"}]}}})
+    end
+
+    it "is unable to upcase keys, because instantiation of a SnakyHash downcases keys" do
+      SnakyHash.load_hash_extensions.add(:test) { |value|
+        if value.is_a?(Hash)
+          value.transform_keys(&:upcase)
+        else
+          value
+        end
+      }
+      hash = subject.load('{"some_hash":{"name":"Michael"}}')
+      expect(hash).to be_a Hashie::Mash
+      expect(hash).to eq({"some_hash" => {"name" => "Michael"}})
+    end
+
+    it "passes through hashes through their own extensions" do
+      SnakyHash.load_hash_extensions.add(:test) { |value|
+        if value.is_a?(Hash)
+          value.transform_keys(&:next)
+        else
+          value
+        end
+      }
+      hash = subject.load('{"some_hash":{"name":"Michael"}}')
+      expect(hash).to be_a Hashie::Mash
+      expect(hash).to eq({"some_hash" => {"namf" => "Michael"}})
+    end
+
+    it "passes hashses through their own extension and return non-hash values properly" do
+      SnakyHash.load_hash_extensions.add(:test) { |value|
+        if value.is_a?(Hash)
+          value.key?("name") ? value["name"] : value
+        else
+          value
+        end
+      }
+      hash = subject.load('{"some_hash":{"name":"Michael"}}')
+      expect(hash).to be_a Hashie::Mash
+      expect(hash).to eq({"some_hash" => "Michael"})
+    end
+  end
+end