recursive-open-struct 0.6.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16edd384bbe19b6efc58d29e12740a3756f6e51a
-  data.tar.gz: 97ad4a2805226395ef2df02f61f5482b37bc047f
+  metadata.gz: 2d1f3fe927a4c1021ecddcde1416e8f6135043c0
+  data.tar.gz: e9ef12ce07604f331d0ccf2d807575c1a41f078b
 SHA512:
-  metadata.gz: 731c64834e1e18e6bcb2cd43fb112b6e87ebbabc6d63e31ce8cafaeb377e56f8601f2b9dcc4f02ecc2282f9a11c4176bb3dcd4f592e4126dad5ec6f9f4caf249
-  data.tar.gz: 173c905112efdc0d907af7de0730af75dd27fc733bd90a591bcb626048d5bb978c001d6e695b618db7204e214f17129ead2953c4fb573572da9ecd87ccd0280b
+  metadata.gz: f430a2b3b7a980715c81d850b93e41259b5a3abaffb8101bd04a96cc55ad599862a1405314886753d9122fd8f045e0b4517622a8d9125478148da891f2e312e4
+  data.tar.gz: 00ef1d3a89aa84d70499a3cc888e8a69f5f2cc921e8e07512b0290af4786c9d80b3a6a0029f6d79f7b65a2f10efa6438d2ae88d9792288c188be8c2da5b55052

data/.travis.yml

@@ -1,8 +1,12 @@
 ---
 language: ruby
 rvm:
-  - 1.9.3
   - 2.0.0
-  - 2.1.0
-  - 2.2
+  - 2.1.7
+  - 2.2.3
+  - 2.3.0
+  - ruby-head
   - jruby-19mode
+  - jruby-9.0.0.0
+  - jruby-head
+sudo: false

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+1.0.0 / 2015-12-11
+==================
+
+* API-Breaking Change: Frederico Aloi: Change `to_h` to always return symbol
+  keys. This is more consistent with OpenStruct.
+* API-Breaking Change: No longer officially supporting Ruby 1.9.3.
+* NEW/FIX: Kris Dekeyser: Ensure that ROS continues to work with the new
+  version of OpenStruct included in dev versions of Ruby 2.2.x and Ruby 2.3. It
+  now implements lazy attribute creation, which broke ROS.
+* NEW: Added `preserve_original_keys` option to revert to the 0.x behavior. Set
+  it to true if you want methods like `to_h` to return strings and perhaps
+  other non-symbols.
+* NEW: Ensuring support for Ruby 2.0.0+ including the upcoming 2.3 release and
+  JRuby 9000.
+* FIX: Peter Yeremenko: Fix a mistake in one of the examples in the README
+
 0.6.5 / 2015-06-30
 ==================
 

data/README.md

@@ -5,23 +5,34 @@ RecursiveOpenStructs.
 
 It allows for hashes within hashes to be called in a chain of methods:
 
-    ros = RecursiveOpenStruct.new( { :fooa => { :foob => 'fooc' } } )
+    ros = RecursiveOpenStruct.new( { fooa: { foob: 'fooc' } } )
 
     ros.fooa.foob # => 'fooc'
 
 Also, if needed, nested hashes can still be accessed as hashes:
 
-    ros.fooa_as_a_hash # { :foob => 'fooc' }
+    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' } ] }
+    h = { :somearr => [ { name: 'a'}, { name: 'b' } ] }
+    ros = RecursiveOpenStruct.new(h, recurse_over_arrays: true )
 
-    ros = RecursiveOpenStruct.new(h, :recurse_over_arrays => true )
+    ros.somearr[0].name # => 'a'
+    ros.somearr[1].name # => 'b'
 
-    ros.somarr[0].name # => 'a'
-    ros.somarr[1].name # => 'b'
+Also, by default it will turn all hash keys into symbols internally:
+
+    h = { 'fear' => 'is', 'the' => 'mindkiller' } }
+    ros = RecursiveOpenStruct.new(h)
+    ros.to_h # => { fear: 'is', the: 'mindkiller' }
+
+You can preserve the original keys by enabling `:preserve_original_keys`:
+
+    h = { 'fear' => 'is', 'the' => 'mindkiller' } }
+    ros = RecursiveOpenStruct.new(h, preserve_original_keys: true)
+    ros.to_h # => { 'fear' => 'is', 'the' => 'mindkiller' }
 
 ## Installation
 

data/lib/recursive_open_struct.rb

@@ -12,10 +12,13 @@ class RecursiveOpenStruct < OpenStruct
   def initialize(hash=nil, args={})
     hash ||= {}
     @recurse_over_arrays = args.fetch(:recurse_over_arrays, false)
-    @deep_dup = DeepDup.new(recurse_over_arrays: @recurse_over_arrays)
+    @preserve_original_keys = args.fetch(:preserve_original_keys, false)
+    @deep_dup = DeepDup.new(
+      recurse_over_arrays: @recurse_over_arrays,
+      preserve_original_keys: @preserve_original_keys
+    )
 
     @table = args.fetch(:mutate_input_hash, false) ? hash : @deep_dup.call(hash)
-    @table && @table.each_key { |k| new_ostruct_member(k) }
 
     @sub_elements = {}
   end
@@ -39,17 +42,46 @@ class RecursiveOpenStruct < OpenStruct
     send name
   end
 
+  # Makes sure ROS responds as expected on #respond_to? and #method requests
+  def respond_to_missing?(mid, include_private = false)
+    mname = _get_key_from_table_(mid.to_s.chomp('=').chomp('_as_a_hash'))
+    @table.key?(mname) || super
+  end
+
+  # Adapted implementation of method_missing to accomodate the differences between ROS and OS.
+  def method_missing(mid, *args)
+    len = args.length
+    if mid =~ /^(.*)=$/
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+      end
+      modifiable[new_ostruct_member($1.to_sym)] = args[0]
+    elsif len == 0
+      key = mid
+      key = $1 if key =~ /^(.*)_as_a_hash$/
+      if @table.key?(_get_key_from_table_(key))
+        new_ostruct_member(key)
+        send(mid)
+      end
+    else
+      err = NoMethodError.new "undefined method `#{mid}' for #{self}", mid, args
+      err.set_backtrace caller(1)
+      raise err
+    end
+  end
+
   def new_ostruct_member(name)
     key_name = _get_key_from_table_ name
-    unless self.respond_to?(name)
+    unless self.methods.include?(name.to_sym)
       class << self; self; end.class_eval do
         define_method(name) do
           v = @table[key_name]
           if v.is_a?(Hash)
             @sub_elements[key_name] ||= self.class.new(
               v,
-              :recurse_over_arrays => @recurse_over_arrays,
-              :mutate_input_hash => true
+              recurse_over_arrays: @recurse_over_arrays,
+              preserve_original_keys: @preserve_original_keys,
+              mutate_input_hash: true
             )
           elsif v.is_a?(Array) and @recurse_over_arrays
             @sub_elements[key_name] ||= recurse_over_array(v)
@@ -68,22 +100,9 @@ class RecursiveOpenStruct < OpenStruct
     key_name
   end
 
-  # 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, :mutate_input_hash => true)
-      elsif a.is_a? Array
-        recurse_over_array a
-      else
-        a
-      end
-    end
-  end
-
   def delete_field(name)
     sym = _get_key_from_table_(name)
-    singleton_class.__send__(:remove_method, sym, "#{sym}=")
+    singleton_class.__send__(:remove_method, sym, "#{sym}=") rescue NoMethodError # ignore if methods not yet generated.
     @sub_elements.delete sym
     @table.delete sym
   end
@@ -95,4 +114,17 @@ class RecursiveOpenStruct < OpenStruct
     return name.to_sym if @table.has_key?(name.to_sym)
     name
   end
+
+  def recurse_over_array(array)
+    array.map do |a|
+      if a.is_a? Hash
+        self.class.new(a, :recurse_over_arrays => true, :mutate_input_hash => true)
+      elsif a.is_a? Array
+        recurse_over_array a
+      else
+        a
+      end
+    end
+  end
+
 end

data/lib/recursive_open_struct/deep_dup.rb

@@ -1,6 +1,7 @@
 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)
@@ -12,7 +13,7 @@ class RecursiveOpenStruct::DeepDup
   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)
+        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|

data/lib/recursive_open_struct/version.rb

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

data/spec/recursive_open_struct/indifferent_access_spec.rb

@@ -9,9 +9,10 @@ describe RecursiveOpenStruct do
 
   describe 'indifferent access' do
     let(:hash) { {:foo => value, 'bar' => symbol} }
-    subject(:hash_ros) { RecursiveOpenStruct.new(hash) }
-    context 'setting value with method' do
+    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
@@ -23,7 +24,6 @@ describe RecursiveOpenStruct do
     end
 
     context 'setting value with symbol' do
-
       before(:each) do
         subject[:foo] = value
       end
@@ -35,7 +35,6 @@ describe RecursiveOpenStruct do
     end
 
     context 'setting value with string' do
-
       before(:each) do
         subject['foo'] = value
       end
@@ -47,9 +46,7 @@ describe RecursiveOpenStruct do
     end
 
     context 'overwriting values' do
-
       context 'set with method' do
-
         before(:each) do
           subject.foo = value
         end
@@ -63,11 +60,9 @@ describe RecursiveOpenStruct 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
@@ -81,11 +76,9 @@ describe RecursiveOpenStruct 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
@@ -99,11 +92,9 @@ describe RecursiveOpenStruct 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
@@ -121,27 +112,52 @@ describe RecursiveOpenStruct 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 '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} ] } ] } }
+      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} ] } ] } }
 
-        it 'after initialization' do
-          expect(hash_ros.to_h).to eq hash
-        end
+          let(:hash_ros_opts) { { preserve_original_keys: true }}
 
-        it 'in recursive hashes' do
-          expect(recursive.to_h).to eq recursive_hash
-        end
+          specify 'after initialization' do
+            expect(hash_ros.to_h).to eq hash
+          end
 
-        it 'after resetting value' do
-          recursive.foo.first[:bar].first[:foo] = :foo
-          expect(recursive.to_h).to eq modified_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

data/spec/recursive_open_struct/ostruct_2_0_0_spec.rb

@@ -95,8 +95,8 @@ describe RecursiveOpenStruct do
     end
 
     context "each_pair" do
-      it "iterates over hash keys" do
-        expect(ros.each_pair).to match hash.each_pair
+      it "iterates over hash keys, with keys as symbol" do
+        expect(ros.each_pair).to match ({:foo => 'foo', :bar => :bar}.each_pair)
       end
     end
 

metadata

@@ -1,97 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 1.0.0
 platform: ruby
 authors:
 - William (B.J.) Snow Orvis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-01 00:00:00.000000000 Z
+date: 2015-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: |
@@ -113,10 +113,10 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- .document
-- .gitignore
-- .rspec
-- .travis.yml
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -146,17 +146,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs