recursive-open-struct 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 603694b270a6d4511c7154607cdb8d8c481f9c8b
-  data.tar.gz: 6c8f56108aefab75a7a1d3baeeb4a5963db1356d
+SHA256:
+  metadata.gz: aef116134efc7102292ad51046c306be7e93621f688e02255996ca218ed578b1
+  data.tar.gz: 722c1e817dbdd25d4a48deb5923ce6f83de55211dd86c00a5c292f91e86bc74b
 SHA512:
-  metadata.gz: 8949632d753c57bfe7d5c191673346c1275d7805dbccf20a3ef52f03bd832b86d7755324b9b28728a9fddde09e004f20b13580693ce0e3dfaf4ef5cf239c5da4
-  data.tar.gz: 82f5fa6407b595972a9016995087d280b8136db3a9a64bc85b335dd316d52016e94b04b5db84682896ec8ad0f7994c63d02331a811abb710eb1de398c23749d6
+  metadata.gz: fde1398adbd2795f9f108859d1d6c963a89048275be0fbf5e5cb1f92abb404ed8a55d4e97a8e2ba0d6367d3a255ecfdfe3dcfacc74d1b9bdd0d0c4e035acbe09
+  data.tar.gz: 82d16703403627ea358097b26d47334a984107c68a9c5360ac617169c4b9602292a7d7df77a96971ac3369fcca11256457518a61ce9895b7fcf9b58ab924c50b

data/.travis.yml

@@ -1,15 +1,21 @@
 ---
 language: ruby
 rvm:
+  # No longer supported
   # - 1.9.3  # json gem now requires Ruby ~> 2.0
   - 2.0.0
   - 2.1.10
-  - 2.2.9
-  - 2.3.6
-  - 2.4.3
-  - ruby-head
+  - 2.2.10
   - jruby-19mode
+  # Current stable supported by Travis
+  - 2.3.8
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - 2.7.0
   - jruby-9.1.9.0
+  # Future
+  - ruby-head
   - jruby-head
 sudo: false
 matrix:
@@ -17,6 +23,8 @@ matrix:
     # No longer supported
     - rvm: 2.0.0
     - rvm: 2.1.10
+    - rvm: 2.2.10
+    - rvm: 2.3.8
     - rvm: jruby-19mode
     # Future
     - rvm: ruby-head

data/AUTHORS.txt

@@ -1,8 +1,10 @@
 Recursive-open-struct was written by these fine people:
 
+* Ben Langfeld <ben@langfeld.me>
 * Beni Cherniavsky-Paskin <cben@redhat.com>
 * Cédric Felizard <cedric@felizard.fr>
 * Edward Betts <edward@4angle.com>
+* Ewoud Kohl van Wijngaarden <ewoud@kohlvanwijngaarden.nl>
 * Federico Aloi <federico.aloi@gmail.com>
 * fervic <roberto@runawaybit.com>
 * Joe Rafaniello <jrafanie@redhat.com>
@@ -12,6 +14,7 @@ Recursive-open-struct was written by these fine people:
 * Offirmo <offirmo.net@gmail.com>
 * Pedro Sena <sena.pedro@gmail.com>
 * Peter Yeremenko <peter.yeremenko@gmail.com>
+* Pirate Praveen <praveen@debian.org>
 * Sebastian Gaul <sebastian@mgvmedia.com>
 * Thiago Guimaraes <thiagogsr@gmail.com>
 * Tom Chapin <tchapin@gmail.com>

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+1.1.1 / 2020/03/10
+==================
+
+* FIX [#64](https://github.com/aetherknight/recursive-open-struct/pull/64):
+  Pirate Praveen: Support Ruby 2.7.0. `OpenStruct#modifiable` support was
+  finally dropped, and has to be replaced with `OpenStruct#modifiable?`.
+* Made some additional changes to continue supporting pre-2.4.x Rubies,
+  including the current stable JRuby (9.1.x.x, which tracks Ruby 2.3.x for
+  features)
+
 1.1.0 / 2018-02-03
 ==================
 

data/CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# Contributing to recursive-open-struct
+
+Thanks for wanting to contribute a bug or code to recursive-open-struct!
+
+To help you out with understanding the direction and philosophy of this project
+with regards to to new features/how it should behave (and whether to file a bug
+report), please review the following contribution guidelines.
+
+## ROS Feature Philosophy
+
+Recursive-open-struct tries to be a minimal extension to the Ruby stdlib's
+`ostruct`/OpenStruct that allows for a nested set of Hashes (and Arrays) to
+initialize similarly structured OpenStruct-like objects. This has the benefit
+of creating arbitrary objects whose values can be accessed with accessor
+methods, similar to JavaScript Objects' dot-notation.
+
+To phrase it another way, RecursiveOpenStruct tries to behave as closely as
+possible to OpenStruct, except for the recursive functionality that it adds.
+
+If Recursive-open-struct were to add additional features (particularly methods)
+that are not implemented by OpenStruct, then those method names would not be
+available for use for accessing fields with the dot-notation that OpenStruct
+and RecursiveOpenStruct provide.
+
+For example, OpenStruct is not (at the time this is written) a
+subclass/specialization of Hash, so several methods implemented by Hash do not
+work with OpenStruct (and thus Recursive OpenStruct), such as `#fetch`.
+
+If you want to add features into RecursiveOpenStruct that would "pollute" the
+method namespace more than OpenStruct already does, consider creating your own
+subclass instead of submitting a code change to RecursiveOpenStruct itself.
+
+
+## Filing/Fixing Bugs and Requesting/Proposing New Features
+
+For simple bug fixes, feel free to provide a pull request. This includes bugs
+in stated features of RecursiveOpenStruct, as well as features added to
+OpenStruct in a newer version of Ruby that RecursiveOpenStruct needs custom
+support to handle.
+
+For anything else (new features, bugs that you want to report, and bugs that
+are difficult to fix), I recommend opening an issue first to discuss the
+feature or bug. I am fairly cautious about adding new features that might cause
+RecursiveOpenStruct's API to deviate radically from OpenStruct's (since it
+might introduce new reserved method names), and it is useful to discuss the
+best way to solve a problem when there are tradeoffs or imperfect solutions.
+
+When contributing code that changes behavior or fixes bugs, please include unit
+tests to cover the new behavior or to provide regression testing for bugs.
+Also, treat the unit tests as documentation --- make sure they are clean,
+clear, and concise, and well organized.

data/README.md

@@ -3,64 +3,107 @@
 OpenStruct subclass that returns nested hash attributes as
 RecursiveOpenStructs.
 
+
+## Usage
+
 It allows for hashes within hashes to be called in a chain of methods:
 
-    ros = RecursiveOpenStruct.new( { fooa: { foob: 'fooc' } } )
+```ruby
+ros = RecursiveOpenStruct.new( { wha: { tagoo: 'siam' } } )
 
-    ros.fooa.foob # => 'fooc'
+ros.wha.tagoo # => 'siam'
+```
 
 Also, if needed, nested hashes can still be accessed as hashes:
 
-    ros.fooa_as_a_hash # { foob: 'fooc' }
+```ruby
+ros.wha_as_a_hash # { tagoo: 'siam' }
+```
+
+
+### Optional: Recurse Over Arrays
 
 RecursiveOpenStruct can also optionally recurse across arrays, although you
-have to explicitly enable it:
+have to explicitly enable it.
+
+Default behavior:
+```ruby
+h = { :somearr => [ { name: 'a'}, { name: 'b' } ] }
+
+ros = RecursiveOpenStruct.new(h)
+ros.somearr # => [ { name: 'a'}, { name: 'b' } ]
+```
+
+Enabling `recurse_over_arrays`:
+
+```ruby
+ros = RecursiveOpenStruct.new(h, recurse_over_arrays: true )
+
+ros.somearr[0].name # => 'a'
+ros.somearr[1].name # => 'b'
+```
 
-    h = { :somearr => [ { name: 'a'}, { name: 'b' } ] }
-    ros = RecursiveOpenStruct.new(h, recurse_over_arrays: true )
 
-    ros.somearr[0].name # => 'a'
-    ros.somearr[1].name # => 'b'
+### Optional: Preserve Original Keys
 
 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' }
+```ruby
+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' }
+```ruby
+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 :
+If you use bundler, just add recursive-open-struct to your gemfile :
 
-    gem 'recursive-open-struct'
+```ruby
+gem 'recursive-open-struct'
+```
 
-You may also install the gem manually :
+You may also install the gem manually:
 
     gem install recursive-open-struct
 
+
 ## Contributing
 
-For simple bug fixes, feel free to provide a pull request.
+If you would like to file or fix a bug, or propose a new feature, please review
+[CONTRIBUTING](CONTRIBUTING.md) first.
+
+
+## Supported Ruby Versions
+
+Recursive-open-struct attempts to support just the versions of Ruby that are
+still actively maintained. Once a given major/minor version of Ruby no longer
+receives patches, they will no longer be supported (but recursive-open-struct
+may still work). I usually update the travis.yml file to reflect this when
+preparing for a new release or do some other work on recursive-open-struct.
+
+I also try to update recursive-open-struct to support new features in
+OpenStruct itself as new versions of Ruby are released. However, I don't
+actively monitor the status of this, so a newer feature might not work. If you
+encounter such a feature, please file a bug or a PR to fix it, and I will try
+to cut a new release of recursive-open-struct quickly.
+
+
+## SemVer Compliance
 
-For anything else (new features, bugs that you want to report, and bugs that
-are difficult to fix), I recommend opening an issue first to discuss the
-feature or bug. I am fairly cautious about adding new features that might cause
-RecursiveOpenStruct's API to deviate radically from OpenStruct's (since it
-might introduce new reserved method names), and it is useful to discuss the
-best way to solve a problem when there are tradeoffs or imperfect solutions.
+Rescursive-open-struct follows [SemVer
+2.0](https://semver.org/spec/v2.0.0.html) for its versioning.
 
-When contributing code that changes behavior or fixes bugs, please include unit
-tests to cover the new behavior or to provide regression testing for bugs.
-Also, treat the unit tests as documentation --- make sure they are clean,
-clear, and concise, and well organized.
 
 ## Copyright
 

data/lib/recursive_open_struct.rb

@@ -9,10 +9,16 @@ require 'recursive_open_struct/dig'
 # TODO: When we care less about Rubies before 2.4.0, match OpenStruct's method
 # names instead of doing things like aliasing `new_ostruct_member` to
 # `new_ostruct_member!`
+#
+# TODO: `#*_as_a_hash` deprecated. Nested hashes can be referenced using
+# `#to_h`.
 
 class RecursiveOpenStruct < OpenStruct
   include Ruby19Backport if RUBY_VERSION =~ /\A1.9/
   include Dig if OpenStruct.public_instance_methods.include? :dig
+
+  # TODO: deprecated, possibly remove or make optional an runtime so that it
+  # doesn't normally pollute the public method namespace
   include DebugInspect
 
   def initialize(hash=nil, args={})
@@ -42,6 +48,8 @@ class RecursiveOpenStruct < OpenStruct
     @deep_dup.call(@table)
   end
 
+  # TODO: deprecated, unsupported by OpenStruct. OpenStruct does not consider
+  # itself to be a "kind of" Hash.
   alias_method :to_hash, :to_h
 
   def [](name)
@@ -68,18 +76,26 @@ class RecursiveOpenStruct < OpenStruct
     @table.key?(mname) || super
   end
 
+  # Continue supporting older rubies -- JRuby 9.1.x.x is still considered
+  # stable, but is based on Ruby
+  # 2.3.x and so uses :modifiable instead of :modifiable?. Furthermore, if
+  # :modifiable is private, then make :modifiable? private too.
+  if !OpenStruct.private_instance_methods.include?(:modifiable?)
+    alias_method :modifiable?, :modifiable
+    if OpenStruct.private_instance_methods.include?(:modifiable)
+      private :modifiable?
+    end
+  end
+
   # Adapted implementation of method_missing to accommodate the differences
   # between ROS and OS.
-  #
-  # TODO: Use modifiable? instead of modifiable, and new_ostruct_member!
-  # instead of new_ostruct_member once we care less about Rubies before 2.4.0.
   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]
+      modifiable?[new_ostruct_member!($1.to_sym)] = args[0]
     elsif len == 0
       key = mid
       key = $1 if key =~ /^(.*)_as_a_hash$/
@@ -105,7 +121,7 @@ class RecursiveOpenStruct < OpenStruct
         end
         define_method("#{name}=") do |x|
           @sub_elements.delete(key_name)
-          modifiable[key_name] = x
+          modifiable?[key_name] = x
         end
         define_method("#{name}_as_a_hash") { @table[key_name] }
       end

data/lib/recursive_open_struct/version.rb

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

data/recursive-open-struct.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   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.homepage = "https://github.com/aetherknight/recursive-open-struct"
   s.licenses = ["MIT"]
 
   s.summary = "OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: recursive-open-struct
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - William (B.J.) Snow Orvis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-03 00:00:00.000000000 Z
+date: 2020-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,6 +119,7 @@ files:
 - ".travis.yml"
 - AUTHORS.txt
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -139,7 +140,7 @@ files:
 - spec/recursive_open_struct/recursion_and_subclassing_spec.rb
 - spec/recursive_open_struct/recursion_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/aetherknight/recursive-open-struct
+homepage: https://github.com/aetherknight/recursive-open-struct
 licenses:
 - MIT
 metadata: {}
@@ -158,8 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs