recursive-open-struct 2.0.0 → 2.1.1

data/.travis.yml

@@ -1,34 +0,0 @@
----
-language: ruby
-rvm:
-  # No longer supported (but test anyways)
-  - 2.0.0
-  - 2.1.10
-  - 2.2.10
-  - jruby-19mode
-  - 2.3.8
-  - 2.4.10
-  # Current stable supported by Travis
-  - 2.5.8
-  - 2.6.6
-  - 2.7.2
-  - 3.0.0
-  - jruby-9.1.9.0
-  # Future
-  - ruby-head
-  - jruby-head
-  - truffleruby-head
-sudo: false
-matrix:
-  allow_failures:
-    # No longer supported
-    - rvm: 2.0.0
-    - rvm: 2.1.10
-    - rvm: 2.2.10
-    - rvm: 2.3.8
-    - rvm: 2.4.10
-    - rvm: jruby-19mode
-    # Future
-    - rvm: ruby-head
-    - rvm: jruby-head
-    - rvm: truffleruby-head

data/CONTRIBUTING.md

@@ -1,51 +0,0 @@
-# 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/Gemfile

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

data/Rakefile

@@ -1,60 +0,0 @@
-# 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/recursive-open-struct.gemspec

@@ -1,46 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require './lib/recursive_open_struct/version'
-
-Gem::Specification.new do |s|
-  s.name = "recursive-open-struct"
-  s.version = RecursiveOpenStruct::VERSION
-  s.authors = ["William (B.J.) Snow Orvis"]
-  s.email = "aetherknight@gmail.com"
-  s.date = Time.now.utc.strftime("%Y-%m-%d")
-  s.homepage = "https://github.com/aetherknight/recursive-open-struct"
-  s.licenses = ["MIT"]
-
-  s.summary = "OpenStruct subclass that returns nested hash attributes as RecursiveOpenStructs"
-  s.description = <<-QUOTE .gsub(/^    /,'')
-    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' }
-    QUOTE
-
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files spec`.split("\n")
-  s.require_paths = ["lib"]
-  s.extra_rdoc_files = [
-    "CHANGELOG.md",
-    "LICENSE.txt",
-    "README.md"
-  ]
-
-  s.add_development_dependency('bundler', [">= 0"])
-  s.add_development_dependency('pry', [">= 0"])
-  s.add_development_dependency('rake', [">= 0"])
-  s.add_development_dependency('rdoc', [">= 0"])
-  s.add_development_dependency('rspec', "~> 3.2")
-  s.add_development_dependency('simplecov', [">= 0"])
-
-  s.add_dependency('ostruct')
-end
-

data/spec/recursive_open_struct/debug_inspect_spec.rb

@@ -1,70 +0,0 @@
-require_relative '../spec_helper'
-require 'recursive_open_struct'
-
-describe RecursiveOpenStruct do
-  describe "#debug_inspect" 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
-      @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)
-      expect(@io.string).to match /^a = "b"$/
-      expect(@io.string).to match /^h1\.$/
-      expect(@io.string).to match /^  a = "a"$/
-      expect(@io.string).to match /^  h2\.$/
-      expect(@io.string).to match /^    a = "b"$/
-      expect(@io.string).to match /^    h1\.$/
-      expect(@io.string).to match /^      a = "a"$/
-      expect(@io.string).to match /^      h2\.$/
-      expect(@io.string).to match /^        a = "b"$/
-      expect(@io.string).to match /^        h1\.$/
-      expect(@io.string).to match /^          a = "a"$/
-      expect(@io.string).to match /^          h2\.$/
-      expect(@io.string).to match /^            a = "b"$/
-      expect(@io.string).to match /^            h1\.$/
-      expect(@io.string).to match /^              a = "a"$/
-      expect(@io.string).to match /^              h2\.$/
-      expect(@io.string).to match /^                a = "b"$/
-      expect(@io.string).to match /^                h1\.$/
-      expect(@io.string).to match /^                  a = "a"$/
-      expect(@io.string).to match /^                  h2\.$/
-      expect(@io.string).to match /^                    a = "b"$/
-      expect(@io.string).to match /^                    h1\.$/
-      expect(@io.string).to match /^                      a = "a"$/
-      expect(@io.string).to match /^                      h2\.$/
-      expect(@io.string).to match /^                        \(recursion limit reached\)$/
-    end
-  end
-end

data/spec/recursive_open_struct/indifferent_access_spec.rb

@@ -1,190 +0,0 @@
-require_relative '../spec_helper'
-require 'recursive_open_struct'
-
-describe RecursiveOpenStruct do
-  let(:value) { 'foo' }
-  let(:symbol) { :bar }
-  let(:new_value) { 'bar' }
-  let(:new_symbol) { :foo }
-
-  describe 'indifferent access' do
-    let(:hash) { {:foo => value, 'bar' => symbol} }
-    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
-
-      it('allows getting with method') { expect(subject.foo).to be value }
-      it('allows getting with symbol') { expect(subject[:foo]).to be value }
-      it('allows getting with string') { expect(subject['foo']).to be value }
-
-    end
-
-    context 'setting value with symbol' do
-      before(:each) do
-        subject[:foo] = value
-      end
-
-      it('allows getting with method') { expect(subject.foo).to be value }
-      it('allows getting with symbol') { expect(subject[:foo]).to be value }
-      it('allows getting with string') { expect(subject['foo']).to be value }
-
-    end
-
-    context 'setting value with string' do
-      before(:each) do
-        subject['foo'] = value
-      end
-
-      it('allows getting with method') { expect(subject.foo).to be value }
-      it('allows getting with symbol') { expect(subject[:foo]).to be value }
-      it('allows getting with string') { expect(subject['foo']).to be value }
-
-    end
-
-    context 'overwriting values' do
-      context 'set with method' do
-        before(:each) do
-          subject.foo = value
-        end
-
-        it('overrides with symbol') do
-          subject[:foo] = new_value
-          expect(subject.foo).to be new_value
-        end
-
-        it('overrides with string') 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
-
-        it('overrides with method') do
-          subject.foo = new_value
-          expect(subject[:foo]).to be new_value
-        end
-
-        it('overrides with string') 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
-
-        it('overrides with method') do
-          subject.foo = new_value
-          expect(subject['foo']).to be new_value
-        end
-
-        it('overrides with symbol') 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
-
-          hash_ros.bar = new_symbol
-          expect(hash_ros['bar']).to be new_symbol
-        end
-
-        it('overrides with symbol') do
-          hash_ros[:bar] = new_symbol
-          expect(hash_ros['bar']).to be new_symbol
-        end
-
-        it('overrides with string') 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 '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} ] } ] } }
-
-          let(:hash_ros_opts) { { preserve_original_keys: true }}
-
-          specify 'after initialization' do
-            expect(hash_ros.to_h).to eq 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
-
-      context 'when undefined method' do
-        context 'when raise_on_missing is enabled' do
-          subject(:recursive) { RecursiveOpenStruct.new(recursive_hash, raise_on_missing: true) }
-          let(:recursive_hash) { {:foo => [ {'bar' => [ { 'foo' => :bar} ] } ] } }
-
-          specify 'raises NoMethodError' do
-            expect {
-              recursive.undefined_method
-            }.to raise_error(NoMethodError)
-          end
-        end
-
-        context 'when raise_on_missing is disabled' do
-          context 'preserves the original keys' do
-            subject(:recursive) { RecursiveOpenStruct.new(recursive_hash) }
-            let(:recursive_hash) { {:foo => [ {'bar' => [ { 'foo' => :bar} ] } ] } }
-
-            specify 'returns nil' do
-              expect(recursive.undefined_method).to be_nil
-            end
-          end
-        end
-      end
-
-    end
-
-  end
-end

data/spec/recursive_open_struct/open_struct_behavior_spec.rb

@@ -1,148 +0,0 @@
-require_relative '../spec_helper'
-require 'recursive_open_struct'
-
-describe RecursiveOpenStruct do
-  let(:hash) { {} }
-  subject(:ros) { RecursiveOpenStruct.new(hash) }
-
-  describe "behavior it inherits from OpenStruct" do
-    context 'when not initialized from anything' do
-      subject(:ros) { RecursiveOpenStruct.new }
-      it "can represent arbitrary data objects" do
-        ros.blah = "John Smith"
-        expect(ros.blah).to eq "John Smith"
-      end
-
-      it 'returns nil for missing attributes' do
-        expect(ros.foo).to be_nil
-      end
-    end
-
-    context 'when initialized with nil' do
-      let(:hash) { nil }
-      it 'returns nil for missing attributes' do
-        expect(ros.foo).to be_nil
-      end
-    end
-
-    context 'when initialized with an empty hash' do
-      it 'returns nil for missing attributes' do
-        expect(ros.foo).to be_nil
-      end
-    end
-
-    context "when initialized from a hash" do
-      let(:hash) { { :asdf => 'John Smith' } }
-
-      context 'that contains symbol keys' do
-        it "turns those symbol keys into method names" do
-          expect(ros.asdf).to eq "John Smith"
-        end
-      end
-
-      it "can modify an existing key" do
-        ros.asdf = "George Washington"
-        expect(ros.asdf).to eq "George Washington"
-      end
-
-      context 'that contains string keys' do
-        let(:hash) { { 'asdf' => 'John Smith' } }
-        it "turns those string keys into method names" do
-          expect(ros.asdf).to eq "John Smith"
-        end
-      end
-
-      context 'that contains keys that mirror existing private methods' do
-        let(:hash) { { test: :foo, rand: 'not a number' } }
-
-        # https://github.com/aetherknight/recursive-open-struct/issues/42
-        it 'handles subscript notation without calling the method name first (#42)' do
-          expect(ros['test']).to eq :foo
-          expect(ros['rand']).to eq 'not a number'
-
-          expect(ros.test).to eq :foo
-          expect(ros.rand).to eq 'not a number'
-        end
-
-      end
-
-      context 'that contains keys that mirror existing public methods inherited from Object' do
-        let(:hash) { { method: :something } }
-        it 'handles subscript notation without calling the existing methods' do
-          expect(ros[:method]).to eq :something
-          expect(ros['method']).to eq :something
-        end
-      end
-
-      if [/\A([0-9]+)\.([0-9]+)\.([0-9]+)\z/.match(RUBY_VERSION)].tap { |l| m = l[0] ; l[0] = (m[1].to_i >= 2 && m[2].to_i >= 4) }.first
-        context 'when Ruby 2.4.0 or newer' do
-          specify 'new_ostruct_member! is private' do
-            expect {
-              ros.new_ostruct_member!(:bonsoir)
-            }.to raise_error(NoMethodError)
-              # OpenStruct.new().new_ostruct_member!(:foo)
-          end
-        end
-      end
-
-    end
-
-
-    describe "handling of arbitrary attributes" do
-      subject { RecursiveOpenStruct.new }
-      before(:each) do
-        subject.blah = "John Smith"
-      end
-
-      describe "#respond?" do
-        it { expect(subject).to respond_to :blah }
-        it { expect(subject).to respond_to :blah= }
-        it { expect(subject).to_not respond_to :asdf }
-        it { expect(subject).to_not respond_to :asdf= }
-      end # describe #respond?
-
-      describe "#methods" do
-        it { expect(subject.methods.map(&:to_sym)).to include :blah }
-        it { expect(subject.methods.map(&:to_sym)).to include :blah= }
-        it { expect(subject.methods.map(&:to_sym)).to_not include :asdf }
-        it { expect(subject.methods.map(&:to_sym)).to_not include :asdf= }
-      end # describe #methods
-    end # describe handling of arbitrary attributes
-
-    describe "handling of freezing" do
-      let(:hash) { { :asdf => 'John Smith' } }
-
-      before do
-        ros.freeze
-      end
-
-      it "can read existing keys" do
-        expect(ros.asdf).to eq 'John Smith'
-      end
-
-      it "cannot write new keys" do
-        expect { ros.new_key = 'new_value' }.to raise_error FrozenError
-      end
-
-      it "cannot write existing keys" do
-        expect { ros.asdf = 'new_value' }.to raise_error FrozenError
-      end
-
-      context "with recursive structure" do
-        let(:hash) { { :key => { :subkey => 42 } } }
-
-        it "can read existing sub-elements" do
-          expect(ros.key.subkey).to eq 42
-        end
-
-        it "can write new sub-elements" do
-          expect { ros.key.new_subkey = 43 }.not_to raise_error
-        end
-
-        it "can write existing sub-elements" do
-          expect { ros.key.subkey = 43 }.not_to raise_error
-        end
-      end
-    end
-  end # describe behavior it inherits from OpenStruct
-end