Rewrite internals, remove Active Support dependency

Author: jaredcwhite

.ruby-version

@@ -0,0 +1 @@
+3.1.4

Gemfile.lock

@@ -1,24 +1,12 @@
 PATH
   remote: .
   specs:
-    hash_with_dot_access (1.2.0)
-      activesupport (>= 5.0.0, < 8.0)
+    hash_with_dot_access (2.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.0)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 1.6, < 2)
-      minitest (>= 5.1)
-      tzinfo (~> 2.0)
-    concurrent-ruby (1.1.9)
-    i18n (1.8.11)
-      concurrent-ruby (~> 1.0)
-    minitest (5.15.0)
-    rake (13.0.6)
-    tzinfo (2.0.4)
-      concurrent-ruby (~> 1.0)
+    rake (13.2.1)
 
 PLATFORMS
   ruby
@@ -27,6 +15,3 @@ DEPENDENCIES
   bundler
   hash_with_dot_access!
   rake (~> 13.0)
-
-BUNDLED WITH
-   2.1.4

hash_with_dot_access.gemspec

@@ -17,8 +17,6 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "activesupport",     [">= 5.0.0", "< 8.0"]
-  
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 13.0"
 end

lib/hash_with_dot_access.rb

@@ -1,62 +1,150 @@
-require "active_support/core_ext/hash/indifferent_access"
-
 module HashWithDotAccess
-  class Hash < ActiveSupport::HashWithIndifferentAccess
-    def respond_to_missing?(key, *)
+  module Utils
+    def self.normalized_value(obj, value)
+      return value if value.instance_of?(obj.class)
+
+      case value
+      when ::Hash
+        obj.class.new(value)
+      when Array
+        value = value.dup if value.frozen?
+        value.map! { normalized_value(obj, _1) }
+      else
+        value
+      end
+    end
+  end
+
+  class Hash < ::Hash
+    class << self
+      undef_method :[]
+    end
+
+    def initialize(hsh = nil)
+      super
+      return unless hsh
+
+      update(hsh)
+      self.default_proc = hsh.default_proc
+      self.default = hsh.default
+    end
+
+    def respond_to_missing?(key, *args)
+      return false unless args.empty?
+
       return true if "#{key}".end_with?("=")
 
       key?(key)
     end
 
-    def method_missing(key, *args)
-      if "#{key}".end_with?("=")
-        self["#{key}".chop] = args.first
+    def key?(key) = super(key.to_s)
+
+    alias_method :has_key?, :key?
+    alias_method :include?, :key?
+    alias_method :member?, :key?
+
+    # save previous method
+    alias_method :_assign, :[]=
+
+    def [](key) = super(key.to_s)
+
+    def []=(key, value)
+      _assign(key.to_s, Utils.normalized_value(self, value))
+    end
+
+    alias_method :store, :[]=
+
+    def fetch(key, *args) = super(key.to_s, *args)
+
+    def assoc(key, *args) = super(key.to_s)
+
+    def values_at(*keys) = super(*keys.map!(&:to_s))
+
+    def fetch_values(*keys) = super(*keys.map!(&:to_s))
+
+    def method_missing(method_name, *args)
+      key = method_name.to_s
+      if key.end_with?("=")
+        key_chop = key.chop
+        self.class.define_method(key) { |value| self[key_chop] = value }
+        self[key.chop] = args.first
       elsif self.key?(key)
+        self.class.define_method(key) { self[key] }
         self[key]
       elsif default_proc
+        super unless args.empty?
         default_proc.call(self, key)
       else
+        super unless args.empty?
         default
       end
     end
 
-    def update(other_hash)
-      if other_hash.is_a? HashWithDotAccess::Hash
-        super(other_hash)
-      else
-        other_hash.to_hash.each_pair do |key, value|
-          if block_given? && key?(key)
-            value = yield(convert_key(key), self[key], value)
+    def update(*other_hashes)
+      other_hashes.each do |other_hash|
+        if other_hash.is_a? HashWithDotAccess::Hash
+          super(other_hash)
+        else
+          other_hash.to_hash.each do |key, value|
+            key = key.to_s
+            if block_given? && key?(key)
+              value = yield(key, self[key], value)
+            end
+            _assign(key, Utils.normalized_value(self, value))
           end
-          regular_writer(convert_key(key), convert_value(value))
         end
-        self
       end
+
+      self
     end
 
-    private
+    alias_method :merge!, :update
 
-    def convert_value(value, options = {}) # :doc:
-      if value.is_a? ::Hash
-        if options[:for] == :to_hash
-          value.to_hash
-        else
-          value.with_dot_access
-        end
-      elsif value.is_a?(Array)
-        if options[:for] != :assignment || value.frozen?
-          value = value.dup
-        end
-        value.map! { |e| convert_value(e, options) }
-      else
-        value
-      end
+    def merge(...) = dup.update(...)
+
+    def replace(...)
+      clear
+      update(...)
+    end
+
+    def dig(*args)
+      super(args[0].to_s, *args[1..])
+    end
+
+    def delete(key) = super(key.to_s)
+
+    def except(*keys) = super(*keys.map!(&:to_s))
+
+    def slice(*keys) = self.class.new(super(*keys.map!(&:to_s)))
+
+    def select(...)
+      return to_enum(:select) unless block_given?
+
+      dup.tap { _1.select!(...) }
+    end
+
+    def reject(...)
+      return to_enum(:reject) unless block_given?
+
+      dup.tap { _1.reject!(...) }
+    end
+
+    def transform_values(...)
+      return to_enum(:transform_values) unless block_given?
+
+      dup.tap { _1.transform_values!(...) }
+    end
+
+    def compact
+      dup.tap { _1.compact! }
     end
   end
-end
 
-class Hash
-  def with_dot_access
-    HashWithDotAccess::Hash.new(self)
+  module Refinements
+    refine ::Hash do
+      def as_dots
+        HashWithDotAccess::Hash.new(self)
+      end
+    end
   end
 end

lib/hash_with_dot_access/version.rb

@@ -1,3 +1,3 @@
 module HashWithDotAccess
-  VERSION = "1.2.0"
+  VERSION = "2.0.0"
 end