attribute_struct 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8589e76432a36f05a1450f97e802269ef8edb8df
-  data.tar.gz: 6364945c9d3ccb645eb54e2a419675a7d4f2ad61
+  metadata.gz: 902bf8b18675d998b37c3543ee77d343d7c37f8f
+  data.tar.gz: 29bf97732d4f10a3797a394e0fcc9bbcca228b35
 SHA512:
-  metadata.gz: 1bf46e3d433e2718593b6981303a88226b38aff6b421028d1b23f79fb7bdf765a7f800a2c0d35a4d33323f17f3a2a33f73b201d8aee88fec0b68aa1b4757d8b6
-  data.tar.gz: e26b766049f6bd19ba1b9e54bae280ae97372d5b438ee15bd1c44f97d8d20b2c802461a9f14721a3eaa98ee65f83f9a4a412fbe2faee590b4b980ff97aed05e1
+  metadata.gz: 4c2f5243ac8e3897820f3e9ed286ab4eca0c1b926c0d10fc05e8302f39f289220a81f5b76c4bc92b45c81f7c231026b286f045d759bfc4c903f5a5676c3c9f98
+  data.tar.gz: 42686aaa093b860aa884c8e1118ebe2841f6367ac96520ad2f966a851007b8c7bda03d7377dfc55ecd76197300e31bd45ec59bdff8f49392d817bfc377d6fc94

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.3.2
+* Update variable names within method_missing to prevent data collisions
+* Use constant for internal nil value
+* Check for internal nil value on set helper
+
 # v0.3.0
 * Only allow forced key processing when camel casing is enabled
 * Refactored dump implementation to better handle deeply nested structs

data/lib/attribute_struct/attribute_struct.rb

@@ -82,6 +82,9 @@ class AttributeStruct < BasicObject
 
   end
 
+  # value used to identify unset value
+  UNSET_VALUE = :__unset__
+
   # Specialized array for collapsing values
   class CollapseArray < ::Array; end
 
@@ -177,8 +180,8 @@ class AttributeStruct < BasicObject
   # @param val [Object]
   # @yield block to execute within context
   # @return [Object]
-  def _set(key, val=nil, &block)
-    if(val)
+  def _set(key, val=UNSET_VALUE, &block)
+    if(val != UNSET_VALUE)
       self.method_missing(key, val, &block)
     else
       self.method_missing(key, &block)
@@ -193,109 +196,109 @@ class AttributeStruct < BasicObject
   # @yield provided block
   # @return [Object] existing value or newly set value
   # @note Dragons and unicorns all over in here
-  def method_missing(sym, *args, &block)
-    if((s = sym.to_s).end_with?('='))
-      s.slice!(-1, s.length)
-      sym = s
+  def method_missing(_sym, *_args, &_block)
+    if((_s = _sym.to_s).end_with?('='))
+      _s.slice!(-1, _s.length)
+      _sym = _s
     end
-    sym = _process_key(sym)
-    if(!args.empty? || block)
-      if(args.empty? && block)
-        base = @table.fetch(sym, :__unset__)
-        if(_state(:value_collapse) && !base.is_a?(self.class!))
-          orig = base
-          base = _klass_new
+    _sym = _process_key(_sym)
+    if(!_args.empty? || _block)
+      if(_args.empty? && _block)
+        _base = @table.fetch(_sym, UNSET_VALUE)
+        if(_state(:value_collapse) && !_base.is_a?(self.class!))
+          _orig = _base
+          _base = _klass_new
         else
-          unless(base.is_a?(self.class!))
-            base = _klass_new
+          unless(_base.is_a?(self.class!))
+            _base = _klass_new
           end
         end
-        @table[sym] = base
-        if(block.arity == 0)
-          base.instance_exec(&block)
+        @table[_sym] = _base
+        if(_block.arity == 0)
+          _base.instance_exec(&_block)
         else
-          base.instance_exec(base, &block)
+          _base.instance_exec(_base, &_block)
         end
-        if(orig.is_a?(::NilClass))
-          @table[sym] = base
+        if(_orig.is_a?(::NilClass))
+          @table[_sym] = _base
         else
-          if(orig == :__unset__)
-            @table[sym] = base
+          if(_orig == UNSET_VALUE)
+            @table[_sym] = _base
           else
-            unless(orig.is_a?(CollapseArray))
-              orig = CollapseArray.new.push(orig)
+            unless(_orig.is_a?(CollapseArray))
+              _orig = CollapseArray.new.push(_orig)
             end
-            orig << base
-            @table[sym] = orig
+            _orig << _base
+            @table[_sym] = _orig
           end
         end
-      elsif(!args.empty? && block)
-        result = leaf = base = @table.fetch(sym, _klass_new)
-        @table[sym] = result
-
-        args.flatten.each do |arg|
-          leaf = base[arg]
-          unless(leaf.is_a?(_klass))
-            leaf = _klass_new
-            base._set(arg, leaf)
-            base = leaf
+      elsif(!_args.empty? && _block)
+        _result = _leaf = _base = @table.fetch(_sym, _klass_new)
+        @table[_sym] = _result
+
+        _args.flatten.each do |_arg|
+          _leaf = base[_arg]
+          unless(_leaf.is_a?(_klass))
+            _leaf = _klass_new
+            _base._set(_arg, _leaf)
+            _base = _leaf
           end
         end
-        if(!leaf.nil? && _state(:value_collapse))
-          orig = leaf
-          leaf = orig.parent._klass_new
+        if(!_leaf.nil? && _state(:value_collapse))
+          _orig = _leaf
+          _leaf = _orig.parent._klass_new
         end
-        block.arity == 0 ? leaf._build(&block) : leaf._build(leaf, &block)
-        if(orig)
-          unless(orig.is_a?(CollapseArray))
-            orig = CollapseArray.new.push(orig)
+        _block.arity == 0 ? _leaf._build(&_block) : _leaf._build(_leaf, &_block)
+        if(_orig)
+          unless(_orig.is_a?(CollapseArray))
+            _orig = CollapseArray.new.push(_orig)
           end
-          orig << leaf
+          _orig << _leaf
         else
-          orig = leaf
+          _orig = _leaf
         end
       else
-        if(args.size > 1 && args.all?{|i| i.is_a?(::String) || i.is_a?(::Symbol)} && !_state(:value_collapse))
-          @table[sym] = _klass_new unless @table[sym].is_a?(_klass)
-          endpoint = args.inject(@table[sym]) do |memo, k|
-            unless(memo[k].is_a?(_klass))
-              memo._set(k, _klass_new)
+        if(_args.size > 1 && _args.all?{|_i| _i.is_a?(::String) || _i.is_a?(::Symbol)} && !_state(:value_collapse))
+          @table[_sym] = _klass_new unless @table[_sym].is_a?(_klass)
+          _endpoint = _args.inject(@table[_sym]) do |_memo, _k|
+            unless(_memo[_k].is_a?(_klass))
+              _memo._set(_k, _klass_new)
             end
-            memo[k]
+            _memo[_k]
           end
-          return endpoint # custom break out
+          return _endpoint # custom break out
         else
-          if(args.size > 1)
-            val = args.map do |v|
-              if(v.is_a?(::Hash) && _state(:hash_load_struct))
-                val = _klass_new
-                val._load(v)
+          if(_args.size > 1)
+            _val = _args.map do |_v|
+              if(_v.is_a?(::Hash) && _state(:hash_load_struct))
+                _val = _klass_new
+                _val._load(_v)
               else
-                v
+                _v
               end
             end
           else
-            if(args.first.is_a?(::Hash) && _state(:hash_load_struct))
-              val = _klass_new
-              val._load(args.first)
+            if(_args.first.is_a?(::Hash) && _state(:hash_load_struct))
+              _val = _klass_new
+              _val._load(_args.first)
             else
-              val = args.first
+              _val = _args.first
             end
           end
-          if(_state(:value_collapse) && !(leaf = @table[sym]).nil?)
-            unless(leaf.is_a?(CollapseArray))
-              leaf = CollapseArray.new.push(leaf)
+          if(_state(:value_collapse) && !(_leaf = @table[_sym]).nil?)
+            unless(_leaf.is_a?(CollapseArray))
+              _leaf = CollapseArray.new.push(_leaf)
             end
-            leaf << val
-            @table[sym] = leaf
+            _leaf << _val
+            @table[_sym] = _leaf
           else
-            @table[sym] = val
+            @table[_sym] = _val
           end
         end
       end
     end
-    @table[sym] = _klass_new if @table[sym].nil? && !@table[sym].is_a?(_klass)
-    @table[sym]
+    @table[_sym] = _klass_new if @table[_sym].nil? && !@table[_sym].is_a?(_klass)
+    @table[_sym]
   end
 
   # @return [TrueClass, FalseClass] struct is nil (empty data)
@@ -359,7 +362,7 @@ class AttributeStruct < BasicObject
         ]
       end
     elsif(item.is_a?(::AttributeStruct))
-      item.nil? ? :__unset__ : item._dump
+      item.nil? ? UNSET_VALUE : item._dump
     else
       item
     end
@@ -370,7 +373,7 @@ class AttributeStruct < BasicObject
     processed = @table.keys.map do |key|
       value = @table[key]
       val = _dump_unpacker(value)
-      [_dump_unpacker(key), val] unless val == :__unset__
+      [_dump_unpacker(key), val] unless val == UNSET_VALUE
     end.compact
     __hashish[*processed.flatten(1)]
   end

data/lib/attribute_struct/version.rb

@@ -1,4 +1,4 @@
 class AttributeStruct < BasicObject
   # Current library version
-  VERSION = ::Gem::Version.new('0.3.0')
+  VERSION = ::Gem::Version.new('0.3.2')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attribute_struct
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-19 00:00:00.000000000 Z
+date: 2016-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo