hash_with_dot_access 1.2.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e56312c78a8c5fa38cac0c7f3b533ca5d5e28c69de1da5b5aa26d7f1be3c7b7e
-  data.tar.gz: 9a5e3cf1d52fcb8f81a3b20ad645a13afe5b30cf1430dcd0649d4059f2e8781e
+  metadata.gz: be6e40c79e1f2c6148e84b6ef6b3521d9c07500bac9603f793a39dac7b3278ce
+  data.tar.gz: ace5ebdd3d951858e6dda87a96cfb9301b4ce7dc9802184cdee1cbd69e664538
 SHA512:
-  metadata.gz: 14723cc0870582ebe4278162e890e028b0515c543069bf97efd2cd16a122f6630cadf39fb64d5c4998331afda494d8388bc5320a9f8a06f011a6870b25672646
-  data.tar.gz: 8650367713ed20fb9b235a44d61d923244084836da9acdc8ca2125f6691cf08956741c3f0dc03f4f99e2047d1bc33f3081e2f061315e216864725fcaf118ad94
+  metadata.gz: 8763ae8a9cd9aec38d1cf2c4e0d659824633295576dfc3132968b82d848f92e354e5fb417f182b5b9be32ba8e2276996e3f36a2e3b8ce71de404c817cd599f1f
+  data.tar.gz: 8ee6d9ba1bdbc2322c40c1a4c79136d43c94376ec167f334123e17844cde1e9364a6a8bee75573827704a12152f328a55bf86980ab249c4170fac9482caa043e

data/.ruby-version

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

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [2.1.0] - 2024-04-20
+
+- Adds conversion back to a hash with `to_h` and `to_dot_h` for enumeration.
+
+## [2.0.0] - 2024-04-20
+
+- Completely rewrite internals and remove Active Support as a dependency
+  (this means HashWithDotAccess::Hash supports string, symbol, and dot access with zero dependencies)
+- Dot access now writes accessors to the class, improving performance (`method_missing` only runs once per key/accessor, essentially)
+
+## [1.2.0] - 2021-12-16
+
+- Support Rails 7

data/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.1.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
@@ -29,4 +17,4 @@ DEPENDENCIES
   rake (~> 13.0)
 
 BUNDLED WITH
-   2.1.4
+   2.5.6

data/README.md

@@ -1,6 +1,8 @@
 # Hash with Dot Access
 
-Rails' ActiveSupport gem provides `HashWithIndifferentAccess` which allows you to access hash keys with either strings or symbols. This gem provides `HashWithDotAccess` which subclasses `HashWithIndifferentAccess` and allows you to access or set those keys using dot access (aka methods). It utilizes `method_missing` to access key data if available, and you can also set data using `keyname=`.
+This gem provides a Ruby `Hash` subclass which lets you access hash values with either string or symbol keys, as well as via methods (aka dot access). It utilizes `method_missing` to access key data if available, and you can also set data using `keyname=`. Our goal is on providing good performance and if anything offering a _subset_ of standard Hash functionality (it's a non-goal to add all-new Hash-related functionality to this class).
+
+Performance is improved over long-running processes (such as the build process of the [Bridgetown](https://www.bridgetownrb.com) framework) by automatically defining accessors on the class so that `method_missing` is only called once per key/accessor pair.
 
 ## Example
 
@@ -26,13 +28,17 @@ hsh[:d]
 hsh["d"]
 # => "Indeed!"
 
-hsh2 = {test: "dot access"}.with_dot_access
+# You can use the `as_dots` method on Hash by loading in our refinement.
+
+using HashWithDotAccess::Refinements
+
+hsh2 = {test: "dot access"}.as_dots
 hsh2.test
 # => "dot access"
 
 ## Nested hashes work too! Pairs nicely with lonely operator: &.
 
-nested = {a: 1, b: {c: 3}}.with_dot_access
+nested = {a: 1, b: {c: 3}}.as_dots
 nested.b.c
 # => 3
 
@@ -41,7 +47,7 @@ nested&.d&.e&.f
 
 ## You can also set default return values when key is missing
 
-hsh = {a: 1, b: 2}.with_dot_access
+hsh = {a: 1, b: 2}.as_dots
 hsh.default = 0
 hsh.a
 # => 1
@@ -49,6 +55,9 @@ hsh.x
 # => 0
 ```
 
+You can convert a `HashWithDotAccess::Hash` back to a regular Hash with `to_h`, which even works with
+block enumeration. Or use `to_dot_h` as a `to_h`-like enumerator which preserves dot access.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -63,12 +72,22 @@ Then simply require `hash_with_dot_access`:
 require "hash_with_dot_access"
 ```
 
+> [!IMPORTANT]
+> If you're upgrading from an earlier version, and you don't want to modify your code away from using `with_dot_access`, you can add a monkey-patch to `Hash`:
+> ```ruby
+> class Hash
+>   def with_dot_access
+>     HashWithDotAccess::Hash.new(self)
+>   end
+> end
+> ```
+
 ## Caveats
 
 As with any Ruby object which provides arbitrary data through dynamic method calls, you may encounter collisions between your key names and existing `Hash` methods. For example:
 
 ```ruby
-hsh = {each: "this won't work!"}.with_dot_access
+hsh = {each: "this won't work!"}.as_dots
 hsh.each
 # => #<Enumerator: {"each"=>"this won't work!"}:each>
 #
@@ -78,7 +97,7 @@ hsh.each
 Of course, the easy fix is to simply use standard ways of accessing hash data in these cases:
 
 ```ruby
-hsh = {each: "this will work!"}.with_dot_access
+hsh = {each: "this will work!"}.as_dots
 hsh[:each]
 # => "this will work!"
 ```

data/hash_with_dot_access.gemspec

@@ -6,10 +6,12 @@ Gem::Specification.new do |spec|
   spec.author        = "Bridgetown Team"
   spec.email         = "maintainers@bridgetownrb.com"
 
-  spec.summary       = %q{Subclass of HashWithIndifferentAccess which provides dot access via method_missing}
+  spec.summary       = %q{Performance-oriented subclass of Hash which provides symbolized keys and method access}
   spec.homepage      = "https://github.com/bridgetownrb/hash_with_dot_access"
   spec.license       = "MIT"
 
+  spec.required_ruby_version = ">= 3.1.0"
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
@@ -17,8 +19,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

data/lib/hash_with_dot_access/version.rb

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

data/lib/hash_with_dot_access.rb

@@ -1,62 +1,176 @@
-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
+
+    def self.primitive_value(value)
+      case value
+      when ::Hash  
+        value.to_h
+      when Array
+        value = value.dup if value.frozen?
+        value.map! { primitive_value(_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
+    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
+
+    alias_method :_to_h, :to_h
+
+    def to_dot_h(...)
+      self.class.new _to_h(...)
+    end
+
+    def to_h
+      ::Hash.new.update(self).to_h do |k, v|
+        value = Utils.primitive_value(v)
+        k, value = yield k, value if block_given?
+        [k, value]
       end
     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

metadata

@@ -1,35 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: hash_with_dot_access
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Bridgetown Team
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-16 00:00:00.000000000 Z
+date: 2024-04-21 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '8.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -58,13 +38,15 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: 
+description:
 email: maintainers@bridgetownrb.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-version"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -78,7 +60,7 @@ homepage: https://github.com/bridgetownrb/hash_with_dot_access
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,15 +68,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
-summary: Subclass of HashWithIndifferentAccess which provides dot access via method_missing
+summary: Performance-oriented subclass of Hash which provides symbolized keys and
+  method access
 test_files: []