recursive-open-struct 1.0.4 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c20dbcb5ce4e4805d18e6c7ea454ef2357dbc224
-  data.tar.gz: d9a112d4e90c9355c3f7356e88b16f81fe8da7f7
+SHA256:
+  metadata.gz: 3cc972f20fd1aba4f8eea6fe1766c17c7d9e663a3ed999e8375549ac37ae4b08
+  data.tar.gz: 9c0d0230d431aedeae47f0f2026d77196dfb230c3ebe9359763b4265c9a4c4d6
 SHA512:
-  metadata.gz: 7379ae006edd0cea0f1b052098042a6333cc8ed3509fa1742f77b54aa73d135eb483e41bfa7eb00e39b29fb2c7c5cc808cd788f4af0cb3ff0fdb11a77a4d2f77
-  data.tar.gz: ac6f2be126563fa292e523f2e463fa1a8f520f8d5e6b45c134e6d196a4bc50de4d1bcf144448cf8da7b5b862615cf400efaf094efd1c11c9b55e7f5e96fa7175
+  metadata.gz: dcdc725048e24182c562551875b2fa90d100248008af5dd4a974bb8df82f48ec5f618b3d76458d16f868b76b55263e96d3576a6d92f5ace69979beb29ae3213f
+  data.tar.gz: d67c50798fcaa7ca49003a924e57df0a22e83a5d688ef6ff90b61f462855f2b6ef8882e5873c0994558416030a9b265fe60cccfe586fd5bf9688e463d92279fe

data/.travis.yml

@@ -1,24 +1,33 @@
 ---
 language: ruby
 rvm:
-  # - 1.9.3  # json gem now requires Ruby ~> 2.0
+  # No longer supported (but test anyways)
   - 2.0.0
   - 2.1.10
-  - 2.2.7
-  - 2.3.4
-  - 2.4.1
-  - ruby-head
+  - 2.2.10
   - jruby-19mode
-  - jruby-9.0.5.0
-  - jruby-9.1.5.0
+  - 2.3.8
+  - 2.4.10
+  # Current stable supported by Travis
+  - 2.5.8
+  - 2.6.6
+  - 2.7.1
+  - jruby-9.1.9.0
+  # Future
+  - ruby-head
   - jruby-head
+  - truffleruby-head
 sudo: false
 matrix:
   allow_failures:
     # No longer supported
     - rvm: 2.0.0
     - rvm: 2.1.10
+    - rvm: 2.2.10
+    - rvm: 2.3.8
+    - rvm: 2.4.10
     - rvm: jruby-19mode
     # Future
     - rvm: ruby-head
     - rvm: jruby-head
+    - rvm: truffleruby-head

data/AUTHORS.txt

@@ -1,8 +1,15 @@
 Recursive-open-struct was written by these fine people:
 
+* Ben Langfeld <ben@langfeld.me>
+* Beni Cherniavsky-Paskin <cben@redhat.com>
 * Cédric Felizard <cedric@felizard.fr>
+* David Feldman <dbfeldman@gmail.com>
+* Edward Betts <edward@4angle.com>
+* Ewoud Kohl van Wijngaarden <ewoud@kohlvanwijngaarden.nl>
 * Federico Aloi <federico.aloi@gmail.com>
 * fervic <roberto@runawaybit.com>
+* Igor Victor <gogainda@yandex.ru>
+* Jean Boussier <jean.boussier@gmail.com>
 * Joe Rafaniello <jrafanie@redhat.com>
 * Kris Dekeyser <kris.dekeyser@libis.be>
 * Matt Culpepper <matt@culpepper.co>
@@ -10,6 +17,7 @@ Recursive-open-struct was written by these fine people:
 * Offirmo <offirmo.net@gmail.com>
 * Pedro Sena <sena.pedro@gmail.com>
 * Peter Yeremenko <peter.yeremenko@gmail.com>
+* Pirate Praveen <praveen@debian.org>
 * Sebastian Gaul <sebastian@mgvmedia.com>
 * Thiago Guimaraes <thiagogsr@gmail.com>
 * Tom Chapin <tchapin@gmail.com>

data/CHANGELOG.md

@@ -1,8 +1,55 @@
+1.1.3 / 2020/10/15
+==================
+
+* No longer officially supporting Ruby 2.4.x, but compatiblity continues.
+* [#68](https://github.com/aetherknight/recursive-open-struct/pull/68): Igor
+  Victor: Add truffleruby-head to travis
+* FIX [#67](https://github.com/aetherknight/recursive-open-struct/pull/67):
+  Jean Boussier: Support upstream changes to OpenStruct in ruby-head (Ruby
+  3.0.0-dev)
+
+1.1.2 / 2020/06/20
+==================
+
+* FIX [#58](https://github.com/aetherknight/recursive-open-struct/pull/58):
+  David Feldman: Fix `[]=` so that it properly updates sub-elements
+* [#58](https://github.com/aetherknight/recursive-open-struct/pull/58):
+  David Feldman: Make the default options configurable at the class level to
+  simplify adding additional options in subclasses
+
+1.1.1 / 2020/03/10
+==================
+
+* FIX [#64](https://github.com/aetherknight/recursive-open-struct/pull/64):
+  Pirate Praveen: Support Ruby 2.7.0. `OpenStruct#modifiable` support was
+  finally dropped, and has to be replaced with `OpenStruct#modifiable?`.
+* Made some additional changes to continue supporting pre-2.4.x Rubies,
+  including the current stable JRuby (9.1.x.x, which tracks Ruby 2.3.x for
+  features)
+
+1.1.0 / 2018-02-03
+==================
+
+* NEW/FIX [#56](https://github.com/aetherknight/recursive-open-struct/issues/56):
+  Add better support for Ruby 2.3+'s `#dig` method (when it exists for the
+  current version of Ruby), so that nested Hashes are properly converted to
+  RecursiveOpenStructs. `OpenStruct#dig`'s implementation was returning Hashes
+  and does not handle `recurse_over_arrays` so ROS needs special support.
+  Thanks to maxp-edcast for reporting the issue.
+* FIX [#55](https://github.com/aetherknight/recursive-open-struct/pull/55):
+  EdwardBetts: Fixed a typo in the documentation/comment for `#method_missing`
+
+1.0.5 / 2017-06-21
+==================
+
+* FIX [#54](https://github.com/aetherknight/recursive-open-struct/pull/54):
+  Beni Cherniavsky-Paskin: Improve performance of `new_ostruct_member` by using
+  `self.singleton_class.method_defined?` instead of `self.methods.include?`
+
 1.0.4 / 2017-04-29
 ==================
 
-* FIX
-  [#52](https://github.com/aetherknight/recursive-open-struct/pull/52): Joe
+* FIX [#52](https://github.com/aetherknight/recursive-open-struct/pull/52): Joe
   Rafaniello: Improve performance of DeepDup by using Set instead of an Array
   to track visited nodes.
 

data/CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# Contributing to recursive-open-struct
+
+Thanks for wanting to contribute a bug or code to recursive-open-struct!
+
+To help you out with understanding the direction and philosophy of this project
+with regards to to new features/how it should behave (and whether to file a bug
+report), please review the following contribution guidelines.
+
+## ROS Feature Philosophy
+
+Recursive-open-struct tries to be a minimal extension to the Ruby stdlib's
+`ostruct`/OpenStruct that allows for a nested set of Hashes (and Arrays) to
+initialize similarly structured OpenStruct-like objects. This has the benefit
+of creating arbitrary objects whose values can be accessed with accessor
+methods, similar to JavaScript Objects' dot-notation.
+
+To phrase it another way, RecursiveOpenStruct tries to behave as closely as
+possible to OpenStruct, except for the recursive functionality that it adds.
+
+If Recursive-open-struct were to add additional features (particularly methods)
+that are not implemented by OpenStruct, then those method names would not be
+available for use for accessing fields with the dot-notation that OpenStruct
+and RecursiveOpenStruct provide.
+
+For example, OpenStruct is not (at the time this is written) a
+subclass/specialization of Hash, so several methods implemented by Hash do not
+work with OpenStruct (and thus Recursive OpenStruct), such as `#fetch`.
+
+If you want to add features into RecursiveOpenStruct that would "pollute" the
+method namespace more than OpenStruct already does, consider creating your own
+subclass instead of submitting a code change to RecursiveOpenStruct itself.
+
+
+## Filing/Fixing Bugs and Requesting/Proposing New Features
+
+For simple bug fixes, feel free to provide a pull request. This includes bugs
+in stated features of RecursiveOpenStruct, as well as features added to
+OpenStruct in a newer version of Ruby that RecursiveOpenStruct needs custom
+support to handle.
+
+For anything else (new features, bugs that you want to report, and bugs that
+are difficult to fix), I recommend opening an issue first to discuss the
+feature or bug. I am fairly cautious about adding new features that might cause
+RecursiveOpenStruct's API to deviate radically from OpenStruct's (since it
+might introduce new reserved method names), and it is useful to discuss the
+best way to solve a problem when there are tradeoffs or imperfect solutions.
+
+When contributing code that changes behavior or fixes bugs, please include unit
+tests to cover the new behavior or to provide regression testing for bugs.
+Also, treat the unit tests as documentation --- make sure they are clean,
+clear, and concise, and well organized.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2016, The Recursive-open-struct developers (given in the
+Copyright (c) 2009-2018, The Recursive-open-struct developers (given in the
 file AUTHORS.txt).
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.md

@@ -3,58 +3,109 @@
 OpenStruct subclass that returns nested hash attributes as
 RecursiveOpenStructs.
 
+
+## Usage
+
 It allows for hashes within hashes to be called in a chain of methods:
 
-    ros = RecursiveOpenStruct.new( { fooa: { foob: 'fooc' } } )
+```ruby
+ros = RecursiveOpenStruct.new( { wha: { tagoo: 'siam' } } )
 
-    ros.fooa.foob # => 'fooc'
+ros.wha.tagoo # => 'siam'
+```
 
 Also, if needed, nested hashes can still be accessed as hashes:
 
-    ros.fooa_as_a_hash # { foob: 'fooc' }
+```ruby
+ros.wha_as_a_hash # { tagoo: 'siam' }
+```
+
+
+### Optional: Recurse Over Arrays
 
 RecursiveOpenStruct can also optionally recurse across arrays, although you
-have to explicitly enable it:
+have to explicitly enable it.
+
+Default behavior:
+```ruby
+h = { :somearr => [ { name: 'a'}, { name: 'b' } ] }
 
-    h = { :somearr => [ { name: 'a'}, { name: 'b' } ] }
-    ros = RecursiveOpenStruct.new(h, recurse_over_arrays: true )
+ros = RecursiveOpenStruct.new(h)
+ros.somearr # => [ { name: 'a'}, { name: 'b' } ]
+```
 
-    ros.somearr[0].name # => 'a'
-    ros.somearr[1].name # => 'b'
+Enabling `recurse_over_arrays`:
+
+```ruby
+ros = RecursiveOpenStruct.new(h, recurse_over_arrays: true )
+
+ros.somearr[0].name # => 'a'
+ros.somearr[1].name # => 'b'
+```
+
+
+### Optional: Preserve Original Keys
 
 Also, by default it will turn all hash keys into symbols internally:
 
-    h = { 'fear' => 'is', 'the' => 'mindkiller' } }
-    ros = RecursiveOpenStruct.new(h)
-    ros.to_h # => { fear: 'is', the: 'mindkiller' }
+```ruby
+h = { 'fear' => 'is', 'the' => 'mindkiller' } }
+ros = RecursiveOpenStruct.new(h)
+ros.to_h # => { fear: 'is', the: 'mindkiller' }
+```
 
 You can preserve the original keys by enabling `:preserve_original_keys`:
 
-    h = { 'fear' => 'is', 'the' => 'mindkiller' } }
-    ros = RecursiveOpenStruct.new(h, preserve_original_keys: true)
-    ros.to_h # => { 'fear' => 'is', 'the' => 'mindkiller' }
+```ruby
+h = { 'fear' => 'is', 'the' => 'mindkiller' } }
+ros = RecursiveOpenStruct.new(h, preserve_original_keys: true)
+ros.to_h # => { 'fear' => 'is', 'the' => 'mindkiller' }
+```
+
 
 ## Installation
 
 Available as a gem in rubygems, the default gem repository.
 
-If you use bundler, just throw that in your gemfile :
+If you use bundler, just add recursive-open-struct to your gemfile :
 
-    gem 'recursive-open-struct'
+```ruby
+gem 'recursive-open-struct'
+```
 
-You may also install the gem manually :
+You may also install the gem manually:
 
     gem install recursive-open-struct
 
+
 ## Contributing
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for your new or changed functionality. Make sure the tests you add
-  provide clean and clear explanation of the feature.
-* Send me a pull request. Bonus points for topic branches.
+
+If you would like to file or fix a bug, or propose a new feature, please review
+[CONTRIBUTING](CONTRIBUTING.md) first.
+
+
+## Supported Ruby Versions
+
+Recursive-open-struct attempts to support just the versions of Ruby that are
+still actively maintained. Once a given major/minor version of Ruby no longer
+receives patches, they will no longer be supported (but recursive-open-struct
+may still work). I usually update the travis.yml file to reflect this when
+preparing for a new release or do some other work on recursive-open-struct.
+
+I also try to update recursive-open-struct to support new features in
+OpenStruct itself as new versions of Ruby are released. However, I don't
+actively monitor the status of this, so a newer feature might not work. If you
+encounter such a feature, please file a bug or a PR to fix it, and I will try
+to cut a new release of recursive-open-struct quickly.
+
+
+## SemVer Compliance
+
+Rescursive-open-struct follows [SemVer
+2.0](https://semver.org/spec/v2.0.0.html) for its versioning.
+
 
 ## Copyright
 
-Copyright (c) 2009-2016, The Recursive-open-struct developers (given in the
+Copyright (c) 2009-2018, The Recursive-open-struct developers (given in the
 file AUTHORS.txt). See LICENSE.txt for details.

data/lib/recursive_open_struct.rb

@@ -3,56 +3,81 @@ require 'recursive_open_struct/version'
 
 require 'recursive_open_struct/debug_inspect'
 require 'recursive_open_struct/deep_dup'
-require 'recursive_open_struct/ruby_19_backport'
+require 'recursive_open_struct/dig'
 
 # TODO: When we care less about Rubies before 2.4.0, match OpenStruct's method
 # names instead of doing things like aliasing `new_ostruct_member` to
 # `new_ostruct_member!`
+#
+# TODO: `#*_as_a_hash` deprecated. Nested hashes can be referenced using
+# `#to_h`.
 
 class RecursiveOpenStruct < OpenStruct
-  include Ruby19Backport if RUBY_VERSION =~ /\A1.9/
+  include Dig if OpenStruct.public_instance_methods.include? :dig
+
+  # TODO: deprecated, possibly remove or make optional an runtime so that it
+  # doesn't normally pollute the public method namespace
   include DebugInspect
 
-  def initialize(hash=nil, args={})
+  def self.default_options
+    {
+      mutate_input_hash: false,
+      recurse_over_arrays: false,
+      preserve_original_keys: false
+    }
+  end
+
+  def initialize(hash=nil, passed_options={})
     hash ||= {}
-    @recurse_over_arrays = args.fetch(:recurse_over_arrays, false)
-    @preserve_original_keys = args.fetch(:preserve_original_keys, false)
-    @deep_dup = DeepDup.new(
-      recurse_over_arrays: @recurse_over_arrays,
-      preserve_original_keys: @preserve_original_keys
-    )
 
-    @table = args.fetch(:mutate_input_hash, false) ? hash : @deep_dup.call(hash)
+    @options = self.class.default_options.merge!(passed_options).freeze
+
+    @deep_dup = DeepDup.new(@options)
+
+    @table = @options[:mutate_input_hash] ? hash : @deep_dup.call(hash)
 
     @sub_elements = {}
   end
 
-  def initialize_copy(orig)
-    super
 
-    # deep copy the table to separate the two objects
-    @table = @deep_dup.call(orig.instance_variable_get(:@table))
-    # Forget any memoized sub-elements
-    @sub_elements = {}
+  if OpenStruct.public_instance_methods.include?(:initialize_copy)
+    def initialize_copy(orig)
+      super
+
+      # deep copy the table to separate the two objects
+      @table = @deep_dup.call(@table)
+      # Forget any memoized sub-elements
+      @sub_elements = {}
+    end
   end
 
   def to_h
     @deep_dup.call(@table)
   end
 
+  # TODO: deprecated, unsupported by OpenStruct. OpenStruct does not consider
+  # itself to be a "kind of" Hash.
   alias_method :to_hash, :to_h
 
+  # Continue supporting older rubies -- JRuby 9.1.x.x is still considered
+  # stable, but is based on Ruby
+  # 2.3.x and so uses :modifiable instead of :modifiable?. Furthermore, if
+  # :modifiable is private, then make :modifiable? private too.
+  if !OpenStruct.private_instance_methods.include?(:modifiable?)
+    if OpenStruct.private_instance_methods.include?(:modifiable)
+      alias_method :modifiable?, :modifiable
+    elsif OpenStruct.public_instance_methods.include?(:modifiable)
+      alias_method :modifiable?, :modifiable
+      private :modifiable?
+    end
+  end
+
   def [](name)
     key_name = _get_key_from_table_(name)
     v = @table[key_name]
     if v.is_a?(Hash)
-      @sub_elements[key_name] ||= self.class.new(
-        v,
-        recurse_over_arrays: @recurse_over_arrays,
-        preserve_original_keys: @preserve_original_keys,
-        mutate_input_hash: true
-      )
-    elsif v.is_a?(Array) and @recurse_over_arrays
+      @sub_elements[key_name] ||= _create_sub_element_(v, mutate_input_hash: true)
+    elsif v.is_a?(Array) and @options[:recurse_over_arrays]
       @sub_elements[key_name] ||= recurse_over_array(v)
       @sub_elements[key_name] = recurse_over_array(@sub_elements[key_name])
     else
@@ -60,29 +85,45 @@ class RecursiveOpenStruct < OpenStruct
     end
   end
 
+  if private_instance_methods.include?(:modifiable?) || public_instance_methods.include?(:modifiable?)
+    def []=(name, value)
+      key_name = _get_key_from_table_(name)
+      tbl = modifiable?  # Ensure we are modifiable
+      @sub_elements.delete(key_name)
+      tbl[key_name] = value
+    end
+  else
+    def []=(name, value)
+      key_name = _get_key_from_table_(name)
+      @table[key_name] = value # raises if self is frozen in Ruby 3.0
+      @sub_elements.delete(key_name)
+    end
+  end
+
   # Makes sure ROS responds as expected on #respond_to? and #method requests
   def respond_to_missing?(mid, include_private = false)
     mname = _get_key_from_table_(mid.to_s.chomp('=').chomp('_as_a_hash'))
     @table.key?(mname) || super
   end
 
-  # Adapted implementation of method_missing to accomodate the differences between ROS and OS.
-  #
-  # TODO: Use modifiable? instead of modifiable, and new_ostruct_member!
-  # instead of new_ostruct_member once we care less about Rubies before 2.4.0.
+  # Adapted implementation of method_missing to accommodate the differences
+  # between ROS and OS.
   def method_missing(mid, *args)
     len = args.length
     if mid =~ /^(.*)=$/
       if len != 1
         raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
       end
-      modifiable[new_ostruct_member!($1.to_sym)] = args[0]
+      # self[$1.to_sym] = args[0]
+      # modifiable?[new_ostruct_member!($1.to_sym)] = args[0]
+      new_ostruct_member!($1.to_sym)
+      public_send(mid, args[0])
     elsif len == 0
       key = mid
       key = $1 if key =~ /^(.*)_as_a_hash$/
       if @table.key?(_get_key_from_table_(key))
         new_ostruct_member!(key)
-        send(mid)
+        public_send(mid)
       end
     else
       err = NoMethodError.new "undefined method `#{mid}' for #{self}", mid, args
@@ -95,14 +136,13 @@ class RecursiveOpenStruct < OpenStruct
   # 2.4.0.
   def new_ostruct_member(name)
     key_name = _get_key_from_table_(name)
-    unless self.methods.include?(name.to_sym)
+    unless self.singleton_class.method_defined?(name.to_sym)
       class << self; self; end.class_eval do
         define_method(name) do
           self[key_name]
         end
         define_method("#{name}=") do |x|
-          @sub_elements.delete(key_name)
-          modifiable[key_name] = x
+          self[key_name] = x
         end
         define_method("#{name}_as_a_hash") { @table[key_name] }
       end
@@ -113,7 +153,7 @@ class RecursiveOpenStruct < OpenStruct
   # Support Ruby 2.4.0+'s changes in a way that doesn't require dynamically
   # modifying ROS.
   #
-  # TODO: Once we care less about Rubies before 2.4.0, reverse this sot hat
+  # TODO: Once we care less about Rubies before 2.4.0, reverse this so that
   # new_ostruct_member points to our version and not OpenStruct's.
   alias new_ostruct_member! new_ostruct_member
   # new_ostruct_member! is private, but new_ostruct_member is not on OpenStruct in 2.4.0-rc1?!
@@ -122,23 +162,36 @@ class RecursiveOpenStruct < OpenStruct
   def delete_field(name)
     sym = _get_key_from_table_(name)
     singleton_class.__send__(:remove_method, sym, "#{sym}=") rescue NoMethodError # ignore if methods not yet generated.
-    @sub_elements.delete sym
-    @table.delete sym
+    @sub_elements.delete(sym)
+    @table.delete(sym)
   end
 
   private
 
+  unless OpenStruct.public_instance_methods.include?(:initialize_copy)
+    def initialize_dup(orig)
+      super
+      # deep copy the table to separate the two objects
+      @table = @deep_dup.call(@table)
+      # Forget any memoized sub-elements
+      @sub_elements = {}
+    end
+  end
+
   def _get_key_from_table_(name)
     return name.to_s if @table.has_key?(name.to_s)
     return name.to_sym if @table.has_key?(name.to_sym)
     name
   end
 
+  def _create_sub_element_(hash, **overrides)
+    self.class.new(hash, @options.merge(overrides))
+  end
+
   def recurse_over_array(array)
     array.each_with_index do |a, i|
       if a.is_a? Hash
-        array[i] = self.class.new(a, :recurse_over_arrays => true,
-          :mutate_input_hash => true, :preserve_original_keys => @preserve_original_keys)
+        array[i] = _create_sub_element_(a, mutate_input_hash: true, recurse_over_arrays: true)
       elsif a.is_a? Array
         array[i] = recurse_over_array a
       end

data/lib/recursive_open_struct/dig.rb

@@ -0,0 +1,22 @@
+class RecursiveOpenStruct < OpenStruct
+  module Dig
+
+    # Replaces +OpenStruct#dig+ to properly support treating nested values as
+    # RecursiveOpenStructs instead of returning the nested Hashes.
+    def dig(name, *names)
+      begin
+        name = name.to_sym
+      rescue NoMethodError
+        raise TypeError, "#{name} is not a symbol nor a string"
+      end
+
+      name_val = self[name]
+
+      if names.length > 0 && name_val.respond_to?(:dig)
+        name_val.dig(*names)
+      else
+        name_val
+      end
+    end
+  end
+end

data/lib/recursive_open_struct/version.rb

@@ -3,5 +3,5 @@
 require 'ostruct'
 
 class RecursiveOpenStruct < OpenStruct
-  VERSION = "1.0.4"
+  VERSION = "1.1.3"
 end

data/recursive-open-struct.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.authors = ["William (B.J.) Snow Orvis"]
   s.email = "aetherknight@gmail.com"
   s.date = Time.now.utc.strftime("%Y-%m-%d")
-  s.homepage = "http://github.com/aetherknight/recursive-open-struct"
+  s.homepage = "https://github.com/aetherknight/recursive-open-struct"
   s.licenses = ["MIT"]
 
   s.summary = "OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs"

data/spec/recursive_open_struct/ostruct_2_0_0_spec.rb

@@ -6,7 +6,7 @@ describe RecursiveOpenStruct do
   let(:hash) { {:foo => 'foo', 'bar' => :bar} }
   subject(:ros) { RecursiveOpenStruct.new(hash) }
 
-  describe "OpenStruct 2.0 methods" do
+  describe "OpenStruct 2.0+ methods" do
 
     context "Hash style setter" do
 
@@ -96,10 +96,16 @@ describe RecursiveOpenStruct do
 
     context "each_pair" do
       it "iterates over hash keys, with keys as symbol" do
-        expect(ros.each_pair).to match ({:foo => 'foo', :bar => :bar}.each_pair)
+        ros_pairs = []
+        ros.each_pair {|k,v| ros_pairs << [k,v]}
+
+        hash_pairs = []
+        {:foo => 'foo', :bar => :bar}.each_pair {|k,v| hash_pairs << [k,v]}
+
+        expect(ros_pairs).to match (hash_pairs)
       end
     end
 
-  end
+  end # describe OpenStruct 2.0+ methods
 
 end

data/spec/recursive_open_struct/ostruct_2_3_0_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../spec_helper'
+require 'recursive_open_struct'
+
+describe RecursiveOpenStruct do
+  describe "OpenStruct 2.3.0+ methods" do
+    describe "#dig" do
+      # We only care when Ruby supports `#dig`.
+      if OpenStruct.public_instance_methods.include? :dig
+        context "recurse_over_arrays: false" do
+          subject { RecursiveOpenStruct.new(a: { b: 2, c: ["doo", "bee", { inner: "one"}]}) }
+
+          describe "OpenStruct-like behavior" do
+            it { expect(subject.dig(:a, :b)).to eq 2 }
+            it { expect(subject.dig(:a, :c, 0)).to eq "doo" }
+            it { expect(subject.dig(:a, :c, 2, :inner)).to eq "one" }
+          end
+
+          describe "recursive behavior" do
+            it {
+              expect(subject.dig(:a)).to eq RecursiveOpenStruct.new(
+                { b: 2, c: ["doo", "bee", { inner: "one"}]}
+              )
+            }
+            it { expect(subject.dig(:a, :c, 2)).to eq({inner: "one"}) }
+          end
+        end
+
+        context "recurse_over_arrays: true" do
+          subject { RecursiveOpenStruct.new({a: { b: 2, c: ["doo", "bee", { inner: "one"}]}}, recurse_over_arrays: true) }
+
+          describe "OpenStruct-like behavior" do
+            it { expect(subject.dig(:a, :b)).to eq 2 }
+            it { expect(subject.dig(:a, :c, 0)).to eq "doo" }
+            it { expect(subject.dig(:a, :c, 2, :inner)).to eq "one" }
+          end
+
+          describe "recursive behavior" do
+            it {
+              expect(subject.dig(:a)).to eq RecursiveOpenStruct.new(
+                { b: 2, c: ["doo", "bee", { inner: "one"}]}
+              )
+            }
+            it { expect(subject.dig(:a, :c, 2)).to eq RecursiveOpenStruct.new(inner: "one") }
+          end
+        end
+      end
+    end # describe #dig
+  end # describe OpenStruct 2.3+ methods
+end

data/spec/recursive_open_struct/recursion_spec.rb

@@ -28,6 +28,15 @@ describe RecursiveOpenStruct do
       expect(subject.blah_as_a_hash).to eq({ :another => 'value' })
     end
 
+    it "handles sub-element replacement with dotted notation before member setup" do
+      expect(ros[:blah][:another]).to eql 'value'
+      expect(ros.methods).not_to include(:blah)
+
+      ros.blah = { changed: 'backing' }
+
+      expect(ros.blah.changed).to eql 'backing'
+    end
+
     describe "handling loops in the original Hashes" do
       let(:h1) { { :a => 'a'} }
       let(:h2) { { :a => 'b', :h1 => h1 } }
@@ -55,6 +64,34 @@ describe RecursiveOpenStruct do
       expect(ros.blah.blargh).to eq "Janet"
     end
 
+    describe 'subscript mutation notation' do
+      it 'handles the basic case' do
+        subject[:blah] = 12345
+        expect(subject.blah).to eql 12345
+      end
+
+      it 'recurses properly' do
+        subject[:blah][:another] = 'abc'
+        expect(subject.blah.another).to eql 'abc'
+        expect(subject.blah_as_a_hash).to eql({ :another => 'abc' })
+      end
+
+      let(:diff){ { :different => 'thing' } }
+
+      it 'can replace the entire hash' do
+        expect(subject.to_h).to eql(h)
+        subject[:blah] = diff
+        expect(subject.to_h).to eql({ :blah => diff })
+      end
+
+      it 'updates sub-element cache' do
+        expect(subject.blah.different).to be_nil
+        subject[:blah] = diff
+        expect(subject.blah.different).to eql 'thing'
+        expect(subject.blah_as_a_hash).to eql(diff)
+      end
+    end
+
     context "after a sub-element has been modified" do
       let(:hash) do
         { :blah => { :blargh => "Brad" }, :some_array => [ 1, 2, 3] }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.3
 platform: ruby
 authors:
 - William (B.J.) Snow Orvis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-29 00:00:00.000000000 Z
+date: 2020-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,6 +119,7 @@ files:
 - ".travis.yml"
 - AUTHORS.txt
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -127,17 +128,18 @@ files:
 - lib/recursive_open_struct.rb
 - lib/recursive_open_struct/debug_inspect.rb
 - lib/recursive_open_struct/deep_dup.rb
-- lib/recursive_open_struct/ruby_19_backport.rb
+- lib/recursive_open_struct/dig.rb
 - lib/recursive_open_struct/version.rb
 - recursive-open-struct.gemspec
 - spec/recursive_open_struct/debug_inspect_spec.rb
 - spec/recursive_open_struct/indifferent_access_spec.rb
 - spec/recursive_open_struct/open_struct_behavior_spec.rb
 - spec/recursive_open_struct/ostruct_2_0_0_spec.rb
+- spec/recursive_open_struct/ostruct_2_3_0_spec.rb
 - spec/recursive_open_struct/recursion_and_subclassing_spec.rb
 - spec/recursive_open_struct/recursion_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/aetherknight/recursive-open-struct
+homepage: https://github.com/aetherknight/recursive-open-struct
 licenses:
 - MIT
 metadata: {}
@@ -156,8 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs
@@ -166,6 +167,7 @@ test_files:
 - spec/recursive_open_struct/indifferent_access_spec.rb
 - spec/recursive_open_struct/open_struct_behavior_spec.rb
 - spec/recursive_open_struct/ostruct_2_0_0_spec.rb
+- spec/recursive_open_struct/ostruct_2_3_0_spec.rb
 - spec/recursive_open_struct/recursion_and_subclassing_spec.rb
 - spec/recursive_open_struct/recursion_spec.rb
 - spec/spec_helper.rb

data/lib/recursive_open_struct/ruby_19_backport.rb

@@ -1,27 +0,0 @@
-module RecursiveOpenStruct::Ruby19Backport
-  # Apply fix if necessary:
-  #   https://github.com/ruby/ruby/commit/2d952c6d16ffe06a28bb1007e2cd1410c3db2d58
-  def initialize_copy(orig)
-    super
-    @table.each_key{|key| new_ostruct_member(key)}
-  end
-
-  def []=(name, value)
-    modifiable[new_ostruct_member(name)] = value
-  end
-
-  def eql?(other)
-    return false unless other.kind_of?(OpenStruct)
-    @table.eql?(other.table)
-  end
-
-  def hash
-    @table.hash
-  end
-
-  def each_pair
-    return to_enum(:each_pair) { @table.size } unless block_given?
-    @table.each_pair{|p| yield p}
-  end
-end
-