recursive-open-struct-sd 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5244992a3f5ff4094c1b2b2cb3daa2e9784e3e6f
+  data.tar.gz: 11d6e66b3fda35da43f246d86ad6b8f82ce38acc
+SHA512:
+  metadata.gz: e106b2c0a0b66e0c6789bd73b3c1aa82c5abf38f45aee8c0942f4f773edc4d87d1986b9c7db4d174c77d996c322422e3d758abc20bc36af2ae7a85a9f6a94cbe
+  data.tar.gz: 24d7faf9c8502bf0316d35abf1f31dd8a5d5571f72de98dc900d545e0dbfcb4fe6fde19f50471709c19d85f8e0e3534d63ef171edb707711ce7b79a2b87c24c6

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,50 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+.DS_Store
+
+# For TextMate
+*.tmproj
+tmtags
+
+# For emacs:
+*~
+\#*
+.\#*
+
+# For vim:
+*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc
+
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,13 @@
+---
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+  - 2.4.0
+  - ruby-head
+  - jruby-19mode
+  - jruby-9.0.5.0
+  - jruby-head
+sudo: false

data/AUTHORS.txt

@@ -0,0 +1,15 @@
+Recursive-open-struct was written by these fine people:
+
+* Cédric Felizard <cedric@felizard.fr>
+* Federico Aloi <federico.aloi@gmail.com>
+* fervic <roberto@runawaybit.com>
+* Kris Dekeyser <kris.dekeyser@libis.be>
+* Matt Culpepper <matt@culpepper.co>
+* Matthew O'Riordan <matthew.oriordan@gmail.com>
+* Offirmo <offirmo.net@gmail.com>
+* Peter Yeremenko <peter.yeremenko@gmail.com>
+* Sebastian Gaul <sebastian@mgvmedia.com>
+* Thiago Guimaraes <thiagogsr@gmail.com>
+* Tom Chapin <tchapin@gmail.com>
+* Victor Guzman <victor.guzman@runawaybit.com>
+* William (B.J.) Snow Orvis <aetherknight@gmail.com>

data/CHANGELOG.md

@@ -0,0 +1,151 @@
+1.0.1 / 2016-01-18
+==================
+
+* FIX [#42](https://github.com/aetherknight/recursive-open-struct/issues/42):
+  `[]` tried to call private methods if they existed instead of triggering the
+  `method_missing` code path. Thanks to @SaltwaterC for reporting.
+
+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
+==================
+
+* FIX: Fix ROS when initialized with nil instead of a hash.
+
+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
+==================
+
+* FIX: Thiago Guimaraes: Restore being able to create an ROS from a hash that
+  contains strings for keys instead of symbols for keys.
+
+0.6.2 / 2015-04-07
+==================
+
+* FIX: fervic: Address a bug in the Ruby 1.9's version of OpenStruct's `dup`
+* FIX: Victor Guzman: Reset memoized values on assignment in order to force the
+  implementation to re-memoize them.
+* MAINT: fervic: Simplified `initialize`
+
+0.6.1 / 2015-03-28
+==================
+
+* FIX: Actually ensure that the internal @table is properly dependent or
+  independent of the input hash tree. I mistakenly refactored away an important
+  piece of code that fervic added.
+* FIX: Actually ensure that `#dup` works.
+* Also refactored how `#to_h` is implemented to use newer plumbing.
+
+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/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2009-2016, The Recursive-open-struct developers (given in the
+file AUTHORS.txt).
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# recursive-open-struct-sd
+
+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' } } )
+
+    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.somearr[0].name # => 'a'
+    ros.somearr[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
+
+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
+
+## Contributing
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* 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 (c) 2009-2016, The Recursive-open-struct developers (given in the
+file AUTHORS.txt). See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+namespace :spec do
+  if RUBY_VERSION =~ /^1\.8/
+    desc "Rspec code coverage (1.8.7)"
+    RSpec::Core::RakeTask.new(:coverage) do |spec|
+      spec.pattern = 'spec/**/*_spec.rb'
+      spec.rcov = true
+    end
+  else
+    desc "Rspec code coverage (1.9+)"
+    task :coverage do
+      ENV['COVERAGE'] = 'true'
+      Rake::Task["spec"].execute
+    end
+  end
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "recursive-open-struct #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :spec
+
+task :fix_permissions do
+  File.umask 0022
+  filelist = `git ls-files`.split("\n")
+  FileUtils.chmod 0644, filelist, :verbose => true
+  FileUtils.chmod 0755, ['lib','spec'], :verbose => true
+end
+
+desc "Update the AUTHORS.txt file"
+task :update_authors do
+  authors = `git log --format="%aN <%aE>"|sort -f|uniq`
+  File.open('AUTHORS.txt', 'w') do |f|
+    f.write("Recursive-open-struct was written by these fine people:\n\n")
+    f.write(authors.split("\n").map { |a| "* #{a}" }.join( "\n" ))
+    f.write("\n")
+  end
+end
+
+task :build => [:update_authors, :fix_permissions]
+
+desc "Run an interactive pry shell with ros required"
+task :pry do
+  sh "pry -I lib -r recursive-open-struct"
+end

data/lib/recursive-open-struct.rb

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

data/lib/recursive_open_struct.rb

@@ -0,0 +1,130 @@
+require 'ostruct'
+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=nil, args={})
+    hash ||= {}
+    @recurse_over_arrays = args.fetch(:recurse_over_arrays, false)
+    @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)
+
+    @sub_elements = {}
+  end
+
+  def initialize_copy(orig)
+    super
+
+    # deep copy the table to separate the two objects
+    @table = @deep_dup.call(orig.instance_variable_get(:@table))
+    # Forget any memoized sub-elements
+    @sub_elements = {}
+  end
+
+  def to_h
+    @deep_dup.call(@table)
+  end
+
+  alias_method :to_hash, :to_h
+
+  def [](name)
+    public_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.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,
+              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)
+            @sub_elements[key_name] = recurse_over_array(@sub_elements[key_name])
+          else
+            v
+          end
+        end
+        define_method("#{name}=") do |x|
+          @sub_elements.delete(key_name)
+          modifiable[key_name] = x
+        end
+        define_method("#{name}_as_a_hash") { @table[key_name] }
+      end
+    end
+    key_name
+  end
+
+  def delete_field(name)
+    sym = _get_key_from_table_(name)
+    singleton_class.__send__(:remove_method, sym, "#{sym}=") rescue NoMethodError # ignore if methods not yet generated.
+    @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
+
+  def recurse_over_array(array)
+    array.each_with_index do |a, i|
+      if a.is_a? Hash
+        array[i] = self.class.new(a, :recurse_over_arrays => true, 
+          :mutate_input_hash => true, :preserve_original_keys => @preserve_original_keys)
+      elsif a.is_a? Array
+        array[i] = recurse_over_array a
+      end
+    end
+    array
+  end
+
+end