fancy-open-struct 0.3.0 → 0.4.0

data/.travis.yml

@@ -8,4 +8,3 @@ rvm:
 
   # Rubies 1.9.x
   - 1.9.3
-  - jruby-19mode # JRuby in 1.9 mode

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.4.0
+  - Changed ostruct methods (new_ostruct_member, recurse_over_array) so that they are private
+  - Overhauled the caching sub-system and how values are set and retrieved to fix a bug with values not updating
+
 0.3.0
   - Deprecated the display_recursive_open_hash alias for debug_inspect
   - Removed some unnecessary code from the to_h method

data/lib/fancy-open-struct.rb

@@ -22,43 +22,14 @@ class FancyOpenStruct < OpenStruct
     @sub_elements = {}
   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 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
+        newval
       end
     end
   end
@@ -73,17 +44,66 @@ class FancyOpenStruct < OpenStruct
 
   # Hash getter method which translates the key to a Symbol
   def [](key)
-    @table[key.to_sym]
+    key = key.to_sym unless key.kind_of? Symbol
+    @table[key]
   end
 
   # Hash setter method which translates the key to a Symbol and also creates
   # a getter method (OpenStruct member) for accessing the key/value later via dot syntax
   def []=(key, value)
-    modifiable[new_ostruct_member(key.to_sym)] = value
+    key = key.to_sym unless key.kind_of? Symbol
+    modifiable[new_ostruct_member(key)] = value
+    build_sub_elements_key_cache(key)
   end
 
   private
 
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless self.respond_to?(name)
+      define_singleton_method name do
+        value = @table[name]
+        if value.is_a?(Hash)
+          @sub_elements[name] ||= self.class.new(value, :recurse_over_arrays => @recurse_over_arrays)
+        elsif value.is_a?(Array) and @recurse_over_arrays
+          @sub_elements[name] ||= recurse_over_array value
+        else
+          value
+        end
+      end
+      define_singleton_method("#{name}=") do |x|
+        modifiable[name] = x
+        build_sub_elements_key_cache(name)
+      end
+      define_singleton_method("#{name}_as_a_hash") { @table[name] }
+    end
+    name
+  end
+
+  def build_sub_elements_key_cache(name)
+    value = @table[name]
+    if value.is_a?(Hash)
+      @sub_elements[name] = self.class.new(value, :recurse_over_arrays => @recurse_over_arrays)
+    elsif value.is_a?(Array) and @recurse_over_arrays
+      @sub_elements[name] = recurse_over_array value
+    else
+      @sub_elements[name] = value
+    end
+    @sub_elements[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
+
   # Dynamically handle any attempts to get or set values via dot syntax
   # if the OpenStruct member methods haven't already been created
   def method_missing(mid, *args) # :nodoc:
@@ -93,10 +113,13 @@ class FancyOpenStruct < OpenStruct
       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]
+      build_sub_elements_key_cache(mname.to_sym)
+      @table[mname.to_sym]
     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)
+      build_sub_elements_key_cache(mname.to_sym)
       self.send(mid)
     else
       nil

data/lib/fancy-open-struct/version.rb

@@ -1,5 +1,5 @@
 require 'ostruct'
 
 class FancyOpenStruct < OpenStruct
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/fancy_open_struct_spec.rb

@@ -127,6 +127,18 @@ describe FancyOpenStruct do
         fos.to_h.should == {:blah => "John Smith"}
         fos[:blah].should == "John Smith"
       end
+
+      it 'lets you access keys via strings or symbols' do
+        h = {'blah' => 'John Smith'}
+        fos = FancyOpenStruct.new(h)
+        fos.to_h.should == {:blah => "John Smith"}
+        fos['blah'].should == "John Smith"
+        fos['foo'] = 'bar'
+        fos.foo.should == 'bar'
+        fos[:foo].should == 'bar'
+        fos['foo'].should == 'bar'
+        fos.to_h.should == {:blah => "John Smith", :foo => 'bar'}
+      end
     end
   end
 
@@ -216,6 +228,32 @@ describe FancyOpenStruct do
             subject.foo.blah[1].foo.should == "Dr Scott"
           end
 
+          it 'recurses and updates both shallow and deep values if they are changed' do
+            fos = FancyOpenStruct.new({}, :recurse_over_arrays => true)
+            deep_array_hash = [
+                {
+                    :foo =>
+                        {:bar => :baz}
+                },
+                {
+                    :qux => [
+                        {:zap => :zam}, {:zip => :boop}
+                    ]
+                }
+            ]
+            fos.bar = deep_array_hash
+            fos.bar[0].foo.bar.should == :baz
+            fos.bar[1].qux[0].zap.should == :zam
+            fos.bar[1].qux[0].zap = :changed1
+            fos.bar[1].qux[0].zap.should == :changed1
+            fos.bar[1].qux[1].zip.should == :boop
+            fos.bar[1].qux[1].zip = :changed2
+            fos.bar[1].qux[1].zip.should == :changed2
+            fos.bar = {:qux_new => [{:zap => :zam}, {:zip => :boop}]}
+            fos.bar.qux.should be_nil
+            fos.bar.qux_new[0].zap.should == :zam
+            fos.bar.qux_new[1].zip.should == :boop
+          end
         end
 
         context "when array is in an array" do
@@ -285,6 +323,13 @@ describe FancyOpenStruct do
       fossc.one.first.class.should == FancyOpenStructSubClass
     end
 
+    it 'returns nil for missing keys' do
+      fos = FancyOpenStruct.new {}
+      fos.foo.should be_nil
+      fos['bar'].should be_nil
+      fos[:baz].should be_nil
+    end
+
     describe 'method aliases' do
       it 'responds to #to_hash' do
         FancyOpenStruct.new.respond_to?(:to_hash).should be_true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fancy-open-struct
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors: