recursive-open-struct 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aef116134efc7102292ad51046c306be7e93621f688e02255996ca218ed578b1
-  data.tar.gz: 722c1e817dbdd25d4a48deb5923ce6f83de55211dd86c00a5c292f91e86bc74b
+  metadata.gz: f4474b5a862c6ea4da4f2c930664880ca70a01f75c077a2e9952fd80ed2d26da
+  data.tar.gz: dcea4c80ebe98a5f91f9ea40b2b7e82cc219b259eae83b62a00329f8075cc85a
 SHA512:
-  metadata.gz: fde1398adbd2795f9f108859d1d6c963a89048275be0fbf5e5cb1f92abb404ed8a55d4e97a8e2ba0d6367d3a255ecfdfe3dcfacc74d1b9bdd0d0c4e035acbe09
-  data.tar.gz: 82d16703403627ea358097b26d47334a984107c68a9c5360ac617169c4b9602292a7d7df77a96971ac3369fcca11256457518a61ce9895b7fcf9b58ab924c50b
+  metadata.gz: e8698402e67013a209a3434235e26201550c2249db8ae82480ec2208bdd0c83fb6524be046ecb4af3ed8cfe09adebd513a383d56b8b40d91f2c973fcd1f18196
+  data.tar.gz: a15827f31947ca85607086b9cda61ab18b4421bb310dd3034ca4dd39ef43ecf5215d599103cb897152924d6faa1ae94e0bc800cf197c5e96ab50fc794c547a2c

data/AUTHORS.txt

@@ -3,6 +3,7 @@ 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>

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+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
 ==================
 

data/lib/recursive_open_struct.rb

@@ -3,7 +3,6 @@ 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
@@ -14,23 +13,28 @@ require 'recursive_open_struct/dig'
 # `#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
@@ -56,13 +60,8 @@ class RecursiveOpenStruct < OpenStruct
     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
@@ -70,6 +69,13 @@ class RecursiveOpenStruct < OpenStruct
     end
   end
 
+  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
+
   # 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'))
@@ -95,13 +101,16 @@ class RecursiveOpenStruct < OpenStruct
       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
@@ -120,8 +129,7 @@ class RecursiveOpenStruct < OpenStruct
           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
@@ -141,8 +149,8 @@ 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
@@ -153,11 +161,14 @@ class RecursiveOpenStruct < OpenStruct
     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/version.rb

@@ -3,5 +3,5 @@
 require 'ostruct'
 
 class RecursiveOpenStruct < OpenStruct
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 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.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - William (B.J.) Snow Orvis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-11 00:00:00.000000000 Z
+date: 2020-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -129,7 +129,6 @@ files:
 - lib/recursive_open_struct/debug_inspect.rb
 - lib/recursive_open_struct/deep_dup.rb
 - lib/recursive_open_struct/dig.rb
-- lib/recursive_open_struct/ruby_19_backport.rb
 - lib/recursive_open_struct/version.rb
 - recursive-open-struct.gemspec
 - spec/recursive_open_struct/debug_inspect_spec.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
-