fancy-open-struct 0.1

data/.document

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

data/.gitignore

@@ -0,0 +1,52 @@
+# 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
+
+*.gem

data/.rspec

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

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+gemspec
+
+group :development do
+  if RUBY_VERSION =~ /^1\.8/
+    gem 'rcov'
+  else
+    gem 'simplecov'
+  end
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Thomas H. Chapin
+
+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.rdoc

@@ -0,0 +1,63 @@
+= fancy-open-struct
+
+OpenStruct subclass that returns nested (recursive) hash attributes as FancyOpenStructs,
+and also allows usage of Hash methods for getting and setting values.
+
+It allows for hashes within hashes to be called in a chain of methods:
+
+  fos = FancyOpenStruct.new( { :fooa => { :foob => 'fooc' } } )
+
+  fos.fooa.foob # => 'fooc'
+
+Also, if needed, nested hashes can still be accessed as hashes:
+
+  fos.fooa_as_a_hash # { :foob => 'fooc' }
+
+Get and set values either via dot syntax, or hash syntax (Hash keys are handled as Symbols):
+
+  fos.foo = 'bar'
+  fos[:foo] # 'bar'
+
+  fos[:baz] = 'qux'
+  fos.baz # 'qux'
+
+  fos.length # 2
+
+FancyOpenStruct can also optionally recurse across arrays, although you
+have to explicitly enable it:
+
+  h = { :somearr => [ { :name => 'a'}, { :name => 'b' } ] }
+
+  fos = FancyOpenStruct.new(h, :recurse_over_arrays => true )
+
+  fos.somarr[0].name # => 'a'
+  fos.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 'fancy-open-struct'
+
+You may also install the gem manually :
+
+  gem install fancy-open-struct
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2014 Thomas H. Chapin. See LICENSE for details.
+
+This gem is based on the recursive-open-struct gem by William (B.J.) Snow Orvis, which can be found here:
+https://github.com/aetherknight/recursive-open-struct

data/Rakefile

@@ -0,0 +1,45 @@
+# 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 = "fancy-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
+
+task :build => :fix_permissions

data/fancy-open-struct.gemspec

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+require './lib/fancy_open_struct'
+
+Gem::Specification.new do |s|
+  s.name = "fancy-open-struct"
+  s.version = FancyOpenStruct::VERSION
+  s.authors = ["Thomas H. Chapin"]
+  s.email = "tchapin@gmail.com"
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
+  s.homepage = "http://github.com/tomchapin/fancy-open-struct"
+  s.licenses = ["MIT"]
+
+  s.summary = "OpenStruct subclass that returns nested hash attributes as FancyOpenStructs"
+  s.description = <<-QUOTE .gsub(/^    /,'')
+    FancyOpenStruct is a subclass of OpenStruct, and is a variant of RecursiveOpenStruct.
+    It differs from OpenStruct in that it allows nested hashes to be treated in a recursive
+    fashion, and it also provides Hash methods for getting and setting values.
+
+    For example:
+
+        fos = FancyOpenStruct.new({ :a => { :b => 'c' } })
+        fos.a.b # 'c'
+
+        fos.foo = 'bar'
+        fos[:foo] # 'bar'
+
+        fos.length # 2
+
+    Also, nested hashes can still be accessed as hashes:
+
+        fos.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 = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+
+  s.add_development_dependency(%q<rspec>, [">= 0"])
+  s.add_development_dependency(%q<bundler>, [">= 0"])
+  s.add_development_dependency(%q<rdoc>, [">= 0"])
+end
+

data/lib/fancy-open-struct.rb

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

data/lib/fancy_open_struct.rb

@@ -0,0 +1,126 @@
+require 'pry'
+require 'ostruct'
+require 'delegate'
+
+class FancyOpenStruct < OpenStruct
+  VERSION = "0.1"
+
+  extend Forwardable
+
+  hash_methods = Hash.instance_methods(false) - (Hash.instance_methods(false) & OpenStruct.instance_methods(false))
+  def_delegators :@table, *hash_methods
+
+  def initialize(hash=nil, args={})
+    @recurse_over_arrays = args.fetch(:recurse_over_arrays, false)
+    @table = {}
+    if hash
+      for k, v in hash
+        @table[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+    @sub_elements = {}
+  end
+
+  def to_h
+    @table.dup.update(@sub_elements) do |k, oldval, newval|
+      if newval.kind_of?(self.class)
+        newval.to_h
+      elsif newval.kind_of?(Array)
+        newval.map { |a| a.kind_of?(self.class) ? a.to_h : a }
+      else
+        raise "Cached value of unsupported type: #{newval.inspect}"
+      end
+    end
+  end
+
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless self.respond_to?(name)
+      define_singleton_method name do
+        v = @table[name]
+        if v.is_a?(Hash)
+          @sub_elements[name] ||= self.class.new(v, :recurse_over_arrays => @recurse_over_arrays)
+        elsif v.is_a?(Array) and @recurse_over_arrays
+          @sub_elements[name] ||= recurse_over_array v
+        else
+          v
+        end
+      end
+      define_singleton_method("#{name}=") { |x| modifiable[name] = x }
+      define_singleton_method("#{name}_as_a_hash") { @table[name] }
+    end
+    name
+  end
+
+  def recurse_over_array array
+    array.map do |a|
+      if a.is_a? Hash
+        self.class.new(a, :recurse_over_arrays => true)
+      elsif a.is_a? Array
+        recurse_over_array a
+      else
+        a
+      end
+    end
+  end
+
+  def debug_inspect(io = STDOUT, indent_level = 0, recursion_limit = 12)
+    display_recursive_open_hash(io, @table, indent_level, recursion_limit)
+  end
+
+  def display_recursive_open_hash(io, ostrct_or_hash, indent_level, recursion_limit)
+
+    if recursion_limit <= 0
+      # protection against recursive structure (like in the tests)
+      io.puts '  '*indent_level + '(recursion limit reached)'
+    else
+      #puts ostrct_or_hash.inspect
+      if ostrct_or_hash.is_a?(self.class)
+        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?(self.class) || 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?(self.class) || value.is_a?(Hash)
+          io.puts '  '*indent_level + key.to_s + '.'
+          display_recursive_open_hash(io, value, indent_level + 1, recursion_limit - 1)
+        else
+          io.puts '  '*indent_level + key.to_s + ' '*(data_indent - key.to_s.length) + ' = ' + value.inspect
+        end
+      end
+    end
+
+    true
+  end
+
+  def []=(*args)
+    len = args.length
+    raise ArgumentError, "wrong number of arguments (#{len} for 2)", caller(1) if len != 2
+    modifiable[new_ostruct_member(args[0].to_sym)] = args[1]
+  end
+
+  def method_missing(mid, *args) # :nodoc:
+    mname = mid.id2name
+    len = args.length
+    if mname.chomp!('=')
+      raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1) if len != 1
+      # Set up an instance method to point to the key/value in the table and set the value
+      modifiable[new_ostruct_member(mname.to_sym)] = args[0]
+    elsif @table.has_key?(mid)
+      # The table has apparently been modified externally, so we need to set up
+      # an instance method to point to the key/value in the table.
+      new_ostruct_member(mname.to_sym)
+      self.send(mid)
+    else
+      nil
+    end
+  end
+end

data/spec/fancy_open_struct_spec.rb

@@ -0,0 +1,308 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'fancy_open_struct'
+
+describe FancyOpenStruct do
+
+  describe "behavior it inherits from OpenStruct" do
+
+    it "can represent arbitrary data objects" do
+      fos = FancyOpenStruct.new
+      fos.blah = "John Smith"
+      fos.blah.should == "John Smith"
+    end
+
+    it "can be created from a hash" do
+      h = {:asdf => 'John Smith'}
+      fos = FancyOpenStruct.new(h)
+      fos.asdf.should == "John Smith"
+    end
+
+    it "can modify an existing key" do
+      h = {:blah => 'John Smith'}
+      fos = FancyOpenStruct.new(h)
+      fos.blah = "George Washington"
+      fos.blah.should == "George Washington"
+    end
+
+    describe "handling of arbitrary attributes" do
+      subject { FancyOpenStruct.new }
+      before(:each) do
+        subject.blah = "John Smith"
+      end
+
+      describe "#respond?" do
+        it { subject.should respond_to :blah }
+        it { subject.should respond_to :blah= }
+        it { subject.should_not respond_to :asdf }
+        it { subject.should_not respond_to :asdf= }
+      end # describe #respond?
+
+      describe "#methods" do
+        it { subject.methods.map(&:to_sym).should include :blah }
+        it { subject.methods.map(&:to_sym).should include :blah= }
+        it { subject.methods.map(&:to_sym).should_not include :asdf }
+        it { subject.methods.map(&:to_sym).should_not include :asdf= }
+      end # describe #methods
+    end # describe handling of arbitrary attributes
+  end # describe behavior it inherits from OpenStruct
+
+  describe "improvements on OpenStruct" do
+    it "can be converted back to a hash" do
+      h = {:asdf => 'John Smith'}
+      fos = FancyOpenStruct.new(h)
+      fos.to_h.should == h
+    end
+
+    describe 'hash methods' do
+      it "handles hash methods for setting values" do
+        fos = FancyOpenStruct.new
+        fos['blah'] = "John Smith"
+        fos[:foo] = "George Washington"
+        fos.blah.should == "John Smith"
+        fos.foo.should == "George Washington"
+      end
+
+      it 'converts string hash keys to symbols' do
+        fos = FancyOpenStruct.new
+        fos['blah'] = "John Smith"
+        fos['blah'].should == nil
+        fos[:blah].should == "John Smith"
+        fos.blah.should == "John Smith"
+      end
+
+      it 'forwards all of the basic Hash methods directly to the @table instance variable' do
+        fos = FancyOpenStruct.new
+        Hash.instance_methods(false).each do |method_name|
+          fos.respond_to?(method_name).should be_true
+        end
+      end
+
+      it 'recovers gracefully even when the internal hash @table is directly modified via hash methods' do
+        fos = FancyOpenStruct.new
+        fos.foo = 'bar'
+        fos.to_h.should == {:foo => "bar"}
+        other_hash = {:baz => :qux}
+        fos.merge! other_hash
+        fos.to_h.should == {:foo => "bar", :baz => :qux}
+        fos.foo.should == 'bar'
+        fos.baz.should == :qux
+        fos.instance_variable_set :@table, {}
+        fos.foo.should == nil
+        fos.baz.should == nil
+      end
+    end
+
+    context 'using strings instead of symbols as hash keys' do
+      it "can be created from a hash" do
+        h = {'asdf' => 'John Smith'}
+        fos = FancyOpenStruct.new(h)
+        fos.asdf.should == "John Smith"
+      end
+
+      it "can modify an existing key" do
+        h = {'blah' => 'John Smith'}
+        fos = FancyOpenStruct.new(h)
+        fos.blah = "George Washington"
+        fos.blah.should == "George Washington"
+      end
+
+      it 'saves string hash keys as symbols' do
+        h = {'blah' => 'John Smith'}
+        fos = FancyOpenStruct.new(h)
+        fos.to_h.should == {:blah => "John Smith"}
+        fos[:blah].should == "John Smith"
+      end
+    end
+  end
+
+  describe "recursive behavior" do
+    let(:h) { {:blah => {:another => 'value'}} }
+    subject { FancyOpenStruct.new(h) }
+
+    it "returns accessed hashes as FancyOpenStructs instead of hashes" do
+      subject.blah.another.should == 'value'
+    end
+
+    it "uses #key_as_a_hash to return key as a Hash" do
+      subject.blah_as_a_hash.should == {:another => 'value'}
+    end
+
+    describe "handling loops in the origin Hashes" do
+      let(:h1) { {:a => 'a'} }
+      let(:h2) { {:a => 'b', :h1 => h1} }
+      before(:each) { h1[:h2] = h2 }
+
+      subject { FancyOpenStruct.new(h2) }
+
+      it { subject.h1.a.should == 'a' }
+      it { subject.h1.h2.a.should == 'b' }
+      it { subject.h1.h2.h1.a.should == 'a' }
+      it { subject.h1.h2.h1.h2.a.should == 'b' }
+      it { subject.h1.should == subject.h1.h2.h1 }
+      it { subject.h1.should_not == subject.h1.h2 }
+    end # describe handling loops in the origin Hashes
+
+    it "can modify a key of a sub-element" do
+      h = {
+          :blah => {
+              :blargh => 'Brad'
+          }
+      }
+      fos = FancyOpenStruct.new(h)
+      fos.blah.blargh = "Janet"
+      fos.blah.blargh.should == "Janet"
+    end
+
+    context "after a sub-element has been modified" do
+      let(:hash) do
+        {
+            :blah => {
+                :blargh => 'Brad'
+            }
+        }
+      end
+      subject { FancyOpenStruct.new(hash) }
+      before(:each) { subject.blah.blargh = "Janet" }
+      it "returns a hash that contains those modifications" do
+        subject.to_h.should == {:blah => {:blargh => "Janet"}}
+      end
+    end
+
+
+    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
+        subject { FancyOpenStruct.new(h, :recurse_over_arrays => true) }
+
+        it { subject.blah.length.should == 3 }
+        it { subject.blah[0].foo.should == '1' }
+        it { subject.blah[1].foo.should == '2' }
+        it { subject.blah_as_a_hash.should == blah_list }
+        it { subject.blah[2].should == 'baz' }
+        it "Retains changes acfoss Array lookups" do
+          subject.blah[1].foo = "Dr Scott"
+          subject.blah[1].foo.should == "Dr Scott"
+        end
+        it "propagates the changes through to .to_h acfoss Array lookups" do
+          subject.blah[1].foo = "Dr Scott"
+          subject.to_h.should == {
+              :blah => [{:foo => '1'}, {:foo => "Dr Scott"}, 'baz']
+          }
+        end
+
+        context "when array is nested deeper" do
+          let(:deep_hash) { {:foo => {:blah => blah_list}} }
+          subject { FancyOpenStruct.new(deep_hash, :recurse_over_arrays => true) }
+
+          it { subject.foo.blah.length.should == 3 }
+          it "Retains changes acfoss Array lookups" do
+            subject.foo.blah[1].foo = "Dr Scott"
+            subject.foo.blah[1].foo.should == "Dr Scott"
+          end
+
+        end
+
+        context "when array is in an array" do
+          let(:haah) { {:blah => [blah_list]} }
+          subject { FancyOpenStruct.new(haah, :recurse_over_arrays => true) }
+
+          it { subject.blah.length.should == 1 }
+          it { subject.blah[0].length.should == 3 }
+          it "Retains changes acfoss Array lookups" do
+            subject.blah[0][1].foo = "Dr Scott"
+            subject.blah[0][1].foo.should == "Dr Scott"
+          end
+
+        end
+
+      end # when recursing over arrays is enabled
+
+      context "when recursing over arrays is disabled" do
+        subject { FancyOpenStruct.new(h) }
+
+        it { subject.blah.length.should == 3 }
+        it { subject.blah[0].should == {:foo => '1'} }
+        it { subject.blah[0][:foo].should == '1' }
+      end # when recursing over arrays is disabled
+
+    end # recursing over arrays
+  end # recursive behavior
+
+  describe "additional features" do
+
+    before(:each) do
+      h1 = {:a => 'a'}
+      h2 = {:a => 'b', :h1 => h1}
+      h1[:h2] = h2
+      @fos = FancyOpenStruct.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
+      @fos.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
+
+    it "creates nested objects via subclass" do
+      FancyOpenStructSubClass = Class.new(FancyOpenStruct)
+
+      fossc = FancyOpenStructSubClass.new({:one => [{:two => :three}]}, recurse_over_arrays: true)
+
+      fossc.one.first.class.should == FancyOpenStructSubClass
+    end
+  end # additionnel features
+
+end # describe FancyOpenStruct

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  SimpleCov.start
+end
+
+# Requires supporting files with custom matchers and macfos, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: fancy-open-struct
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Thomas H. Chapin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "FancyOpenStruct is a subclass of OpenStruct, and is a variant of RecursiveOpenStruct.\nIt
+  differs from OpenStruct in that it allows nested hashes to be treated in a recursive\nfashion,
+  and it also provides Hash methods for getting and setting values.\n\nFor example:\n\n
+  \   fos = FancyOpenStruct.new({ :a => { :b => 'c' } })\n    fos.a.b # 'c'\n\n    fos.foo
+  = 'bar'\n    fos[:foo] # 'bar'\n\n    fos.length # 2\n\nAlso, nested hashes can
+  still be accessed as hashes:\n\n    fos.a_as_a_hash # { :b => 'c' }\n\n"
+email: tchapin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- fancy-open-struct.gemspec
+- lib/fancy-open-struct.rb
+- lib/fancy_open_struct.rb
+- spec/fancy_open_struct_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/tomchapin/fancy-open-struct
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: OpenStruct subclass that returns nested hash attributes as FancyOpenStructs
+test_files:
+- spec/fancy_open_struct_spec.rb
+- spec/spec_helper.rb