recursive-open-struct 0.4.1 → 0.4.2

data/lib/recursive_open_struct.rb

@@ -1,15 +1,24 @@
 require 'ostruct'
 
 class RecursiveOpenStruct < OpenStruct
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 
   def initialize(h=nil, args={})
     @recurse_over_arrays = args.fetch(:recurse_over_arrays,false)
     super(h)
+    @sub_elements = {}
   end
 
   def to_h
-    @table.dup
+    @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
   end
 
   def new_ostruct_member(name)
@@ -19,9 +28,9 @@ class RecursiveOpenStruct < OpenStruct
         define_method(name) do
           v = @table[name]
           if v.is_a?(Hash)
-            RecursiveOpenStruct.new(v)
+            @sub_elements[name] ||= RecursiveOpenStruct.new(v)
           elsif v.is_a?(Array) and @recurse_over_arrays
-            v.map { |a| (a.is_a? Hash) ? RecursiveOpenStruct.new(a, :recurse_over_arrays => true) : a }
+            @sub_elements[name] ||= v.map { |a| (a.is_a? Hash) ? RecursiveOpenStruct.new(a, :recurse_over_arrays => true) : a }
           else
             v
           end

data/spec/recursive_open_struct_spec.rb

@@ -17,12 +17,6 @@ describe RecursiveOpenStruct do
       ros.asdf.should == "John Smith"
     end
 
-    it "can be converted back to a hash" do
-      h = { :asdf => 'John Smith' }
-      ros = RecursiveOpenStruct.new(h)
-      ros.to_h.should == h
-    end
-
     it "can modify an existing key" do
       h = { :blah => 'John Smith' }
       ros = RecursiveOpenStruct.new(h)
@@ -31,81 +25,120 @@ describe RecursiveOpenStruct do
     end
 
     describe "handling of arbitrary attributes" do
+      subject { RecursiveOpenStruct.new }
       before(:each) do
-        @ros = RecursiveOpenStruct.new
-        @ros.blah = "John Smith"
+        subject.blah = "John Smith"
       end
 
       describe "#respond?" do
-        it { @ros.should respond_to :blah }
-        it { @ros.should respond_to :blah= }
-        it { @ros.should_not respond_to :asdf }
-        it { @ros.should_not respond_to :asdf= }
+        it { subject.should respond_to :blah }
+        it { subject.should respond_to :blah= }
+        it { subject.should_not respond_to :asdf }
+        it { subject.should_not respond_to :asdf= }
       end # describe #respond?
 
       describe "#methods" do
-        it { @ros.methods.map(&:to_sym).should include :blah }
-        it { @ros.methods.map(&:to_sym).should include :blah= }
-        it { @ros.methods.map(&:to_sym).should_not include :asdf }
-        it { @ros.methods.map(&:to_sym).should_not include :asdf= }
+        it { subject.methods.map(&:to_sym).should include :blah }
+        it { subject.methods.map(&:to_sym).should include :blah= }
+        it { subject.methods.map(&:to_sym).should_not include :asdf }
+        it { subject.methods.map(&:to_sym).should_not include :asdf= }
       end # describe #methods
     end # describe handling of arbitrary attributes
   end # describe behavior it inherits from OpenStruct
 
-  describe "recursive behavior" do
-    before(:each) do
-      h = { :blah => { :another => 'value' } }
-      @ros = RecursiveOpenStruct.new(h)
+  describe "improvements on OpenStruct" do
+    it "can be converted back to a hash" do
+      h = { :asdf => 'John Smith' }
+      ros = RecursiveOpenStruct.new(h)
+      ros.to_h.should == h
     end
+  end
+
+  describe "recursive behavior" do
+    let(:h) { { :blah => { :another => 'value' } } }
+    subject { RecursiveOpenStruct.new(h) }
 
     it "returns accessed hashes as RecursiveOpenStructs instead of hashes" do
-      @ros.blah.another.should == 'value'
+      subject.blah.another.should == 'value'
     end
 
     it "uses #key_as_a_hash to return key as a Hash" do
-      @ros.blah_as_a_hash.should == { :another => 'value' }
+      subject.blah_as_a_hash.should == { :another => 'value' }
     end
 
     describe "handling loops in the origin Hashes" do
-      before(:each) do
-        h1 = { :a => 'a'}
-        h2 = { :a => 'b', :h1 => h1 }
-        h1[:h2] = h2
-        @ros = RecursiveOpenStruct.new(h2)
+      let(:h1) { { :a => 'a'} }
+      let(:h2) { { :a => 'b', :h1 => h1 } }
+      before(:each) { h1[:h2] = h2 }
+
+      subject { RecursiveOpenStruct.new(h2) }
+
+      it { subject.h1.a.should == 'a' }
+      it { subject.h1.h2.a.should == 'b' }
+      it { subject.h1.h2.h1.a.should == 'a' }
+      it { subject.h1.h2.h1.h2.a.should == 'b' }
+      it { subject.h1.should == subject.h1.h2.h1 }
+      it { subject.h1.should_not == subject.h1.h2 }
+    end # describe handling loops in the origin Hashes
+
+    it "can modify a key of a sub-element" do
+      h = {
+        :blah => {
+          :blargh => 'Brad'
+        }
+      }
+      ros = RecursiveOpenStruct.new(h)
+      ros.blah.blargh = "Janet"
+      ros.blah.blargh.should == "Janet"
+    end
+
+    context "after a sub-element has been modified" do
+      let(:hash) do
+        {
+          :blah => {
+            :blargh => 'Brad'
+          }
+        }
+      end
+      subject { RecursiveOpenStruct.new(hash) }
+      before(:each) { subject.blah.blargh = "Janet" }
+      it "returns a hash that contains those modifications" do
+        subject.to_h.should == { :blah => { :blargh => "Janet" } }
       end
+    end
 
-      it { @ros.h1.a.should == 'a' }
-      it { @ros.h1.h2.a.should == 'b' }
-      it { @ros.h1.h2.h1.a.should == 'a' }
-      it { @ros.h1.h2.h1.h2.a.should == 'b' }
-      it { @ros.h1.should == @ros.h1.h2.h1 }
-      it { @ros.h1.should_not == @ros.h1.h2 }
-    end # describe handling loops in the origin Hashes
 
     describe 'recursing over arrays' do
       let(:blah_list) { [ { :foo => '1' }, { :foo => '2' }, 'baz' ] }
       let(:h) { { :blah => blah_list } }
 
       context "when recursing over arrays is enabled" do
-        before(:each) do
-          @ros = RecursiveOpenStruct.new(h, :recurse_over_arrays => true)
+        subject { RecursiveOpenStruct.new(h, :recurse_over_arrays => true) }
+
+        it { subject.blah.length.should == 3 }
+        it { subject.blah[0].foo.should == '1' }
+        it { subject.blah[1].foo.should == '2' }
+        it { subject.blah_as_a_hash.should == blah_list }
+        it { subject.blah[2].should == 'baz' }
+        it "Retains changes across Array lookups" do
+          subject.blah[1].foo = "Dr Scott"
+          subject.blah[1].foo.should == "Dr Scott"
+        end
+        it "propagates the changes through to .to_h across Array lookups" do
+          subject.blah[1].foo = "Dr Scott"
+          subject.to_h.should == {
+            :blah => [ { :foo => '1' }, { :foo => "Dr Scott" }, 'baz' ]
+          }
         end
 
-        it { @ros.blah.length.should == 3 }
-        it { @ros.blah[0].foo.should == '1' }
-        it { @ros.blah[1].foo.should == '2' }
-        it { @ros.blah_as_a_hash.should == blah_list }
-        it { @ros.blah[2].should == 'baz' }
       end # when recursing over arrays is enabled
 
       context "when recursing over arrays is disabled" do
-        before(:each) do
-          @ros = RecursiveOpenStruct.new(h)
-        end
+        subject { RecursiveOpenStruct.new(h) }
 
-        it { @ros.blah.length.should == 3 }
-        it { @ros.blah[0].should == { :foo => '1' } }
-        it { @ros.blah[0][:foo].should == '1' }
+        it { subject.blah.length.should == 3 }
+        it { subject.blah[0].should == { :foo => '1' } }
+        it { subject.blah[0][:foo].should == '1' }
       end # when recursing over arrays is disabled
 
     end # recursing over arrays

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-29 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec