recursive-open-struct 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1f1a8f65c6217fb268d9cb42d7a862c17331c9a
-  data.tar.gz: 0ac4e5cd8da82078b32e3c782668e1446f2383bb
+  metadata.gz: 7067232359a27f9453674a17396798cb42b085d4
+  data.tar.gz: 88fbfa54a7bff4548ab752ae681309afda312923
 SHA512:
-  metadata.gz: 3ccb7649bea9011276fa62f1f5e1d22956446d846d41320616e1a1b83738bf1ede1baa128cc9fa2d283e1b591dbc8f765dcbde1f64ffd7a367535edda95114e1
-  data.tar.gz: 5c762d9925b274435e1753b1c24b4b4e84ddc49f84cc2780c40e39fd01aa803eb071b8f9afc1484aa974500fa08a34ccaf5c12602bafeb55131a22483b413ec3
+  metadata.gz: 50a3ea326db6026dfa417ecb81919ecda0e1b997753ea908a28c22281a9586d8b081b33dee0bacafb12ab65f568f91646237386d40d46a0bd070159a4bd3c594
+  data.tar.gz: bec50eceabca004115b14b176caf67253fa7b06414552d2051cc4d3502508c5a3fbab27f08027907aba1e7571391a03e92ac4c04a3260aa870b651f9eb8a785b

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+0.6.4 / 2015-05-20
+==================
+
+* FIX: Kris Dekeyser: Fix indifferent subscript access (string or symbol). Also
+  backported several ostruct methods for Ruby 1.9.x.
+* FIX: Partial fix for allowing an array in a RecursiveOpenStruct tree to be
+  modified. However, methods such as to_hash are still broken.
+
 0.6.3 / 2015-04-11
 ==================
 

data/lib/recursive_open_struct.rb

@@ -3,8 +3,10 @@ require 'recursive_open_struct/version'
 
 require 'recursive_open_struct/debug_inspect'
 require 'recursive_open_struct/deep_dup'
+require 'recursive_open_struct/ruby_19_backport'
 
 class RecursiveOpenStruct < OpenStruct
+  include Ruby19Backport if RUBY_VERSION =~ /\A1.9/
   include DebugInspect
 
   def initialize(hash={}, args={})
@@ -20,10 +22,6 @@ class RecursiveOpenStruct < OpenStruct
   def initialize_copy(orig)
     super
 
-    # Apply fix if necessary:
-    #   https://github.com/ruby/ruby/commit/2d952c6d16ffe06a28bb1007e2cd1410c3db2d58
-    @table.each_key{|key| new_ostruct_member(key)} if RUBY_VERSION =~ /^1.9/
-
     # deep copy the table to separate the two objects
     @table = @deep_dup.call(orig.instance_variable_get(:@table))
     # Forget any memoized sub-elements
@@ -41,28 +39,32 @@ class RecursiveOpenStruct < OpenStruct
   end
 
   def new_ostruct_member(name)
+    key_name = _get_key_from_table_ name
     unless self.respond_to?(name)
       class << self; self; end.class_eval do
         define_method(name) do
-          v = @table[name]
+          v = @table[key_name]
           if v.is_a?(Hash)
-            @sub_elements[name] ||= self.class.new(v,
-                                      :recurse_over_arrays => @recurse_over_arrays,
-                                      :mutate_input_hash => true)
+            @sub_elements[key_name] ||= self.class.new(
+              v,
+              :recurse_over_arrays => @recurse_over_arrays,
+              :mutate_input_hash => true
+            )
           elsif v.is_a?(Array) and @recurse_over_arrays
-            @sub_elements[name] ||= recurse_over_array(v)
+            @sub_elements[key_name] ||= recurse_over_array(v)
+            @sub_elements[key_name] = recurse_over_array(@sub_elements[key_name])
           else
             v
           end
         end
         define_method("#{name}=") do |x|
-          @sub_elements.delete(name)
-          modifiable[name] = x
+          @sub_elements.delete(key_name)
+          modifiable[key_name] = x
         end
-        define_method("#{name}_as_a_hash") { @table[name] }
+        define_method("#{name}_as_a_hash") { @table[key_name] }
       end
     end
-    name
+    key_name
   end
 
   # TODO: Make me private if/when we do an API-breaking change release
@@ -77,5 +79,19 @@ class RecursiveOpenStruct < OpenStruct
       end
     end
   end
-end
 
+  def delete_field(name)
+    sym = _get_key_from_table_(name)
+    singleton_class.__send__(:remove_method, sym, "#{sym}=")
+    @sub_elements.delete sym
+    @table.delete sym
+  end
+
+  private
+
+  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
+end

data/lib/recursive_open_struct/ruby_19_backport.rb

@@ -0,0 +1,27 @@
+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
+

data/lib/recursive_open_struct/version.rb

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

data/spec/recursive_open_struct/debug_inspect_spec.rb

@@ -0,0 +1,70 @@
+require_relative '../spec_helper'
+require 'recursive_open_struct'
+
+describe RecursiveOpenStruct do
+  describe "#debug_inspect" do
+    before(:each) do
+      h1 = { :a => 'a'}
+      h2 = { :a => 'b', :h1 => h1 }
+      h1[:h2] = h2
+      @ros = RecursiveOpenStruct.new(h2)
+    end
+
+    it "should have a simple way of display" do
+      @output = <<-QUOTE
+a = "b"
+h1.
+  a = "a"
+  h2.
+    a = "b"
+    h1.
+      a = "a"
+      h2.
+        a = "b"
+        h1.
+          a = "a"
+          h2.
+            a = "b"
+            h1.
+              a = "a"
+              h2.
+                a = "b"
+                h1.
+                  a = "a"
+                  h2.
+                    a = "b"
+                    h1.
+                      a = "a"
+                      h2.
+                        (recursion limit reached)
+      QUOTE
+      @io = StringIO.new
+      @ros.debug_inspect(@io)
+      expect(@io.string).to match /^a = "b"$/
+      expect(@io.string).to match /^h1\.$/
+      expect(@io.string).to match /^  a = "a"$/
+      expect(@io.string).to match /^  h2\.$/
+      expect(@io.string).to match /^    a = "b"$/
+      expect(@io.string).to match /^    h1\.$/
+      expect(@io.string).to match /^      a = "a"$/
+      expect(@io.string).to match /^      h2\.$/
+      expect(@io.string).to match /^        a = "b"$/
+      expect(@io.string).to match /^        h1\.$/
+      expect(@io.string).to match /^          a = "a"$/
+      expect(@io.string).to match /^          h2\.$/
+      expect(@io.string).to match /^            a = "b"$/
+      expect(@io.string).to match /^            h1\.$/
+      expect(@io.string).to match /^              a = "a"$/
+      expect(@io.string).to match /^              h2\.$/
+      expect(@io.string).to match /^                a = "b"$/
+      expect(@io.string).to match /^                h1\.$/
+      expect(@io.string).to match /^                  a = "a"$/
+      expect(@io.string).to match /^                  h2\.$/
+      expect(@io.string).to match /^                    a = "b"$/
+      expect(@io.string).to match /^                    h1\.$/
+      expect(@io.string).to match /^                      a = "a"$/
+      expect(@io.string).to match /^                      h2\.$/
+      expect(@io.string).to match /^                        \(recursion limit reached\)$/
+    end
+  end
+end

data/spec/recursive_open_struct/indifferent_access_spec.rb

@@ -0,0 +1,150 @@
+require_relative '../spec_helper'
+require 'recursive_open_struct'
+
+describe RecursiveOpenStruct do
+  let(:value) { 'foo' }
+  let(:symbol) { :bar }
+  let(:new_value) { 'bar' }
+  let(:new_symbol) { :foo }
+
+  describe 'indifferent access' do
+    let(:hash) { {:foo => value, 'bar' => symbol} }
+    subject(:hash_ros) { RecursiveOpenStruct.new(hash) }
+    context 'setting value with method' do
+
+      before(:each) do
+        subject.foo = value
+      end
+
+      it('allows getting with method') { expect(subject.foo).to be value }
+      it('allows getting with symbol') { expect(subject[:foo]).to be value }
+      it('allows getting with string') { expect(subject['foo']).to be value }
+
+    end
+
+    context 'setting value with symbol' do
+
+      before(:each) do
+        subject[:foo] = value
+      end
+
+      it('allows getting with method') { expect(subject.foo).to be value }
+      it('allows getting with symbol') { expect(subject[:foo]).to be value }
+      it('allows getting with string') { expect(subject['foo']).to be value }
+
+    end
+
+    context 'setting value with string' do
+
+      before(:each) do
+        subject['foo'] = value
+      end
+
+      it('allows getting with method') { expect(subject.foo).to be value }
+      it('allows getting with symbol') { expect(subject[:foo]).to be value }
+      it('allows getting with string') { expect(subject['foo']).to be value }
+
+    end
+
+    context 'overwriting values' do
+
+      context 'set with method' do
+
+        before(:each) do
+          subject.foo = value
+        end
+
+        it('overrides with symbol') do
+          subject[:foo] = new_value
+          expect(subject.foo).to be new_value
+        end
+
+        it('overrides with string') do
+          subject['foo'] = new_value
+          expect(subject.foo).to be new_value
+        end
+
+      end
+
+      context 'set with symbol' do
+
+        before(:each) do
+          subject[:foo] = value
+        end
+
+        it('overrides with method') do
+          subject.foo = new_value
+          expect(subject[:foo]).to be new_value
+        end
+
+        it('overrides with string') do
+          subject['foo'] = new_value
+          expect(subject[:foo]).to be new_value
+        end
+
+      end
+
+      context 'set with string' do
+
+        before(:each) do
+          subject['foo'] = value
+        end
+
+        it('overrides with method') do
+          subject.foo = new_value
+          expect(subject['foo']).to be new_value
+        end
+
+        it('overrides with symbol') do
+          subject[:foo] = new_value
+          expect(subject['foo']).to be new_value
+        end
+
+      end
+
+      context 'set with hash' do
+
+        it('overrides with method') do
+          hash_ros.foo = new_value
+          expect(hash_ros[:foo]).to be new_value
+
+          hash_ros.bar = new_symbol
+          expect(hash_ros['bar']).to be new_symbol
+        end
+
+        it('overrides with symbol') do
+          hash_ros[:bar] = new_symbol
+          expect(hash_ros['bar']).to be new_symbol
+        end
+
+        it('overrides with string') do
+          hash_ros['foo'] = new_value
+          expect(hash_ros[:foo]).to be new_value
+        end
+
+      end
+
+      context 'keeps original keys' do
+        subject(:recursive) { RecursiveOpenStruct.new(recursive_hash, recurse_over_arrays: true) }
+        let(:recursive_hash) { {:foo => [ {'bar' => [ { 'foo' => :bar} ] } ] } }
+        let(:modified_hash) { {:foo => [ {'bar' => [ { 'foo' => :foo} ] } ] } }
+
+        it 'after initialization' do
+          expect(hash_ros.to_h).to eq hash
+        end
+
+        it 'in recursive hashes' do
+          expect(recursive.to_h).to eq recursive_hash
+        end
+
+        it 'after resetting value' do
+          recursive.foo.first[:bar].first[:foo] = :foo
+          expect(recursive.to_h).to eq modified_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/recursive_open_struct/open_struct_behavior_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../spec_helper'
+require 'recursive_open_struct'
+
+describe RecursiveOpenStruct do
+  let(:hash) { {} }
+  subject(:ros) { RecursiveOpenStruct.new(hash) }
+
+  describe "behavior it inherits from OpenStruct" do
+    context 'when not initialized from anything' do
+      subject(:ros) { RecursiveOpenStruct.new }
+      it "can represent arbitrary data objects" do
+        ros.blah = "John Smith"
+        expect(ros.blah).to eq "John Smith"
+      end
+    end
+
+    context "when initialized from a hash" do
+      let(:hash) { { :asdf => 'John Smith' } }
+
+      context 'that contains symbol keys' do
+        it "turns those symbol keys into method names" do
+          expect(ros.asdf).to eq "John Smith"
+        end
+      end
+
+      it "can modify an existing key" do
+        ros.asdf = "George Washington"
+        expect(ros.asdf).to eq "George Washington"
+      end
+
+      context 'that contains string keys' do
+        let(:hash) { { 'asdf' => 'John Smith' } }
+        it "turns those string keys into method names" do
+          expect(ros.asdf).to eq "John Smith"
+        end
+      end
+
+    end
+
+
+    describe "handling of arbitrary attributes" do
+      subject { RecursiveOpenStruct.new }
+      before(:each) do
+        subject.blah = "John Smith"
+      end
+
+      describe "#respond?" do
+        it { expect(subject).to respond_to :blah }
+        it { expect(subject).to respond_to :blah= }
+        it { expect(subject).to_not respond_to :asdf }
+        it { expect(subject).to_not respond_to :asdf= }
+      end # describe #respond?
+
+      describe "#methods" do
+        it { expect(subject.methods.map(&:to_sym)).to include :blah }
+        it { expect(subject.methods.map(&:to_sym)).to include :blah= }
+        it { expect(subject.methods.map(&:to_sym)).to_not include :asdf }
+        it { expect(subject.methods.map(&:to_sym)).to_not include :asdf= }
+      end # describe #methods
+    end # describe handling of arbitrary attributes
+  end # describe behavior it inherits from OpenStruct
+end

data/spec/recursive_open_struct/ostruct_2_0_0_spec.rb

@@ -0,0 +1,105 @@
+require_relative '../spec_helper'
+require 'recursive_open_struct'
+
+describe RecursiveOpenStruct do
+
+  let(:hash) { {:foo => 'foo', 'bar' => :bar} }
+  subject(:ros) { RecursiveOpenStruct.new(hash) }
+
+  describe "OpenStruct 2.0 methods" do
+
+    context "Hash style setter" do
+
+      it "method exists" do
+        expect(ros.respond_to?('[]=')).to be_truthy
+      end
+
+      it "changes the value" do
+        ros[:foo] = :foo
+        ros.foo = :foo
+      end
+
+    end
+
+    context "delete_field" do
+
+      before(:each) { ros.delete_field :foo }
+
+      it "removes the value" do
+        expect(ros.foo).to be_nil
+        expect(ros.to_h).to_not include(:foo)
+      end
+
+      it "removes the getter method" do
+        is_expected.to_not respond_to :foo
+      end
+
+      it "removes the setter method" do
+        expect(ros.respond_to? 'foo=').to be_falsey
+      end
+
+      it "works with indifferent access" do
+        expect(ros.delete_field :bar).to eq :bar
+        is_expected.to_not respond_to :bar
+        is_expected.to_not respond_to 'bar='
+        expect(ros.to_h).to be_empty
+      end
+
+    end
+
+    context "eql?" do
+      subject(:new_ros) { ros.dup }
+
+      context "with identical ROS" do
+        subject { ros }
+        it { is_expected.to be_eql ros }
+      end
+
+      context "with similar ROS" do
+        subject { RecursiveOpenStruct.new(hash) }
+        it { is_expected.to be_eql ros }
+      end
+
+      context "with same Hash" do
+        subject { RecursiveOpenStruct.new(hash, recurse_over_arrays: true) }
+        it { is_expected.to be_eql ros }
+      end
+
+      context "with duplicated ROS" do
+        subject { ros.dup }
+
+        it "fails on different value" do
+          subject.foo = 'bar'
+          is_expected.not_to be_eql ros
+        end
+
+        it "fails on missing field" do
+          subject.delete_field :bar
+          is_expected.not_to be_eql ros
+        end
+
+        it "fails on added field" do
+          subject.baz = :baz
+          is_expected.not_to be_eql ros
+        end
+
+      end
+
+    end
+
+    context "hash" do
+      it "calculates table hash" do
+        expect(ros.hash).to be ros.instance_variable_get('@table').hash
+      end
+
+    end
+
+    context "each_pair" do
+      it "iterates over hash keys" do
+        expect(ros.each_pair).to match hash.each_pair
+      end
+    end
+
+  end
+
+end

data/spec/recursive_open_struct/recursion_and_subclassing_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../spec_helper'
+require 'recursive_open_struct'
+
+describe RecursiveOpenStruct do
+  describe "subclassing RecursiveOpenStruct" do
+    let(:subclass) { Class.new(RecursiveOpenStruct) }
+
+    subject(:rossc) { subclass.new({ :one => [{:two => :three}] }, recurse_over_arrays: true) }
+
+    specify "nested objects use the subclass of the parent" do
+      expect(rossc.one.first.class).to eq subclass
+    end
+  end
+end

data/spec/recursive_open_struct/recursion_spec.rb

@@ -0,0 +1,284 @@
+require_relative '../spec_helper'
+require 'recursive_open_struct'
+
+describe RecursiveOpenStruct do
+
+  describe "recursive behavior" do
+    let(:h) { { :blah => { :another => 'value' } } }
+    subject { RecursiveOpenStruct.new(h) }
+
+    it "can convert the entire hash tree back into a hash" do
+      blank_obj = Object.new
+      h = {:asdf => 'John Smith', :foo => [{:bar => blank_obj}, {:baz => nil}]}
+      ros = RecursiveOpenStruct.new(h)
+
+      expect(ros.to_h).to eq h
+      expect(ros.to_hash).to eq h
+    end
+
+    it "returns accessed hashes as RecursiveOpenStructs instead of hashes" do
+      expect(subject.blah.another).to eq 'value'
+    end
+
+    it "handles subscript notation the same way as dotted notation" do
+      expect(subject.blah.another).to eq subject[:blah].another
+    end
+
+    it "uses #key_as_a_hash to return key as a Hash" do
+      expect(subject.blah_as_a_hash).to eq({ :another => 'value' })
+    end
+
+    describe "handling loops in the original Hashes" do
+      let(:h1) { { :a => 'a'} }
+      let(:h2) { { :a => 'b', :h1 => h1 } }
+      before(:each) { h1[:h2] = h2 }
+
+      subject { RecursiveOpenStruct.new(h2) }
+
+      it { expect(subject.h1.a).to eq 'a' }
+      it { expect(subject.h1.h2.a).to eq 'b' }
+      it { expect(subject.h1.h2.h1.a).to eq 'a' }
+      it { expect(subject.h1.h2.h1.h2.a).to eq 'b' }
+      it { expect(subject.h1).to eq subject.h1.h2.h1 }
+      it { expect(subject.h1).to_not eq 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"
+
+      expect(ros.blah.blargh).to eq "Janet"
+    end
+
+    context "after a sub-element has been modified" do
+      let(:hash) do
+        { :blah => { :blargh => "Brad" }, :some_array => [ 1, 2, 3] }
+      end
+      let(:updated_hash) do
+        { :blah => { :blargh => "Janet" }, :some_array => [ 1, 2, 3] }
+      end
+
+      subject { RecursiveOpenStruct.new(hash) }
+
+      before(:each) { subject.blah.blargh = "Janet" }
+
+      describe ".to_h" do
+        it "returns a hash tree that contains those modifications" do
+          expect(subject.to_h).to eq updated_hash
+        end
+
+        specify "modifying the returned hash tree does not modify the ROS" do
+          subject.to_h[:blah][:blargh] = "Dr Scott"
+
+          expect(subject.blah.blargh).to eq "Janet"
+        end
+      end
+
+      it "does not mutate the original hash tree passed to the constructor" do
+        expect(hash[:blah][:blargh]).to eq 'Brad'
+      end
+
+      it "limits the deep-copy to the initial hash tree" do
+        subject.some_array[0] = 4
+
+        expect(hash[:some_array][0]).to eq 4
+      end
+
+      describe "#dup" do
+        let(:duped_subject) { subject.dup }
+
+        it "preserves sub-element modifications" do
+          expect(duped_subject.blah.blargh).to eq subject.blah.blargh
+        end
+
+        it "allows the copy's sub-elements to be modified independently from the original's" do
+          expect(subject.blah.blargh).to eq "Janet"
+
+          duped_subject.blah.blargh = "Dr. Scott"
+
+          expect(subject.blah.blargh).to eq "Janet"
+          expect(duped_subject.blah.blargh).to eq "Dr. Scott"
+        end
+      end
+    end
+
+    context "when memoizing and then modifying entire recursive structures" do
+      subject do
+        RecursiveOpenStruct.new(
+          { :blah => original_blah }, :recurse_over_arrays => true)
+      end
+
+      before(:each) { subject.blah } # enforce memoization
+
+      context "when modifying an entire Hash" do
+        let(:original_blah) { { :a => 'A', :b => 'B' } }
+        let(:new_blah) { { :something_new => "C" } }
+
+        before(:each) { subject.blah = new_blah }
+
+        it "returns the modified value instead of the memoized one" do
+          expect(subject.blah.something_new).to eq "C"
+        end
+
+        specify "the old value no longer exists" do
+          expect(subject.blah.a).to be_nil
+        end
+      end
+
+      context "when modifying an entire Array" do
+        let(:original_blah) { [1, 2, 3] }
+
+        it "returns the modified value instead of the memoized one" do
+          new_blah = [4, 5, 6]
+          subject.blah = new_blah
+          expect(subject.blah).to eq new_blah
+        end
+      end
+    end
+
+    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
+        subject { RecursiveOpenStruct.new(h, :recurse_over_arrays => true) }
+
+        it { expect(subject.blah.length).to eq 3 }
+        it { expect(subject.blah[0].foo).to eq '1' }
+        it { expect(subject.blah[1].foo).to eq '2' }
+        it { expect(subject.blah_as_a_hash).to eq blah_list }
+        it { expect(subject.blah[2]).to eq 'baz' }
+
+        context "when an inner value changes" do
+          let(:updated_blah_list) { [ { :foo => '1' }, { :foo => 'Dr Scott' }, 'baz' ] }
+          let(:updated_h) { { :blah => updated_blah_list } }
+
+          before(:each) { subject.blah[1].foo = "Dr Scott" }
+
+          it "Retains changes across Array lookups" do
+            expect(subject.blah[1].foo).to eq "Dr Scott"
+          end
+
+          it "propagates the changes through to .to_h across Array lookups" do
+            expect(subject.to_h).to eq({
+              :blah => [ { :foo => '1' }, { :foo => "Dr Scott" }, 'baz' ]
+            })
+          end
+
+          it "deep-copies hashes within Arrays" do
+            subject.to_h[:blah][1][:foo] = "Rocky"
+
+            expect(subject.blah[1].foo).to eq "Dr Scott"
+          end
+
+          it "does not mutate the input hash passed to the constructor" do
+            expect(h[:blah][1][:foo]).to eq '2'
+          end
+
+          it "the deep copy recurses over Arrays as well" do
+            expect(h[:blah][1][:foo]).to eq '2'
+          end
+
+          describe "#dup" do
+            let(:duped_subject) { subject.dup }
+
+            it "preserves sub-element modifications" do
+              expect(duped_subject.blah[1].foo).to eq 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"
+
+              expect(duped_subject.blah[1].foo).to eq "Rocky"
+              expect(subject.blah[1].foo).to eq "Dr Scott"
+            end
+          end
+        end
+
+        context "when array is nested deeper" do
+          let(:deep_hash) { { :foo => { :blah => blah_list } } }
+          subject { RecursiveOpenStruct.new(deep_hash, :recurse_over_arrays => true) }
+
+          it { expect(subject.foo.blah.length).to eq 3 }
+          it "Retains changes across Array lookups" do
+            subject.foo.blah[1].foo = "Dr Scott"
+            expect(subject.foo.blah[1].foo).to eq "Dr Scott"
+          end
+
+        end
+
+        context "when array is in an array" do
+          let(:haah) { { :blah => [ blah_list ] } }
+          subject { RecursiveOpenStruct.new(haah, :recurse_over_arrays => true) }
+
+          it { expect(subject.blah.length).to eq 1 }
+          it { expect(subject.blah[0].length).to eq 3 }
+          it "Retains changes across Array lookups" do
+            subject.blah[0][1].foo = "Dr Scott"
+
+            expect(subject.blah[0][1].foo).to eq "Dr Scott"
+          end
+
+        end
+
+      end # when recursing over arrays is enabled
+
+      context "when recursing over arrays is disabled" do
+        subject { RecursiveOpenStruct.new(h) }
+
+        it { expect(subject.blah.length).to eq 3 }
+        it { expect(subject.blah[0]).to eq({ :foo => '1' }) }
+        it { expect(subject.blah[0][:foo]).to eq '1' }
+      end # when recursing over arrays is disabled
+
+      describe 'modifying an array and recursing over it' do
+        let(:h) { {} }
+        subject { RecursiveOpenStruct.new(h, recurse_over_arrays: true) }
+
+        context 'when adding an array with hashes into the tree' do
+          before(:each) do
+            subject.mystery = {}
+            subject.mystery.science = [{ theatre: 9000 }]
+          end
+
+          it "ROS's it" do
+            expect(subject.mystery.science[0].theatre).to eq 9000
+          end
+        end
+
+        context 'when appending a hash to an array' do
+          before(:each) do
+            subject.mystery = {}
+            subject.mystery.science = []
+            subject.mystery.science << { theatre: 9000 }
+          end
+
+          it "ROS's it" do
+            expect(subject.mystery.science[0].theatre).to eq 9000
+          end
+        end
+
+        context 'after appending a hash to an array' do
+          before(:each) do
+            subject.mystery = {}
+            subject.mystery.science = []
+            subject.mystery.science[0] = {}
+          end
+
+          it "can have new values be set" do
+            expect do
+              subject.mystery.science[0].theatre = 9000
+            end.to_not raise_error
+
+            expect(subject.mystery.science[0].theatre).to eq 9000
+          end
+        end
+      end # modifying an array and then recursing
+    end # recursing over arrays
+  end # recursive behavior
+end

data/spec/spec_helper.rb

@@ -15,5 +15,5 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
-  config.expect_with(:rspec) { |c| c.syntax = :should }
+#  config.expect_with(:rspec) { |c| c.syntax = :should }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - William (B.J.) Snow Orvis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-11 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -126,9 +126,15 @@ 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/version.rb
 - recursive-open-struct.gemspec
-- spec/recursive_open_struct_spec.rb
+- 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/recursion_and_subclassing_spec.rb
+- spec/recursive_open_struct/recursion_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/aetherknight/recursive-open-struct
 licenses:
@@ -155,5 +161,10 @@ signing_key:
 specification_version: 4
 summary: OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs
 test_files:
-- spec/recursive_open_struct_spec.rb
+- 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/recursion_and_subclassing_spec.rb
+- spec/recursive_open_struct/recursion_spec.rb
 - spec/spec_helper.rb

data/spec/recursive_open_struct_spec.rb

@@ -1,366 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'recursive_open_struct'
-
-describe RecursiveOpenStruct do
-
-  describe "behavior it inherits from OpenStruct" do
-
-    it "can represent arbitrary data objects" do
-      ros = RecursiveOpenStruct.new
-      ros.blah = "John Smith"
-      ros.blah.should == "John Smith"
-    end
-
-    context "can be created from a hash" do
-      it "and keys are instanced as symbol" do
-        h = { :asdf => 'John Smith' }
-        ros = RecursiveOpenStruct.new(h)
-        ros.asdf.should == "John Smith"
-      end
-
-      it "and keys are instanced as string" do
-        h = { "asdf" => 'John Smith' }
-        ros = RecursiveOpenStruct.new(h)
-        ros.asdf.should == "John Smith"
-      end
-    end
-
-    it "can modify an existing key" do
-      h = { :blah => 'John Smith' }
-      ros = RecursiveOpenStruct.new(h)
-      ros.blah = "George Washington"
-      ros.blah.should == "George Washington"
-    end
-
-    describe "handling of arbitrary attributes" do
-      subject { RecursiveOpenStruct.new }
-      before(:each) do
-        subject.blah = "John Smith"
-      end
-
-      describe "#respond?" do
-        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 { 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 "improvements on OpenStruct" do
-    it "can be converted back to a hash" do
-      blank_obj = Object.new
-      h = {:asdf => 'John Smith', :foo => [{:bar => blank_obj}, {:baz => nil}]}
-      ros = RecursiveOpenStruct.new(h)
-      ros.to_h.should == h
-      ros.to_hash.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
-      subject.blah.another.should == 'value'
-    end
-
-    it "handles subscript notation the same way as dotted notation" do
-      subject.blah.another.should == subject[:blah].another
-    end
-
-    it "uses #key_as_a_hash to return key as a Hash" do
-      subject.blah_as_a_hash.should == { :another => 'value' }
-    end
-
-    describe "handling loops in the origin Hashes" do
-      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" }, :some_array => [ 1, 2, 3] }
-      end
-      let(:updated_hash) do
-        { :blah => { :blargh => "Janet" }, :some_array => [ 1, 2, 3] }
-      end
-
-      subject { RecursiveOpenStruct.new(hash) }
-
-      before(:each) { subject.blah.blargh = "Janet" }
-
-      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 original hash tree passed to the constructor" do
-        hash[:blah][:blargh].should == 'Brad'
-      end
-
-      it "limits the deep-copy to the initial hash tree" do
-        subject.some_array[0] = 4
-
-        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
-
-    context "when memoizing and then modifying entire recursive structures" do
-      subject do
-        RecursiveOpenStruct.new(
-          { :blah => original_blah }, :recurse_over_arrays => true)
-      end
-
-      before(:each) { subject.blah } # enforce memoization
-
-      context "when modifying an entire Hash" do
-        let(:original_blah) { { :a => 'A', :b => 'B' } }
-        let(:new_blah) { { :something_new => "C" } }
-
-        before(:each) { subject.blah = new_blah }
-
-        it "returns the modified value instead of the memoized one" do
-          subject.blah.something_new.should == "C"
-        end
-
-        specify "the old value no longer exists" do
-          subject.blah.a.should be_nil
-        end
-      end
-
-      context "when modifying an entire Array" do
-        let(:original_blah) { [1, 2, 3] }
-
-        it "returns the modified value instead of the memoized one" do
-          new_blah = [4, 5, 6]
-          subject.blah = new_blah
-          subject.blah.should == new_blah
-        end
-      end
-    end
-
-    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
-        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' }
-
-        context "when an inner value changes" do
-          let(:updated_blah_list) { [ { :foo => '1' }, { :foo => 'Dr Scott' }, 'baz' ] }
-          let(:updated_h) { { :blah => updated_blah_list } }
-
-          before(:each) { subject.blah[1].foo = "Dr Scott" }
-
-          it "Retains changes across Array lookups" do
-            subject.blah[1].foo.should == "Dr Scott"
-          end
-
-          it "propagates the changes through to .to_h across Array lookups" do
-            subject.to_h.should == {
-              :blah => [ { :foo => '1' }, { :foo => "Dr Scott" }, 'baz' ]
-            }
-          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
-
-          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
-          let(:deep_hash) { { :foo => { :blah => blah_list } } }
-          subject { RecursiveOpenStruct.new(deep_hash, :recurse_over_arrays => true) }
-
-          it { subject.foo.blah.length.should == 3 }
-          it "Retains changes across Array lookups" do
-            subject.foo.blah[1].foo = "Dr Scott"
-            subject.foo.blah[1].foo.should == "Dr Scott"
-          end
-
-        end
-
-        context "when array is in an array" do
-          let(:haah) { { :blah => [ blah_list ] } }
-          subject { RecursiveOpenStruct.new(haah, :recurse_over_arrays => true) }
-
-          it { subject.blah.length.should == 1 }
-          it { subject.blah[0].length.should == 3 }
-          it "Retains changes across Array lookups" do
-            subject.blah[0][1].foo = "Dr Scott"
-            subject.blah[0][1].foo.should == "Dr Scott"
-          end
-
-        end
-
-      end # when recursing over arrays is enabled
-
-      context "when recursing over arrays is disabled" do
-        subject { RecursiveOpenStruct.new(h) }
-
-        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
-  end # recursive behavior
-
-  describe "additionnel features" do
-
-    before(:each) do
-      h1 = { :a => 'a'}
-      h2 = { :a => 'b', :h1 => h1 }
-      h1[:h2] = h2
-      @ros = RecursiveOpenStruct.new(h2)
-    end
-
-    it "should have a simple way of display" do
-      @output = <<-QUOTE
-a = "b"
-h1.
-  a = "a"
-  h2.
-    a = "b"
-    h1.
-      a = "a"
-      h2.
-        a = "b"
-        h1.
-          a = "a"
-          h2.
-            a = "b"
-            h1.
-              a = "a"
-              h2.
-                a = "b"
-                h1.
-                  a = "a"
-                  h2.
-                    a = "b"
-                    h1.
-                      a = "a"
-                      h2.
-                        (recursion limit reached)
-QUOTE
-      @io = StringIO.new
-      @ros.debug_inspect(@io)
-      @io.string.should match /^a = "b"$/
-      @io.string.should match /^h1\.$/
-      @io.string.should match /^  a = "a"$/
-      @io.string.should match /^  h2\.$/
-      @io.string.should match /^    a = "b"$/
-      @io.string.should match /^    h1\.$/
-      @io.string.should match /^      a = "a"$/
-      @io.string.should match /^      h2\.$/
-      @io.string.should match /^        a = "b"$/
-      @io.string.should match /^        h1\.$/
-      @io.string.should match /^          a = "a"$/
-      @io.string.should match /^          h2\.$/
-      @io.string.should match /^            a = "b"$/
-      @io.string.should match /^            h1\.$/
-      @io.string.should match /^              a = "a"$/
-      @io.string.should match /^              h2\.$/
-      @io.string.should match /^                a = "b"$/
-      @io.string.should match /^                h1\.$/
-      @io.string.should match /^                  a = "a"$/
-      @io.string.should match /^                  h2\.$/
-      @io.string.should match /^                    a = "b"$/
-      @io.string.should match /^                    h1\.$/
-      @io.string.should match /^                      a = "a"$/
-      @io.string.should match /^                      h2\.$/
-      @io.string.should match /^                        \(recursion limit reached\)$/
-    end
-
-    it "creates nested objects via subclass" do
-      RecursiveOpenStructSubClass = Class.new(RecursiveOpenStruct)
-
-      rossc = RecursiveOpenStructSubClass.new({ :one => [{:two => :three}] }, recurse_over_arrays: true)
-
-      rossc.one.first.class.should == RecursiveOpenStructSubClass
-    end
-  end # additionnel features
-
-end # describe RecursiveOpenStruct