recursive-open-struct 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4442ce9b9b12e7e7b187a2df666cf8018c97a30d
-  data.tar.gz: d869866022cbc4e3bc5f7ade8b2ed424010b0823
+  metadata.gz: 72ff48c134d3b90f56c0c2808e55f107c8bdd302
+  data.tar.gz: 3acf497ceb23b7b86de443dc3b4a83ddffa143eb
 SHA512:
-  metadata.gz: 217c2af046ca66b67c2f35d513dcd05dd4e00255ec73a67f66b80acf8403c62919728cab7c255f0435cd1e7264c2e53cb57a1be1b79eacc4bb85fe0b91ca27d5
-  data.tar.gz: f6a6aa2438f32e8f3d4021ddecd1547915702e00599475dff6e6ce6bfb23f9191f4f2400057531abfb455a0e6b1710cc184fc2884c21e9afcacca931bd13dc40
+  metadata.gz: 0279ca781f0607ae71c16d21589644a7b6151605f7f8cd74b47129ff2aad4c99536893375215aa9308342db54ba117ce271346bbc9c6a589c10e0f5bb105c9d1
+  data.tar.gz: be2d8df65e43686494858e8ab4cbec822336bcd5f68d0f87445fd968afd4ea08770e766192c489d900ae7d6b7233b9a17308da0089c7f6aa821b45e967f29a4c

data/.travis.yml

@@ -4,4 +4,5 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.2
   - jruby-19mode

data/CHANGELOG.md

@@ -0,0 +1,92 @@
+0.6.0 / 2015-03-28
+==================
+
+* NEW: fervic: Make subscript notation be recursive like dot-method notation
+* NEW: fervic: Added a new option, `:mutate_input_hash`, that allows the caller
+  to determine whether the original hash is mutated or not when a nested value
+  in the ROS tree is modified. If false (the default), the ROS will not modify
+  the original hash tree. If tree, changes within the ROS tree will also be
+  reflected in the hash tree.
+* FIX: fervic: Setting/updating a value nested deep in an ROS tree is kept
+  when the top-level ROS object is duped.
+* MAINT: Extracted `#deep_dup` added by fervic into its own class. This makes it
+  possibly easier to use/copy for others, and it cleans up the main class file.
+* MAINT: Moved `#debug_inspect` out to its own module. This cleans up the main
+  class file a bit. It is also something I may remove if I ever have a major
+  version bump.
+* MAINT: Adding MRI 2.2 to Travis-CI
+
+0.5.0 / 2014-06-14
+==================
+
+* NEW: Tom Chapin: Added a `#to_hash` alias for `#to_h`
+* MAINT: Added Travis-CI support. Testing against MRI 1.9.3, MRI 2.0, MRI 2.1,
+  and JRuby in 1.9 mode. Not aiming to support 1.8.7 since it has been nearly a
+  year since it has officially been retired.
+
+0.4.5 / 2013-10-23
+==================
+
+* FIX: Matt Culpepper: Allow ROS subclasses to use their own type when creating
+  nested objects in the tree.
+
+0.4.4 / 2013-08-28
+==================
+
+* FIX: Ensure proper file permissions when building the gem archive
+
+0.4.3 / 2013-05-30
+==================
+
+* FIX: Sebastian Gaul: Make `recurse_over_arrays` option work on more
+  deeply-nested hashes.
+
+0.4.2 / 2013-05-29
+==================
+
+* FIX: Setting a value on a nested element, then getting that value should show
+  the updated value
+* FIX: Calling `#to_h` on the top-level ROS object also reflects changed nested
+  elements.
+
+0.4.1 / 2013-05-28
+==================
+
+* FIX: Fixing the `spec:coverage` Rake task
+
+0.4.0 / 2013-05-26
+==================
+
+* NEW: Added `#to_h`
+* MAINT: Stopped using jeweler for gem development/packaging
+
+0.3.1 / 2012-10-23
+==================
+
+* FIX: Cédric Felizard: Fix to make it work with MRI 1.8.7 again
+* MAINT: More spec fixups to improve spec runs on MRI 1.9.3
+
+0.3.0 / 2013-10-23
+==================
+
+* NEW: Matthew O'Riordan: Add support for recursion working over Arrays
+* NEW: Made recursion over Arrays optional with `recurse_over_arrays` option.
+* NEW: Improving `#debug_inspect` so that it can use any IO object, not just
+  STDOUT.
+* MAINT: Much cleanup of development dependencies, README file, etc.
+
+0.2.1 / 2011-05-31
+==================
+
+* FIX: Offirmo: Slight improvement for `#debug_inspect`
+
+0.2.0 / 2011-05-25
+==================
+
+* NEW: Offirmo: Added `debug_inspect`
+* MAINT: Offirmo: Worked the development files so that it can be built as a gem
+
+0.1.0 / 2010-01-12
+==================
+
+* Initial release

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2009 William (B.J.) Snow Orvis
+Copyright (c) 2009-2015 William (B.J.) Snow Orvis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.rdoc → README.md}

@@ -1,4 +1,4 @@
-= recursive-open-struct
+# recursive-open-struct
 
 OpenStruct subclass that returns nested hash attributes as
 RecursiveOpenStructs.
@@ -23,7 +23,7 @@ have to explicitly enable it:
   ros.somarr[0].name # => 'a'
   ros.somarr[1].name # => 'b'
 
-== Installation
+## Installation
 
 Available as a gem in rubygems, the default gem repository.
 
@@ -35,16 +35,14 @@ You may also install the gem manually :
 
   gem install recursive-open-struct
 
-== Note on Patches/Pull Requests
+## Contributing
  
 * Fork the project.
 * Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Add tests for your new or changed functionality. Make sure the tests you add
+  provide clean and clear explanation of the feature.
 * Send me a pull request. Bonus points for topic branches.
 
-== Copyright
+## Copyright
 
-Copyright (c) 2010 William (B.J.) Snow Orvis. See LICENSE for details.
+Copyright (c) 2009-2015 William (B.J.) Snow Orvis. See LICENSE for details.

data/lib/recursive_open_struct.rb

@@ -1,11 +1,22 @@
 require 'ostruct'
+require 'recursive_open_struct/version'
+
+require 'recursive_open_struct/debug_inspect'
+require 'recursive_open_struct/deep_dup'
 
 class RecursiveOpenStruct < OpenStruct
-  VERSION = "0.5.0"
+  include DebugInspect
+
+  def initialize(hash=nil, args={})
+    @recurse_over_arrays = args.fetch(:recurse_over_arrays, false)
+    mutate_input_hash = args.fetch(:mutate_input_hash, false)
+
+    unless mutate_input_hash
+      hash = DeepDup.new(recurse_over_arrays: @recurse_over_arrays).call(hash)
+    end
+
+    super(hash)
 
-  def initialize(h=nil, args={})
-    @recurse_over_arrays = args.fetch(:recurse_over_arrays,false)
-    super(h)
     @sub_elements = {}
   end
 
@@ -23,6 +34,10 @@ class RecursiveOpenStruct < OpenStruct
 
   alias_method :to_hash, :to_h
 
+  def [](name)
+    send name
+  end
+
   def new_ostruct_member(name)
     name = name.to_sym
     unless self.respond_to?(name)
@@ -30,9 +45,11 @@ class RecursiveOpenStruct < OpenStruct
         define_method(name) do
           v = @table[name]
           if v.is_a?(Hash)
-            @sub_elements[name] ||= self.class.new(v, :recurse_over_arrays => @recurse_over_arrays)
+            @sub_elements[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[name] ||= recurse_over_array(v)
           else
             v
           end
@@ -44,10 +61,11 @@ class RecursiveOpenStruct < OpenStruct
     name
   end
 
-  def recurse_over_array array
+  # TODO: Make me private if/when we do an API-breaking change release
+  def recurse_over_array(array)
     array.map do |a|
       if a.is_a? Hash
-        self.class.new(a, :recurse_over_arrays => true)
+        self.class.new(a, :recurse_over_arrays => true, :mutate_input_hash => true)
       elsif a.is_a? Array
         recurse_over_array a
       else
@@ -55,41 +73,5 @@ class RecursiveOpenStruct < OpenStruct
       end
     end
   end
-
-  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/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,30 @@
+class RecursiveOpenStruct::DeepDup
+  def initialize(opts={})
+    @recurse_over_arrays = opts.fetch(:recurse_over_arrays, 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[key] = value_or_deep_dup(value, visited)
+      end
+    elsif obj.is_a?(Array) && @recurse_over_arrays
+      obj.each_with_object([]) do |value, arr|
+        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/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 = "0.6.0"
+end

data/recursive-open-struct.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-require './lib/recursive_open_struct'
+require './lib/recursive_open_struct/version'
 
 Gem::Specification.new do |s|
   s.name = "recursive-open-struct"
@@ -29,11 +29,12 @@ Gem::Specification.new do |s|
   s.test_files = `git ls-files spec`.split("\n")
   s.require_paths = ["lib"]
   s.extra_rdoc_files = [
+    "CHANGELOG.md",
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
 
-  s.add_development_dependency(%q<rspec>, [">= 0"])
+  s.add_development_dependency('rspec', "~> 3.2")
   s.add_development_dependency(%q<bundler>, [">= 0"])
   s.add_development_dependency(%q<rdoc>, [">= 0"])
   s.add_development_dependency(%q<rake>, [">= 0"])

data/spec/recursive_open_struct_spec.rb

@@ -64,6 +64,10 @@ describe RecursiveOpenStruct 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
@@ -96,19 +100,30 @@ describe RecursiveOpenStruct do
 
     context "after a sub-element has been modified" do
       let(:hash) do
-        {
-          :blah => {
-            :blargh => 'Brad'
-          }
-        }
+        { :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" }
-      it "returns a hash that contains those modifications" do
-        subject.to_h.should == { :blah => { :blargh => "Janet" } }
+
+      it "returns a hash tree that contains those modifications" do
+        subject.to_h.should == updated_hash
+      end
+
+      it "does not mutate the input hash tree passed to the constructor" do
+        hash[:blah][:blargh].should == 'Brad'
       end
-    end
 
+      it "limits the deep-copy to the initial hash tree" do
+        subject.some_array[0] = 4
+
+        hash[:some_array][0].should == 4
+      end
+    end
 
     describe 'recursing over arrays' do
       let(:blah_list) { [ { :foo => '1' }, { :foo => '2' }, 'baz' ] }
@@ -122,15 +137,30 @@ describe RecursiveOpenStruct do
         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' ]
-          }
+
+        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 "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
         end
 
         context "when array is nested deeper" do

data/spec/spec_helper.rb

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

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - William (B.J.) Snow Orvis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-14 00:00:00.000000000 Z
+date: 2015-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -81,19 +81,24 @@ email: aetherknight@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
+- CHANGELOG.md
 - LICENSE.txt
-- README.rdoc
+- README.md
 files:
 - .document
 - .gitignore
 - .rspec
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - lib/recursive-open-struct.rb
 - lib/recursive_open_struct.rb
+- lib/recursive_open_struct/debug_inspect.rb
+- lib/recursive_open_struct/deep_dup.rb
+- lib/recursive_open_struct/version.rb
 - recursive-open-struct.gemspec
 - spec/recursive_open_struct_spec.rb
 - spec/spec_helper.rb