recursive-open-struct-sd 1.0.2

data/lib/recursive_open_struct/debug_inspect.rb

@@ -0,0 +1,38 @@
+module RecursiveOpenStruct::DebugInspect
+  def debug_inspect(io = STDOUT, indent_level = 0, recursion_limit = 12)
+    display_recursive_open_struct(io, @table, indent_level, recursion_limit)
+  end
+
+  def display_recursive_open_struct(io, ostrct_or_hash, indent_level, recursion_limit)
+
+    if recursion_limit <= 0 then
+      # protection against recursive structure (like in the tests)
+      io.puts '  '*indent_level + '(recursion limit reached)'
+    else
+      #puts ostrct_or_hash.inspect
+      if ostrct_or_hash.is_a?(self.class) then
+        ostrct_or_hash = ostrct_or_hash.marshal_dump
+      end
+
+      # We'll display the key values like this :    key =  value
+      # to align display, we look for the maximum key length of the data that will be displayed
+      # (everything except hashes)
+      data_indent = ostrct_or_hash \
+        .reject { |k, v| v.is_a?(self.class) || v.is_a?(Hash) } \
+        .max {|a,b| a[0].to_s.length <=> b[0].to_s.length}[0].to_s.length
+      # puts "max length = #{data_indent}"
+
+      ostrct_or_hash.each do |key, value|
+        if (value.is_a?(self.class) || value.is_a?(Hash)) then
+          io.puts '  '*indent_level + key.to_s + '.'
+          display_recursive_open_struct(io, value, indent_level + 1, recursion_limit - 1)
+        else
+          io.puts '  '*indent_level + key.to_s + ' '*(data_indent - key.to_s.length) + ' = ' + value.inspect
+        end
+      end
+    end
+
+    true
+  end
+
+end

data/lib/recursive_open_struct/deep_dup.rb

@@ -0,0 +1,32 @@
+class RecursiveOpenStruct::DeepDup
+  def initialize(opts={})
+    @recurse_over_arrays = opts.fetch(:recurse_over_arrays, false)
+    @preserve_original_keys = opts.fetch(:preserve_original_keys, false)
+  end
+
+  def call(obj)
+    deep_dup(obj)
+  end
+
+  private
+
+  def deep_dup(obj, visited=[])
+    if obj.is_a?(Hash)
+      obj.each_with_object({}) do |(key, value), h|
+        h[@preserve_original_keys ? key : key.to_sym] = value_or_deep_dup(value, visited)
+      end
+    elsif obj.is_a?(Array) && @recurse_over_arrays
+      obj.each_with_object([]) do |value, arr|
+        value = value.is_a?(RecursiveOpenStruct) ? value.to_h : value
+        arr << value_or_deep_dup(value, visited)
+      end
+    else
+      obj
+    end
+  end
+
+  def value_or_deep_dup(value, visited)
+    obj_id = value.object_id
+    visited.include?(obj_id) ? value : deep_dup(value, visited << obj_id)
+  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

@@ -0,0 +1,7 @@
+# Necessary since the top-level class/module is a class that inherits from
+# OpenStruct.
+require 'ostruct'
+
+class RecursiveOpenStruct < OpenStruct
+  VERSION = "1.0.2"
+end

data/recursive-open-struct-sd.gemspec

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require './lib/recursive_open_struct/version'
+
+Gem::Specification.new do |s|
+  s.name = "recursive-open-struct-sd"
+  s.version = RecursiveOpenStruct::VERSION
+  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.licenses = ["MIT"]
+
+  s.summary = "OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs"
+  s.description = <<-QUOTE .gsub(/^    /,'')
+    RecursiveOpenStruct is a subclass of OpenStruct. It differs from
+    OpenStruct in that it allows nested hashes to be treated in a recursive
+    fashion. For example:
+
+        ros = RecursiveOpenStruct.new({ :a => { :b => 'c' } })
+        ros.a.b # 'c'
+
+    Also, nested hashes can still be accessed as hashes:
+
+        ros.a_as_a_hash # { :b => 'c' }
+
+    > This is a fork of the original recursive-open-struct
+    > to include a fix for https://github.com/aetherknight/recursive-open-struct/issues/46
+    QUOTE
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files spec`.split("\n")
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = [
+    "CHANGELOG.md",
+    "LICENSE.txt",
+    "README.md"
+  ]
+
+  s.add_development_dependency('bundler', [">= 0"])
+  s.add_development_dependency('pry', [">= 0"])
+  s.add_development_dependency('rake', [">= 0"])
+  s.add_development_dependency('rdoc', [">= 0"])
+  s.add_development_dependency('rspec', "~> 3.2")
+  s.add_development_dependency('simplecov', [">= 0"])
+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,166 @@
+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} }
+    let(:hash_ros_opts) { {} }
+    subject(:hash_ros) { RecursiveOpenStruct.new(hash, hash_ros_opts) }
+
+    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 'when preserve_original_keys is not enabled' do
+        context 'transforms original keys to symbols' do
+          subject(:recursive) { RecursiveOpenStruct.new(recursive_hash, recurse_over_arrays: true) }
+          let(:recursive_hash) { {:foo => [ {'bar' => [ { 'foo' => :bar} ] } ] } }
+          let(:symbolized_recursive_hash) { {:foo => [ {:bar => [ { :foo => :bar} ] } ] } }
+          let(:symbolized_modified_hash) { {:foo => [ {:bar => [ { :foo => :foo} ] } ] } }
+          let(:symbolized_hash) { Hash[hash.map{|(k,v)| [k.to_sym,v]}] }
+
+          specify 'after initialization' do
+            expect(hash_ros.to_h).to eq symbolized_hash
+          end
+
+          specify 'in recursive hashes' do
+            expect(recursive.to_h).to eq symbolized_recursive_hash
+          end
+
+          specify 'after resetting value' do
+            recursive.foo.first[:bar].first[:foo] = :foo
+            expect(recursive.to_h).to eq symbolized_modified_hash
+          end
+        end
+      end
+
+      context 'when preserve_original_keys is enabled' do
+        context 'preserves the original keys' do
+          subject(:recursive) { RecursiveOpenStruct.new(recursive_hash, recurse_over_arrays: true, preserve_original_keys: true) }
+          let(:recursive_hash) { {:foo => [ {'bar' => [ { 'foo' => :bar} ] } ] } }
+          let(:modified_hash) { {:foo => [ {'bar' => [ { 'foo' => :foo} ] } ] } }
+
+          let(:hash_ros_opts) { { preserve_original_keys: true }}
+
+          specify 'after initialization' do
+            expect(hash_ros.to_h).to eq hash
+          end
+
+          specify 'in recursive hashes' do
+            expect(recursive.to_h).to eq recursive_hash
+          end
+
+          specify 'after resetting value' do
+            recursive.foo.first[:bar].first[:foo] = :foo
+            expect(recursive.to_h).to eq modified_hash
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/spec/recursive_open_struct/open_struct_behavior_spec.rb

@@ -0,0 +1,92 @@
+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
+
+      it 'returns nil for missing attributes' do
+        expect(ros.foo).to be_nil
+      end
+    end
+
+    context 'when initialized with nil' do
+      let(:hash) { nil }
+      it 'returns nil for missing attributes' do
+        expect(ros.foo).to be_nil
+      end
+    end
+
+    context 'when initialized with an empty hash' do
+      it 'returns nil for missing attributes' do
+        expect(ros.foo).to be_nil
+      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
+
+      context 'that contains keys that mirror existing private methods' do
+        let(:hash) { { test: :foo, rand: 'not a number' } }
+
+        # https://github.com/aetherknight/recursive-open-struct/issues/42
+        it 'handles subscript notation without calling the method name first (#42)' do
+          expect(ros['test']).to eq :foo
+          expect(ros['rand']).to eq 'not a number'
+
+          expect(ros.test).to eq :foo
+          expect(ros.rand).to eq 'not a number'
+        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