hash-proxy 0.0.4 → 0.1.0

data/History.txt

@@ -1,3 +1,7 @@
+# == Version 0.1.0 / 2012-06-12
+# * include Enumerable in Proxy
+# * Add some hash-like semantics to Proxy
+#
 # == Version 0.0.4 / 2012-06-08
 # * Add #to_str to NullObject to avoid some rspec errors
 #

data/README.md

@@ -25,11 +25,20 @@ Features
 Examples
 --------
 
-    require 'hash-proxy'
+    require 'hash_proxy'
     hash = {foo: 'bar', baz: [{key: 'value', key2: 2, key3: [1,2,3]}, {key: 'value2', key2: 22, key3: [4,5,6]}], bip: 'bop'}
     proxy = HashProxy.create_from(hash)
     proxy.baz.last.key3.should == [4,5,6]
 
+Also supports hash like semantics:
+
+    proxy[:foo]    => 'bar'
+    proxy[:newkey] = 'new value'
+
+    proxy.each do |k, v|
+      puts "#{k}: #{v}"
+    end
+
 Requirements
 ------------
 

data/lib/hash_proxy/proxy.rb

@@ -5,6 +5,7 @@ module HashProxy
   # hash at the key corresponding to the message.  If the
   # key does not exist, returns a NullObject instance.
   class Proxy
+    include Enumerable
     # The one and only NullObject instance
     NO_OBJECT = NullObject.new
 
@@ -24,21 +25,67 @@ module HashProxy
       @converted = {}
     end
 
-    # The magic.  Turns arbitrary method invocations into
+    # Returns the number of values stored in the underlying hash
+    #
+    # @return [Integer]
+    def size
+      @hash.size + @converted.size
+    end
+
+    # Yields to the provided block all the values in this Hash proxy.  All values
+    # are converted via #convert_value as they are yielded.  The order in which
+    # values are yielded is not deterministic.  Insertion order in the original 
+    # hash may be lost if some values are already converted.
+    def each(&blk)
+      enum = Enumerator.new do |y|
+        @converted.each {|k, v| y.yield(k,v) }
+        @hash.each {|k,v| y.yield(k, self.move_value(k)) }
+      end
+      if blk.nil?
+        enum
+      else
+        enum.each do |k,v|
+          blk.call(k,v)
+        end
+      end
+    end
+
+    # Returns the converted value in the original
+    # hash associated with the given key
+    #
+    # @param [Object] key The value to look up
+    # @return [Object] The object associated with the key
+    def [](key)
+      self.send(key)
+    end
+
+    # Sets a value after converting it to a Proxy if necessary
+    #
+    # @param [Object] key The key of the value to set
+    # @param [Object] value The value to set
+    def []=(key, value)
+      self.send("#{key}=", value)
+    end
+
+    # Turns arbitrary method invocations into
     # lookups or sets on the contained hash
     def method_missing(name, *args)
       name_str = name.to_s
       if name_str.end_with?(EQUALS)
-        @converted[name_str[0..-2]] = convert_value(args.first)
+        # Handle edge case (self.send(:"=", 'foo') ? why would someone do this)
+        if name_str != EQUALS
+          @converted[name_str[0..-2].to_sym] = convert_value(args.first)
+        else
+          super
+        end
       else
-        # Move the value from the original hash to the converted hash.
-        # Support both symbol or string keys
-        if @converted.has_key?(name_str)
-          @converted[name_str]
+        # Return the value if it has already been converted
+        if @converted.has_key?(name)
+          @converted[name]
         else
-          unconverted = @hash.delete(name) || @hash.delete(name_str)
-          converted = convert_value(unconverted)
-          @converted[name_str] = converted
+          # Move the value from the original hash to the converted hash.
+          # Support both symbol or string keys
+          self.move_value(name, name_str)
         end
       end
     end
@@ -80,5 +127,13 @@ module HashProxy
         value || NO_OBJECT
       end
     end
+
+    # moves a value from the original hash to the converted
+    # hash after converting the value to a proxy if necessary
+    def move_value(name, name_str = name.to_s)
+      @converted[name] = self.convert_value(@hash.delete(name) || @hash.delete(name_str))
+    end
+
   end
+
 end

data/spec/hash_proxy_spec.rb

@@ -2,6 +2,39 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe HashProxy do
+  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']])
+
+    proxy.take(1).should 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')
+  end
+
+  it "can call setters" do
+    proxy = HashProxy::Proxy.new({})
+    proxy.foo = 'foo val'
+    proxy.bar = {:bip => :baz, :smoo => :smee}
+
+    proxy.size.should eq(2)
+    proxy[:bar].class.should eq(HashProxy::Proxy)
+  end
+
+  it "handles crappy method calls" do
+    proxy = HashProxy::Proxy.new({})
+    lambda { proxy.send(:'=', 'crap') }.should raise_error(NoMethodError)
+  end
+
   it "turns hash keys into method calls" do
     hash = {foo: 'bar', baz: 'bip'}
     proxy = HashProxy::Proxy.new(hash)

data/version.txt

@@ -1 +1 @@
-0.0.4
+0.1.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hash-proxy
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-08 00:00:00.000000000 Z
+date: 2012-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones