recursive-open-struct 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72ff48c134d3b90f56c0c2808e55f107c8bdd302
-  data.tar.gz: 3acf497ceb23b7b86de443dc3b4a83ddffa143eb
+  metadata.gz: ad6b86b4a8ed2c69543135a33097d06f13e92671
+  data.tar.gz: bb738b78cb40ff95bb7d257cda73a68b5dec6f7b
 SHA512:
-  metadata.gz: 0279ca781f0607ae71c16d21589644a7b6151605f7f8cd74b47129ff2aad4c99536893375215aa9308342db54ba117ce271346bbc9c6a589c10e0f5bb105c9d1
-  data.tar.gz: be2d8df65e43686494858e8ab4cbec822336bcd5f68d0f87445fd968afd4ea08770e766192c489d900ae7d6b7233b9a17308da0089c7f6aa821b45e967f29a4c
+  metadata.gz: fd1efd0c19bc1e6418592d071b32fcf5df03a341b852f6e1c4a5a75f7cf120494135a518011348848718c960e96414e1db033a985e388dca1060790fd7f9e922
+  data.tar.gz: 8a2e0a8592dac362652a0e8adb369b4b611df7cdbab37c55dd8cae75bad1ca6cc1976f11fedfa4d751fa0ae099e0a44551368ae838e76cedb3591ab06585aae1

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+0.6.1 / 2015-03-28
+==================
+
+* FIX: Actually ensure that the internal @table is properly dependent or
+  independent of the input hash tree. I mistakenly refactored away an important
+  piece of code that fervic added.
+* FIX: Actually ensure that `#dup` works.
+* Also refactored how `#to_h` is implemented to use newer plumbing.
+
 0.6.0 / 2015-03-28
 ==================
 

data/Gemfile

@@ -1,6 +1,8 @@
 source 'http://rubygems.org'
 gemspec
 
+gem 'pry'
+
 group :development do
   if RUBY_VERSION =~ /^1\.8/
     gem 'rcov'

data/README.md

@@ -5,23 +5,23 @@ RecursiveOpenStructs.
 
 It allows for hashes within hashes to be called in a chain of methods:
 
-  ros = RecursiveOpenStruct.new( { :fooa => { :foob => 'fooc' } } )
+    ros = RecursiveOpenStruct.new( { :fooa => { :foob => 'fooc' } } )
 
-  ros.fooa.foob # => 'fooc'
+    ros.fooa.foob # => 'fooc'
 
 Also, if needed, nested hashes can still be accessed as hashes:
 
-  ros.fooa_as_a_hash # { :foob => 'fooc' }
+    ros.fooa_as_a_hash # { :foob => 'fooc' }
 
 RecursiveOpenStruct can also optionally recurse across arrays, although you
 have to explicitly enable it:
 
-  h = { :somearr => [ { :name => 'a'}, { :name => 'b' } ] }
+    h = { :somearr => [ { :name => 'a'}, { :name => 'b' } ] }
 
-  ros = RecursiveOpenStruct.new(h, :recurse_over_arrays => true )
+    ros = RecursiveOpenStruct.new(h, :recurse_over_arrays => true )
 
-  ros.somarr[0].name # => 'a'
-  ros.somarr[1].name # => 'b'
+    ros.somarr[0].name # => 'a'
+    ros.somarr[1].name # => 'b'
 
 ## Installation
 
@@ -29,11 +29,11 @@ Available as a gem in rubygems, the default gem repository.
 
 If you use bundler, just throw that in your gemfile :
 
-  gem 'recursive-open-struct'
+    gem 'recursive-open-struct'
 
 You may also install the gem manually :
 
-  gem install recursive-open-struct
+    gem install recursive-open-struct
 
 ## Contributing
  

data/lib/recursive_open_struct.rb

@@ -17,19 +17,25 @@ class RecursiveOpenStruct < OpenStruct
 
     super(hash)
 
+    if mutate_input_hash && hash
+      hash.clear
+      @table.each { |k,v| hash[k] = v }
+      @table = hash
+    end
+
+    @sub_elements = {}
+  end
+
+  def initialize_copy(orig)
+    super
+    # deep copy the table to separate the two objects
+    @table = DeepDup.new(recurse_over_arrays: @recurse_over_arrays).call(orig.instance_variable_get(:@table))
+    # Forget any memoized sub-elements
     @sub_elements = {}
   end
 
   def to_h
-    @table.dup.update(@sub_elements) do |k, oldval, newval|
-      if newval.kind_of?(self.class)
-        newval.to_h
-      elsif newval.kind_of?(Array)
-        newval.map { |a| a.kind_of?(self.class) ? a.to_h : a }
-      else
-        raise "Cached value of unsupported type: #{newval.inspect}"
-      end
-    end
+    DeepDup.new(recurse_over_arrays: @recurse_over_arrays).call(@table)
   end
 
   alias_method :to_hash, :to_h

data/lib/recursive_open_struct/version.rb

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

data/spec/recursive_open_struct_spec.rb

@@ -110,11 +110,19 @@ describe RecursiveOpenStruct do
 
       before(:each) { subject.blah.blargh = "Janet" }
 
-      it "returns a hash tree that contains those modifications" do
-        subject.to_h.should == updated_hash
+      describe ".to_h" do
+        it "returns a hash tree that contains those modifications" do
+          subject.to_h.should == updated_hash
+        end
+
+        specify "modifying the returned hash tree does not modify the ROS" do
+          subject.to_h[:blah][:blargh] = "Dr Scott"
+
+          subject.blah.blargh.should == "Janet"
+        end
       end
 
-      it "does not mutate the input hash tree passed to the constructor" do
+      it "does not mutate the original hash tree passed to the constructor" do
         hash[:blah][:blargh].should == 'Brad'
       end
 
@@ -123,6 +131,22 @@ describe RecursiveOpenStruct do
 
         hash[:some_array][0].should == 4
       end
+
+      describe "#dup" do
+        let(:duped_subject) { subject.dup }
+
+        it "preserves sub-element modifications" do
+          duped_subject.blah.blargh.should == subject.blah.blargh
+        end
+
+        it "allows the copy's sub-elements to be modified independently from the original's" do
+          subject.blah.blargh.should == "Janet"
+          duped_subject.blah.blargh = "Dr. Scott"
+
+          duped_subject.blah.blargh.should == "Dr. Scott"
+          subject.blah.blargh.should == "Janet"
+        end
+      end
     end
 
     describe 'recursing over arrays' do
@@ -154,6 +178,12 @@ describe RecursiveOpenStruct do
             }
           end
 
+          it "deep-copies hashes within Arrays" do
+            subject.to_h[:blah][1][:foo] = "Rocky"
+
+            subject.blah[1].foo.should == "Dr Scott"
+          end
+
           it "does not mutate the input hash passed to the constructor" do
             h[:blah][1][:foo].should == '2'
           end
@@ -161,6 +191,21 @@ describe RecursiveOpenStruct do
           it "the deep copy recurses over Arrays as well" do
             h[:blah][1][:foo].should == '2'
           end
+
+          describe "#dup" do
+            let(:duped_subject) { subject.dup }
+
+            it "preserves sub-element modifications" do
+              duped_subject.blah[1].foo.should == subject.blah[1].foo
+            end
+
+            it "allows the copy's sub-elements to be modified independently from the original's" do
+              duped_subject.blah[1].foo = "Rocky"
+
+              duped_subject.blah[1].foo.should == "Rocky"
+              subject.blah[1].foo.should == "Dr Scott"
+            end
+          end
         end
 
         context "when array is nested deeper" do

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
+require 'pry'
 
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - William (B.J.) Snow Orvis