hash-proxy 0.1.5 → 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8eb13d235ef7982d3e5198f8a0162e5ffab73b7
+  data.tar.gz: 2d8917c67b98c0053da4b5a13cbe6fea23d330a3
+SHA512:
+  metadata.gz: 33047135a972c9592132d6562515f8f9f787c70e23ef36e1bff8e6ed00c7ffe5f1e1754f1f041d6716af9456426d8890ec626d94cafb9f86cda4f17c6105eba8
+  data.tar.gz: 9222c1f4376fae7060388d95ae2781474f8abf6064081c59e8161b6f79192fa2c573255c16be9c7c70d6b43825746562dd2313b3ea1d84c91f07499142b5e5a3

data/.ruby-gemset

@@ -0,0 +1 @@
+hash-proxy

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.4.1

data/Gemfile

@@ -1,5 +1,6 @@
 source 'https://rubygems.org'
 
+gem 'rspec'
 gem 'bones'
 gem 'bones-rspec'
 gem 'bones-git'

data/Gemfile.lock

@@ -1,34 +1,40 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    bones (3.8.0)
-      little-plugger (~> 1.1.3)
-      loquacious (~> 1.9.1)
-      rake (>= 0.8.7)
-    bones-git (1.3.0)
-      bones (>= 3.6)
-      git (>= 1.2.5)
+    bones (3.8.4)
+      little-plugger (~> 1.1)
+      loquacious (~> 1.9)
+      rake (~> 12.0)
+      rdoc (~> 5.0)
+    bones-git (1.3.1)
+      git (~> 1.2)
     bones-rspec (2.0.1)
       bones (>= 3.6)
       rspec (>= 1.3)
     bones-yard (1.0.0)
       bones (>= 3.5.0)
       yard (>= 0.5.8)
-    diff-lcs (1.2.1)
-    git (1.2.5)
-    little-plugger (1.1.3)
+    diff-lcs (1.3)
+    git (1.5.0)
+    little-plugger (1.1.4)
     loquacious (1.9.1)
-    rake (10.0.3)
-    redcarpet (2.2.2)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.0)
-    yard (0.8.5.2)
+    rake (12.3.1)
+    rdoc (5.1.0)
+    redcarpet (3.4.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    yard (0.9.16)
 
 PLATFORMS
   ruby
@@ -39,3 +45,7 @@ DEPENDENCIES
   bones-rspec
   bones-yard
   redcarpet
+  rspec
+
+BUNDLED WITH
+   1.15.4

data/History.txt

@@ -1,3 +1,7 @@
+# == Version 0.1.6 / 2014-09-25
+# * Pin to rspec < 3
+# * fix a warning
+#
 # == Version 0.1.5 / 2013-03-12
 # * Support #to_json
 #

data/README.md

@@ -83,6 +83,10 @@ Original author: Douglas A. Seifert (doug@dseifert.net)
 History
 -------
 
+### Version 0.1.6 / 2014-09-25
+* Pin to rspec < 3
+* fix a warning
+
 ### Version 0.1.5 / 2013-03-12
 * Support #to_json
 

data/Rakefile

@@ -13,11 +13,11 @@ Bones {
   authors  'Douglas A. Seifert'
   email    'doug@dseifert.net'
   url      'https://github.com/seifertd/hash-proxy'
-  depend_on 'bones', :development => true
-  depend_on 'bones-rspec', :development => true
-  depend_on 'bones-git', :development => true
-  depend_on 'bones-yard', :development => true
-  depend_on 'redcarpet', :development => true
+  #depend_on 'bones', :development => true
+  #depend_on 'bones-rspec', :development => true
+  #depend_on 'bones-git', :development => true
+  #depend_on 'bones-yard', :development => true
+  #depend_on 'redcarpet', :development => true
 
   yard.exclude ['version.txt']
 }

data/lib/hash_proxy/proxy.rb

@@ -121,7 +121,7 @@ module HashProxy
     #    p.stuff => NullObject
     #    p.respond_to?(:stuff) => true
     #
-    def respond_to?(method)
+    def respond_to?(method, include_all = false)
       method_name = method.to_s
       method_name.gsub(/=$/, '')
       (@hash && @converted && (@hash.keys.map(&:to_s) + @converted.keys.map(&:to_s)).include?(method_name)) || super

data/spec/hash_proxy_spec.rb

@@ -6,55 +6,55 @@ describe HashProxy do
     proxy = HashProxy.create_from(:size => 42, :bar => :foo)
     data = Marshal.dump(proxy)
     proxy2 = Marshal.load(data)
-    proxy.keys.should eq(proxy2.keys)
-    proxy.values.should eq(proxy2.values)
+    expect(proxy.keys).to eq(proxy2.keys)
+    expect(proxy.values).to eq(proxy2.values)
   end
 
   it "works with null values" do
     proxy = HashProxy.create_from(:null => nil)
-    proxy.size.should eq(1)
-    proxy.null.should be_nil
-    proxy.null.class.should eq(HashProxy::NullObject)
-    proxy.null.to_a.should eq([])
-    proxy.null.to_ary.should eq([])
+    expect(proxy.size).to eq(1)
+    expect(proxy.null).to be_nil
+    expect(proxy.null.class).to eq(HashProxy::NullObject)
+    expect(proxy.null.to_a).to eq([])
+    expect(proxy.null.to_ary).to eq([])
   end
 
   it "works with keys called size" do
     proxy = HashProxy.create_from(:size => 42, :bar => :foo)
-    proxy.size.should eq(2)
-    proxy[:size].should == 42
+    expect(proxy.size).to eq(2)
+    expect(proxy[:size]).to eq(42)
   end
 
 
   it "handles booleans" do
     proxy = HashProxy.create_from(:indexed => false, :followed => true)
-    proxy.indexed.should eq(false)
-    proxy.followed.should == true
+    expect(proxy.indexed).to eq(false)
+    expect(proxy.followed).to eq(true)
   end
 
   it "does not get confused by methods defined on Kernel" do
     proxy = HashProxy::Proxy.new({})
-    lambda { proxy[:format] }.should_not raise_error
-    proxy.format.should be_nil
+    expect(lambda { proxy[:format] }).to_not raise_error
+    expect(proxy.format).to be_nil
   end
 
   it "supports enumerable" do
     hash = {foo: 'bar', baz: 'bip', smee: 'cree'}
     proxy = HashProxy::Proxy.new(hash)
     iterator = proxy.each
-    iterator.to_a.should eq([[:foo, 'bar'], [:baz, 'bip'], [:smee, 'cree']])
+    expect(iterator.to_a).to eq([[:foo, 'bar'], [:baz, 'bip'], [:smee, 'cree']])
 
-    proxy.take(1).should eq([[:foo, 'bar']])
+    expect(proxy.take(1)).to eq([[:foo, 'bar']])
   end
 
   it "behaves kind of like a hash" do
     hash = {foo: 'bar', baz: 'bip', smee: 'cree'}
     proxy = HashProxy::Proxy.new(hash)
-    proxy.size.should eq(3)
-    proxy.each.to_a.size.should eq(3)
-    proxy.each.to_a.map{|a| a.first}.should eq([:foo, :baz, :smee])
-    proxy.each.to_a.map{|a| a.last}.should eq(['bar', 'bip', 'cree'])
-    proxy[:foo].should eq('bar')
+    expect(proxy.size).to eq(3)
+    expect(proxy.each.to_a.size).to eq(3)
+    expect(proxy.each.to_a.map{|a| a.first}).to eq([:foo, :baz, :smee])
+    expect(proxy.each.to_a.map{|a| a.last}).to eq(['bar', 'bip', 'cree'])
+    expect(proxy[:foo]).to eq('bar')
   end
 
   it "can call setters" do
@@ -62,79 +62,79 @@ describe HashProxy do
     proxy.foo = 'foo val'
     proxy.bar = {:bip => :baz, :smoo => :smee}
 
-    proxy.size.should eq(2)
-    proxy[:bar].class.should eq(HashProxy::Proxy)
+    expect(proxy.size).to eq(2)
+    expect(proxy[:bar].class).to eq(HashProxy::Proxy)
   end
 
   it "handles crappy method calls" do
     proxy = HashProxy::Proxy.new({})
-    lambda { proxy.send(:'=', 'crap') }.should raise_error(NoMethodError)
+    expect(lambda { proxy.send(:'=', 'crap') }).to raise_error(NoMethodError)
   end
 
-  it "turns hash keys into method calls" do
+  it "turns hash keys i).to method calls" do
     hash = {foo: 'bar', baz: 'bip'}
     proxy = HashProxy::Proxy.new(hash)
-    proxy.foo.should eq('bar')
-    proxy.baz.should eq('bip')
+    expect(proxy.foo).to eq('bar')
+    expect(proxy.baz).to eq('bip')
   end
 
   it "handles nested hashes" do
     hash = {foo: {bar: 'barvalue', baz: 'bazvalue'}, bip: 'bipvalue'}
     proxy = HashProxy::Proxy.new(hash)
-    proxy.foo.bar.should eq('barvalue')
-    proxy.foo.baz.should eq('bazvalue')
-    proxy.bip.should eq('bipvalue')
+    expect(proxy.foo.bar).to eq('barvalue')
+    expect(proxy.foo.baz).to eq('bazvalue')
+    expect(proxy.bip).to eq('bipvalue')
   end
 
   it "handles string keys" do
     hash = {'foo' => 'bar', 'baz' => 'bip'}
     proxy = HashProxy::Proxy.new(hash)
-    proxy.foo.should eq('bar')
-    proxy.baz.should eq('bip')
+    expect(proxy.foo).to eq('bar')
+    expect(proxy.baz).to eq('bip')
   end
 
   it "handles simple arrays" do
     hash = {'foo' => 'bar', 'arr1' => [1,2,3], 'baz' => 'bip'}
     proxy = HashProxy::Proxy.new(hash)
-    proxy.arr1.should eq([1,2,3])
+    expect(proxy.arr1).to eq([1,2,3])
   end
 
   it "handles complicated arrays" do
     hash = {'foo' => 'bar', 'arr1' => [{'subkey' => 'subkeyval', 'more' => 'moreval'}, 3, {'subkey' => 'subkeyval2', 'more' => 'moreval2'}], 'baz' => 'bip'}
     proxy = HashProxy::Proxy.new(hash)
-    proxy.arr1.first.subkey.should eq('subkeyval')
-    proxy.arr1.last.subkey.should eq('subkeyval2')
-    proxy.arr1[1].should eq(3)
+    expect(proxy.arr1.first.subkey).to eq('subkeyval')
+    expect(proxy.arr1.last.subkey).to eq('subkeyval2')
+    expect(proxy.arr1[1]).to eq(3)
   end
 
   it "should not convert values if nothing is referenced" do
     hash = {'foo' => 'bar', 'arr1' => [1,2,3], 'baz' => 'bip'}
-    proxy = HashProxy::Proxy.new(hash)
-    HashProxy::Proxy.should_not_receive(:convert_value)
-    proxy.to_s
+    HashProxy::Proxy.new(hash)
+    expect(HashProxy::Proxy).not_to receive(:convert_value)
   end
 
   it "should convert values if they are referenced" do
     hash = {foo: 'bar', baz: 'bip'}
     proxy = HashProxy::Proxy.new(hash)
-    proxy.should_receive(:convert_value).once.with('bar').and_return('bar')
-    proxy.foo.should eq('bar')
+    #proxy.should_receive(:convert_value).once.with('bar').and_return('bar')
+    expect(proxy).to receive(:convert_value).once.with('bar').and_return('bar')
+    expect(proxy.foo).to eq('bar')
   end
 
   it "can be created using the factory method" do
     hash = {foo: 'bar', baz: 'bip'}
     proxy = HashProxy.create_from(hash)
-    proxy.foo.should eq('bar')
+    expect(proxy.foo).to eq('bar')
   end
 
   it "handles keys that do not exist" do
     hash = {foo: 'bar', baz: 'bip'}
     proxy = HashProxy.create_from(hash)
-    proxy.key.does.not.exist.to_s.should eq('')
-    proxy.key.does.not.exist.nil?.should eq(true)
-    proxy.key.does.not.exist.blank?.should eq(true)
-    proxy.key.does.not.exist.empty?.should eq(true)
-    proxy.key.does.not.exist.to_a.should eq([])
+    expect(proxy.key.does.not.exist.to_s).to eq('')
+    expect(proxy.key.does.not.exist.nil?).to eq(true)
+    expect(proxy.key.does.not.exist.blank?).to eq(true)
+    expect(proxy.key.does.not.exist.empty?).to eq(true)
+    expect(proxy.key.does.not.exist.to_a).to eq([])
   end
 
   describe "json conversion" do
@@ -142,35 +142,35 @@ describe HashProxy do
     it "should work when no keys are converted" do
       hash = {foo: 'bar', baz: {subkey: 'sub1', subkey2: 'sub2'}}
       proxy = HashProxy.create_from hash
-      proxy.to_json.should eq(hash.to_json)
+      expect(proxy.to_json).to eq(hash.to_json)
     end
     it "should work when normal value has been converted" do
       orig = {foo: 'bar', baz: {subkey: 'sub1', subkey2: 'sub2'}}
       hash = Marshal.load(Marshal.dump(orig))
       proxy = HashProxy.create_from hash
-      proxy.foo.should eq('bar')
+      expect(proxy.foo).to eq('bar')
       # Need to parse back to ruby arrays so we can use the ruby == operator
       # to compare
-      JSON.parse(proxy.to_json).should eq(JSON.parse(orig.to_json))
+      expect(JSON.parse(proxy.to_json)).to eq(JSON.parse(orig.to_json))
     end
     it "should work when nested value has been converted" do
       orig = {foo: 'bar', baz: {subkey: 'sub1', subkey2: 'sub2'}}
       hash = Marshal.load(Marshal.dump(orig))
       proxy = HashProxy.create_from hash
       proxy.baz.each do |key, val|
-        orig[:baz][key].should eq(val)
+        expect(orig[:baz][key]).to eq(val)
       end
       # Need to parse back to ruby arrays so we can use the ruby == operator
       # to compare
-      JSON.parse(proxy.to_json).should eq(JSON.parse(orig.to_json))
+      expect(JSON.parse(proxy.to_json)).to eq(JSON.parse(orig.to_json))
     end
   end
 
-  # TODO: Am I itching badly enough to make this pass? ....
+  # TODO: Am I itching badly enough).to make this pass? ....
   #it "should lazily handle nested arrays" do
   #  hash = {:foo => [{:key1 => 'val11', :key2 => 'val12'}, {:key1 => 'val21', :key2 => 'val22'}], :bar => :baz}
   #  proxy = HashProxy.create_from(hash)
-  #  proxy.foo.should eq([{:key1 => 'val11', :key2 => 'val12'}, {:key1 => 'val21', :key2 => 'val22'}])
+  #  expect(proxy.foo).to eq([{:key1 => 'val11', :key2 => 'val12'}, {:key1 => 'val21', :key2 => 'val22'}])
   #end
 
 end

data/version.txt

@@ -1 +1 @@
-0.1.5
+0.1.6

metadata

@@ -1,123 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: hash-proxy
 version: !ruby/object:Gem::Version
-  version: 0.1.5
-  prerelease: 
+  version: 0.1.7
 platform: ruby
 authors:
 - Douglas A. Seifert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2018-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 3.8.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
-- !ruby/object:Gem::Dependency
-  name: bones-rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.0.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.0.1
-- !ruby/object:Gem::Dependency
-  name: bones-git
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.3.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.3.0
-- !ruby/object:Gem::Dependency
-  name: bones-yard
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-- !ruby/object:Gem::Dependency
-  name: redcarpet
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.2.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.2.2
-- !ruby/object:Gem::Dependency
-  name: bones
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 3.8.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 3.8.0
-description: ! 'An object that proxies method calls to a Hash object as hash key lookups.
-
-  Handles nested hashes and arrays.'
+        version: 3.8.4
+description: |-
+  An object that proxies method calls to a Hash object as hash key lookups.
+  Handles nested hashes and arrays.
 email: doug@dseifert.net
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- History.txt
 files:
-- .bnsignore
-- .gitignore
-- .rvmrc
+- ".bnsignore"
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
 - Gemfile
 - Gemfile.lock
 - History.txt
@@ -131,29 +50,27 @@ files:
 - version.txt
 homepage: https://github.com/seifertd/hash-proxy
 licenses: []
+metadata: {}
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--main"
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4040495455569849470
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: hash-proxy
-rubygems_version: 1.8.24
+rubygems_version: 2.6.12
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: An object that proxies method calls to a Hash object as hash key lookups.
 test_files: []

data/.rvmrc

@@ -1 +0,0 @@
-rvm gemset use hash-proxy --create