fancy-open-struct 0.1.2 → 0.1.3

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: ATscazUF1vqixUbLan70hDzMHNPsrSu0b

data/.rspec

@@ -1 +1,2 @@
 --color
+--format progress

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/Gemfile

@@ -7,5 +7,4 @@ group :development do
   else
     gem 'simplecov'
   end
-  gem 'pry'
 end

data/README.rdoc

@@ -1,9 +1,23 @@
-= fancy-open-struct
+= FancyOpenStruct
 
-OpenStruct subclass that returns nested (recursive) hash attributes as FancyOpenStructs,
-and also allows usage of Hash methods for getting and setting values.
+{<img src="http://allthebadges.io/tomchapin/fancy-open-struct/badge_fury.png" alt="Version" />}[http://allthebadges.io/tomchapin/fancy-open-struct/badge_fury]
+{<img src="http://allthebadges.io/tomchapin/fancy-open-struct/gemnasium.png" alt="Dependencies" />}[http://allthebadges.io/tomchapin/fancy-open-struct/gemnasium]
+{<img src="http://allthebadges.io/tomchapin/fancy-open-struct/travis.png" alt="Build Status" />}[http://allthebadges.io/tomchapin/fancy-open-struct/travis]
+{<img src="http://allthebadges.io/tomchapin/fancy-open-struct/coveralls.png" alt="Coverage" />}[http://allthebadges.io/tomchapin/fancy-open-struct/coveralls]
+{<img src="http://allthebadges.io/tomchapin/fancy-open-struct/code_climate.png" alt="Code Climate" />}[http://allthebadges.io/tomchapin/fancy-open-struct/code_climate]
 
-It allows for hashes within hashes to be called in a chain of methods:
+FancyOpenStruct is a subclass of OpenStruct, and is a variant of RecursiveOpenStruct.
+
+This gem allows you to convert nested hashes into a structure where keys and values can be
+navigated and modified via dot-syntax, like: foo.bar = :something. This particular gem also adds support
+for the Hash methods you know and love (such as length or merge), and also allows you to access and modify
+the contained data structure the same way that you would handle a normal Hash.
+
+== Usage
+
+FancyOpenStruct allows for hashes within hashes to be called in a chain of methods:
+
+  require 'fancy-open-struct'
 
   fos = FancyOpenStruct.new( { :fooa => { :foob => 'fooc' } } )
 
@@ -15,6 +29,8 @@ Also, if needed, nested hashes can still be accessed as hashes:
 
 Get and set values either via dot syntax, or hash syntax (Hash keys are handled as Symbols):
 
+  fos = FancyOpenStruct.new
+
   fos.foo = 'bar'
   fos[:foo] # 'bar'
 

data/Rakefile

@@ -42,4 +42,4 @@ task :fix_permissions do
   FileUtils.chmod 0755, ['lib','spec'], :verbose => true
 end
 
-task :build => :fix_permissions
+task :build => :fix_permissions

data/fancy-open-struct.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-require './lib/fancy_open_struct'
+require './lib/fancy-open-struct'
 
 Gem::Specification.new do |s|
   s.name = "fancy-open-struct"
@@ -12,38 +12,32 @@ Gem::Specification.new do |s|
   s.licenses = ["MIT"]
 
   s.summary = "OpenStruct subclass that returns nested hash attributes as FancyOpenStructs"
-  s.description = <<-QUOTE .gsub(/^    /,'')
+  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.
+    This allows you to convert nested hashes into a structure where keys and values can be
+    navigated and modified via dot-syntax, like: foo.bar = :something. This particular gem
+    also adds support for Hash methods (such as length or merge), and also allows you to
+    access and modify the data structure the same way that you would handle a normal Hash.
 
-    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
+  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"
+      "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"])
-  s.add_development_dependency(%q<pry>, [">= 0"])
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rdoc"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "coveralls"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "guard-bundler"
+  s.add_development_dependency "simplecov-multi"
 end
 

data/lib/fancy-open-struct.rb

@@ -1 +1,125 @@
-require 'fancy_open_struct'
+require 'ostruct'
+require 'forwardable'
+
+class FancyOpenStruct < OpenStruct
+  VERSION = "0.1.3"
+
+  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/lib/fancy_open_struct.rb

@@ -1,125 +1 @@
-require 'ostruct'
-require 'forwardable'
-
-class FancyOpenStruct < OpenStruct
-  VERSION = "0.1.2"
-
-  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
+require 'fancy-open-struct'

data/spec/spec_helper.rb

@@ -5,6 +5,12 @@ require 'pry'
 
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      Coveralls::SimpleCov::Formatter
+  ]
   SimpleCov.start
 end
 
@@ -13,6 +19,7 @@ end
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-  config.filter_run focus: true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
+  config.filter_run :focus
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fancy-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -28,7 +28,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
+  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: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -75,12 +91,102 @@ dependencies:
     - - ! '>='
       - !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"
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: guard
+  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: guard-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: guard-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: simplecov-multi
+  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.
+
+  This allows you to convert nested hashes into a structure where keys and values
+  can be
+
+  navigated and modified via dot-syntax, like: foo.bar = :something. This particular
+  gem
+
+  also adds support for Hash methods (such as length or merge), and also allows you
+  to
+
+  access and modify the data structure the same way that you would handle a normal
+  Hash.
+
+
+'
 email: tchapin@gmail.com
 executables: []
 extensions: []
@@ -88,9 +194,11 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.rdoc
 files:
+- .coveralls.yml
 - .document
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.rdoc