recursive-open-struct 0.2.1 → 0.3.1

data/Gemfile

@@ -10,5 +10,6 @@ group :development do
   gem 'rspec'    #, "~> 2.3.0"
   gem 'bundler'  #, "~> 1.0.0"
   gem 'jeweler'  #, "~> 1.6.0"
-  gem 'rcov'     #, ">= 0"
+  gem 'rcov' if RUBY_VERSION =~ /^1\.8/
+  gem 'rdoc'
 end

data/Gemfile.lock

@@ -1,22 +1,25 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.2)
+    diff-lcs (1.1.3)
     git (1.2.5)
-    jeweler (1.6.0)
-      bundler (~> 1.0.0)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    rake (0.9.0)
-    rcov (0.9.9)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.2)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
+      rdoc
+    json (1.7.5)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
 
 PLATFORMS
   ruby
@@ -24,5 +27,5 @@ PLATFORMS
 DEPENDENCIES
   bundler
   jeweler
-  rcov
+  rdoc
   rspec

data/README.rdoc

@@ -1,27 +1,39 @@
 = recursive-open-struct
 
-RecursiveOpenStruct is a extension of OpenStruct.
-It enhance OpenStruct in that it allows nested hashes to be treated in a recursive
-fashion. For example:
+OpenStruct subclass that returns nested hash attributes as
+RecursiveOpenStructs.
+
+It allows for hashes within hashes to be called in a chain of methods:
+
   ros = RecursiveOpenStruct.new( { :fooa => { :foob => 'fooc' } } )
-can now be accessed this way :
-  ros.fooa.foob # 'fooc'
 
-Also, if needed, nested hashes can still be accessed as hashes :
+  ros.fooa.foob # => 'fooc'
+
+Also, if needed, nested hashes can still be accessed as hashes:
 
   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' } ] }
+
+  ros = RecursiveOpenStruct.new(h, :recurse_over_arrays => true )
+
+  ros.somarr[0].name # => 'a'
+  ros.somarr[1].name # => 'b'
+
 == Installation
 
 Available as a gem in rubygems, the default gem repository.
 
 If you use bundler, just throw that in your gemfile :
+
   gem 'recursive-open-struct'
 
 You may also install the gem manually :
-  gem install recursive-open-struct
 
-Isn't that easy ? (Special thanks to the jeweler tool)
+  gem install recursive-open-struct
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -49,7 +49,7 @@ end
 
 task :default => :spec
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.1

data/lib/recursive-open-struct.rb

@@ -0,0 +1 @@
+require 'recursive_open_struct'

data/lib/recursive_open_struct.rb

@@ -1,55 +1,66 @@
 require 'ostruct'
 
 class RecursiveOpenStruct < OpenStruct
-  
+
+  def initialize(h=nil, args={})
+    @recurse_over_arrays = args.fetch(:recurse_over_arrays,false)
+    super(h)
+  end
+
   def new_ostruct_member(name)
     name = name.to_sym
     unless self.respond_to?(name)
       class << self; self; end.class_eval do
-        define_method(name) {
+        define_method(name) do
           v = @table[name]
-          v.is_a?(Hash) ? RecursiveOpenStruct.new(v) : v
-        }
+          if v.is_a?(Hash)
+            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 }
+          else
+            v
+          end
+        end
         define_method("#{name}=") { |x| modifiable[name] = x }
         define_method("#{name}_as_a_hash") { @table[name] }
       end
     end
     name
   end
-  
-  def debug_inspect(indent_level = 0, recursion_limit = 12)
-    display_recursive_open_struct(@table, indent_level, recursion_limit)
+
+  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(ostrct_or_hash, indent_level, recursion_limit)
-    
+
+  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)
-      puts '  '*indent_level + '(recursion limit reached)'
+      io.puts '  '*indent_level + '(recursion limit reached)'
     else
       #puts ostrct_or_hash.inspect
       if ostrct_or_hash.is_a?(RecursiveOpenStruct) 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?(RecursiveOpenStruct) || v.is_a?(Hash) }
-          .max {|a,b| a[0].to_s.length <=> b[0].to_s.length}[0].length
+      data_indent = ostrct_or_hash \
+        .reject { |k, v| v.is_a?(RecursiveOpenStruct) || 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?(RecursiveOpenStruct) || value.is_a?(Hash)) then
-          puts '  '*indent_level + key.to_s + '.'
-          display_recursive_open_struct(value, indent_level + 1, recursion_limit - 1)
+          io.puts '  '*indent_level + key.to_s + '.'
+          display_recursive_open_struct(io, value, indent_level + 1, recursion_limit - 1)
         else
-          puts '  '*indent_level + key.to_s + ' '*(data_indent - key.to_s.length) + ' = ' + value.inspect
+          io.puts '  '*indent_level + key.to_s + ' '*(data_indent - key.to_s.length) + ' = ' + value.inspect
         end
       end
     end
-    
+
     true
   end
 

data/recursive-open-struct.gemspec

@@ -4,24 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{recursive-open-struct}
-  s.version = "0.2.1"
+  s.name = "recursive-open-struct"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{William (B.J.) Snow Orvis}]
-  s.date = %q{2011-05-31}
-  s.description = %q{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' }
-}
-  s.email = %q{aetherknight@gmail.com}
+  s.authors = ["William (B.J.) Snow Orvis"]
+  s.date = "2013-01-05"
+  s.description = "RecursiveOpenStruct is a subclass of OpenStruct. It differs from\nOpenStruct in that it allows nested hashes to be treated in a recursive\nfashion. For example:\n\n    ros = RecursiveOpenStruct.new({ :a => { :b => 'c' } })\n    ros.a.b # 'c'\n\nAlso, nested hashes can still be accessed as hashes:\n\n    ros.a_as_a_hash # { :b => 'c' }\n"
+  s.email = "aetherknight@gmail.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.rdoc"
@@ -35,16 +25,17 @@ Also, nested hashes can still be accessed as hashes:
     "README.rdoc",
     "Rakefile",
     "VERSION",
+    "lib/recursive-open-struct.rb",
     "lib/recursive_open_struct.rb",
     "recursive-open-struct.gemspec",
     "spec/recursive_open_struct_spec.rb",
     "spec/spec_helper.rb"
   ]
-  s.homepage = %q{http://github.com/aetherknight/recursive-open-struct}
-  s.licenses = [%q{MIT}]
-  s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.3}
-  s.summary = %q{OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs}
+  s.homepage = "http://github.com/aetherknight/recursive-open-struct"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
@@ -53,18 +44,18 @@ Also, nested hashes can still be accessed as hashes:
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<bundler>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
     else
       s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<bundler>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
     end
   else
     s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<bundler>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
   end
 end
 

data/spec/recursive_open_struct_spec.rb

@@ -2,46 +2,46 @@ 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
-    
+
     it "can be created from a hash" do
       h = { :asdf => 'John Smith' }
       ros = RecursiveOpenStruct.new(h)
       ros.asdf.should == "John Smith"
     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
       before(:each) do
         @ros = RecursiveOpenStruct.new
         @ros.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= }
       end # describe #respond?
-      
+
       describe "#methods" do
-        it { @ros.methods.should include :blah }
-        it { @ros.methods.should include :blah= }
-        it { @ros.methods.should_not include :asdf }
-        it { @ros.methods.should_not include :asdf= }
+        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= }
       end # describe #methods
     end # describe handling of arbitrary attributes
   end # describe behavior it inherits from OpenStruct
@@ -51,15 +51,15 @@ describe RecursiveOpenStruct do
       h = { :blah => { :another => 'value' } }
       @ros = RecursiveOpenStruct.new(h)
     end
-    
+
     it "returns accessed hashes as RecursiveOpenStructs instead of hashes" do
       @ros.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' }
     end
-    
+
     describe "handling loops in the origin Hashes" do
       before(:each) do
         h1 = { :a => 'a'}
@@ -67,7 +67,7 @@ describe RecursiveOpenStruct do
         h1[:h2] = h2
         @ros = RecursiveOpenStruct.new(h2)
       end
-      
+
       it { @ros.h1.a.should == 'a' }
       it { @ros.h1.h2.a.should == 'b' }
       it { @ros.h1.h2.h1.a.should == 'a' }
@@ -75,20 +75,101 @@ describe RecursiveOpenStruct do
       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)
+        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
+
+        it { @ros.blah.length.should == 3 }
+        it { @ros.blah[0].should == { :foo => '1' } }
+        it { @ros.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
-      @ros.debug_inspect
+      @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
   end # additionnel features
-  
+
 end # describe RecursiveOpenStruct

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-05-31 00:00:00.000000000Z
+date: 2013-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &73346940 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *73346940
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &73346640 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *73346640
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &73346350 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *73346350
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rcov
-  requirement: &73346110 !ruby/object:Gem::Requirement
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +69,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *73346110
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! "RecursiveOpenStruct is a subclass of OpenStruct. It differs from\nOpenStruct
   in that it allows nested hashes to be treated in a recursive\nfashion. For example:\n\n
   \   ros = RecursiveOpenStruct.new({ :a => { :b => 'c' } })\n    ros.a.b # 'c'\n\nAlso,
@@ -75,6 +95,7 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- lib/recursive-open-struct.rb
 - lib/recursive_open_struct.rb
 - recursive-open-struct.gemspec
 - spec/recursive_open_struct_spec.rb
@@ -94,7 +115,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 764807215
+      hash: -2043007964418436897
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -103,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.3
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs