attribute_struct 0.1.2 → 0.1.4

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## v0.1.4
+* Add `_array` helper
+* Ensure all helpers are using underscore prefix
+* Inherit from BasicObject
+* Allow struct discovery in enumerable objects
+* Add more helpers
+
 ## v0.1.2
 * Fix naming in require
 

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'minitest'
+
 gemspec

data/Gemfile.lock

@@ -1,16 +1,18 @@
 PATH
   remote: .
   specs:
-    attribute_struct (0.1.0)
+    attribute_struct (0.1.3)
       hashie (~> 2.0.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
     hashie (2.0.5)
+    minitest (5.0.6)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   attribute_struct!
+  minitest

data/README.md

@@ -4,6 +4,10 @@ This is a helper library that essentially builds hashes. It
 wraps hash building with a nice DSL to make it slightly cleaner,
 more robust, and provide extra features.
 
+## Build Status
+
+* [![Build Status](https://api.travis-ci.org/chrisroberts/attribute_struct.png)](https://travis-ci.org/chrisroberts/attribute_struct)
+
 ### Usage
 
 ```ruby

data/lib/attribute_struct.rb

@@ -1,2 +1,2 @@
 require 'attribute_struct/version'
-require 'attribute_struct/attribute_struct'
+

data/lib/attribute_struct/attribute_hash.rb

@@ -2,8 +2,8 @@ require 'hashie/extensions/deep_merge'
 require 'hashie/extensions/indifferent_access'
 
 class AttributeStruct
-  class AttributeHash < Hash
-    include Hashie::Extensions::DeepMerge
-    include Hashie::Extensions::IndifferentAccess
+  class AttributeHash < ::Hash
+    include ::Hashie::Extensions::DeepMerge
+    include ::Hashie::Extensions::IndifferentAccess
   end
 end

data/lib/attribute_struct/attribute_struct.rb

@@ -1,15 +1,20 @@
-class AttributeStruct
+class AttributeStruct < BasicObject
   
   class << self
-    
+
+    # Global flag for camel cased keys
     attr_reader :camel_keys
+    # Force tooling from Chef
     attr_accessor :force_chef
 
+    # val:: bool
+    # Automatically converts keys to camel case
     def camel_keys=(val)
       load_the_camels if val
       @camel_keys = !!val
     end
 
+    # Loads helpers for camel casing
     def load_the_camels
       unless(@camels_loaded)
         require 'attribute_struct/monkey_camels'
@@ -17,6 +22,7 @@ class AttributeStruct
       end
     end
 
+    # Determines what hash library to load based on availability
     def load_the_hash
       unless(@hash_loaded)
         if(defined?(Chef) || force_chef)
@@ -25,34 +31,46 @@ class AttributeStruct
         else
           require 'attribute_struct/attribute_hash'
         end
-        @hash_loaded
+        @hash_loaded = true
       end
     end
 
   end
 
+  # Flag for camel cased keys
   attr_reader :_camel_keys
   
   def initialize(*args, &block)
-    self.class.load_the_hash
-    @_camel_keys = self.class.camel_keys
+    _klass.load_the_hash
+    @_camel_keys = _klass.camel_keys
     @table = __hashish.new
     unless(args.empty?)
-      if(args.size == 1 && args.first.is_a?(Hash))
+      if(args.size == 1 && args.first.is_a?(::Hash))
         _load(args.first)
       end
     end
+    if(block)
+      self.instance_exec(&block)
+    end
   end
 
+  # val:: bool
+  # Turn camel cased keys on/off
   def _camel_keys=(val)
-    self.class.load_the_camels if val
+    _klass.load_the_camels if val
     @_camel_keys = !!val
   end
-  
+
+  # key:: Object
+  # Access data directly
   def [](key)
     _data[_process_key(key)]
   end
 
+  # key:: Object
+  # val:: Object
+  # Directly set val into struct. Useful when key is not valid syntax
+  # for a ruby method
   def _set(key, val=nil, &block)
     if(val)
       self.method_missing(key, val, &block)
@@ -60,14 +78,15 @@ class AttributeStruct
       self.method_missing(key, &block)
     end
   end
-  
+
+  # 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
     end
     sym = _process_key(sym)
-    @table[sym] ||= AttributeStruct.new
+    @table[sym] ||= _klass_new
     if(!args.empty? || block)
       if(args.empty? && block)
         base = @table[sym]
@@ -79,13 +98,13 @@ class AttributeStruct
         @table[sym] = base
       elsif(!args.empty? && block)
         base = @table[sym]
-        base = self.class.new unless base.is_a?(self.class)
+        base = _klass_new unless base.is_a?(_klass)
         @table[sym] = base
         leaf = base
         args.each do |arg|
           leaf = base[arg]
-          unless(leaf.is_a?(self.class))
-            leaf = self.class.new
+          unless(leaf.is_a?(_klass))
+            leaf = _klass_new
             base._set(arg, leaf)
             base = leaf
           end
@@ -96,36 +115,81 @@ class AttributeStruct
           leaf.instance_exec(leaf, &block)
         end
       else
-        @table[sym] = args.first
+        if(args.size > 1)
+          @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]
+          end
+          return endpoint # custom break out
+        else
+          @table[sym] = args.first
+        end
       end
     end
     @table[sym]
   end
 
+  # Returns if this struct is considered nil (empty data)
   def nil?
     _data.empty?
   end
 
+  # klass:: Class
+  # Returns if this struct is a klass
+  def is_a?(klass)
+    klass.ancestors.include?(_klass)
+  end
+  alias_method :kind_of?, :is_a?
+
+  # Returns current keys within struct
   def _keys
     _data.keys
   end
-  
+
+  # Returns underlying data hash
   def _data
     @table
   end
 
+  # key:: Object
+  # Delete entry in struct with key
+  def _delete(key)
+    _data.delete(_process_key(key))
+  end
+
+  # Dumps the current instance to a Hash
   def _dump
-    __hashish[
-      *(@table.map{|key, value|
-          [key, value.is_a?(self.class) ? value._dump : value]
-        }.flatten(1))
-    ]
+    processed = @table.map do |key, value|
+      if(value.is_a?(::Enumerable))
+        flat = value.map do |v|
+          v.is_a?(_klass) ? v._dump : v
+        end
+        val = value.is_a?(::Hash) ? __hashish[*flat.flatten(1)] : flat
+      elsif(value.is_a?(_klass))
+        val = value._dump
+      else
+        val = value
+      end
+      [key, val]
+    end
+    __hashish[*processed.flatten(1)]
   end
 
+  # hashish:: Hash type object
+  # Clears current instance data and replaces with provided hash
   def _load(hashish)
     @table.clear
     hashish.each do |key, value|
-      if(value.is_a?(Hash))
+      if(value.is_a?(::Enumerable))
+        flat = value.map do |v|
+          v.is_a?(::Hash) ? _klass.new(v) : v
+        end
+        value = value.is_a?(::Hash) ? __hashish[*flat.flatten(1)] : flat
+      end
+      if(value.is_a?(::Hash))
         self._set(key)._load(value)
       else
         self._set(key, value)
@@ -134,60 +198,124 @@ class AttributeStruct
     self
   end
 
+  # target:: AttributeStruct
+  # Performs a deep merge and returns the resulting AttributeStruct
   def _merge(target)
-    source = deep_copy
-    dest = target.deep_copy
-    if(defined?(Mash))
-      result = Chef::Mixin::DeepMerge.merge(source, dest)
+    source = _deep_copy
+    dest = target._deep_copy
+    if(defined?(::Mash))
+      result = ::Chef::Mixin::DeepMerge.merge(source, dest)
     else
       result = source.deep_merge(dest)
     end
-    AttributeStruct.new(result)
+    _klass.new(result)
   end
 
+  # target:: AttributeStruct
+  # Performs a deep merge and updates the current instance with the
+  # resulting value
   def _merge!(target)
     result = _merge(target)._dump
     _load(result)
     self
   end
-  
+
+  # Returns a new Hash type instance based on what is available
   def __hashish
-    defined?(Mash) ? Mash : AttributeHash
+    defined?(::Mash) ? ::Mash : ::AttributeStruct::AttributeHash
   end
-  
-  def do_dup(v)
+
+  # Returns dup of value. Converts Symbol objects to strings
+  def _do_dup(v)
     begin
       v.dup
     rescue
-      v.is_a?(Symbol) ? v.to_s : v
+      v.is_a?(::Symbol) ? v.to_s : v
     end
   end
 
-  def deep_copy(thing=nil)
+  # thing:: Object
+  # Returns a proper deep copy
+  def _deep_copy(thing=nil)
     thing ||= _dump
-    if(thing.is_a?(Enumerable))
-      val = thing.map{|v| v.is_a?(Enumerable) ? deep_copy(v) : do_dup(v) }
+    if(thing.is_a?(::Enumerable))
+      val = thing.map{|v| v.is_a?(::Enumerable) ? _deep_copy(v) : _do_dup(v) }
     else
-      val = do_dup(thing)
+      val = _do_dup(thing)
     end
-    if(thing.is_a?(Hash))
+    if(thing.is_a?(::Hash))
       val = __hashish[*val.flatten(1)]
     end
     val
   end
 
-  def _process_key(key)
+  # key:: String or Symbol
+  # Processes the key and returns value based on current settings
+  def _process_key(key, *args)
     key = key.to_s
-    if(_camel_keys && key._camel?)
+    if(_camel_keys && _camel_keys_action)
+      case _camel_keys_action
+      when :auto_disable
+        key._no_hump
+      when :auto_enable
+        key._hump
+      end
+    end
+    if((_camel_keys && key._camel?) || args.include?(:force))
       key.to_s.split('_').map do |part|
         "#{part[0,1].upcase}#{part[1,part.size]}"
       end.join.to_sym
     else
       if(_camel_keys)
         # Convert so Hash doesn't make a new one and lose the meta
-        key = CamelString.new(key) unless key.is_a?(CamelString)
+        key = ::CamelString.new(key) unless key.is_a?(::CamelString)
       end
       key
     end
   end
+
+  # Helper to return class of current instance
+  def _klass
+    ::AttributeStruct
+  end
+  alias_method :class, :_klass
+
+  # Helper to return new instance of current instance type
+  def _klass_new
+    n = _klass.new
+    n._camel_keys_set(_camel_keys_action)
+    n
+  end
+
+  # v:: Symbol (:auto_disable, :auto_enable)
+  # Sets custom rule for processed keys
+  def _camel_keys_set(v)
+    @_camel_keys_set = v
+  end
+
+  # Returns value set via #_camel_keys_set
+  def _camel_keys_action
+    @_camel_keys_set
+  end
+
+  # args:: Objects
+  # Helper to create Arrays with nested AttributeStructs. Proc
+  # instances are automatically executed into new AttributeStruct
+  # instances
+  def _array(*args)
+    args.map do |maybe_block|
+      if(maybe_block.is_a?(::Proc))
+        klass = _klass_new
+        if(maybe_block.arity > 0)
+          klass.instance_exec(klass, &maybe_block)
+        else
+          klass.instance_exec(&maybe_block)
+        end
+        klass
+      else
+        maybe_block
+      end
+    end
+  end
+  
 end

data/lib/attribute_struct/version.rb

@@ -1,6 +1,8 @@
+require 'attribute_struct/attribute_struct'
+
 class AttributeStruct
-  class Version < Gem::Version
+  class Version < ::Gem::Version
   end
 
-  VERSION = Version.new('0.1.2')
+  VERSION = Version.new('0.1.4')
 end

data/test/spec.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'specs/*.rb')).each do |path|
+  require path
+end

data/test/specs/basic.rb

@@ -0,0 +1,169 @@
+require 'minitest/autorun'
+
+describe AttributeStruct do
+  describe 'Basic usage' do
+    describe 'instance based population' do
+      before do
+        @struct = AttributeStruct.new
+        @struct.method.based.access true
+        @struct.method('and', 'parameter', 'based').access true
+        @struct.block do
+          based.access true
+        end
+        @struct.block('and', 'parameter', 'based') do
+          access true
+        end
+        @struct.block_only do
+          access true
+        end
+        @struct._set('1') do
+          value true
+        end
+      end
+
+      it 'allows method based access' do
+        @struct.method.based.access.must_equal true
+      end
+
+      it 'allows method and parameter based access' do
+        @struct.method.and.parameter.based.access.must_equal true
+      end
+
+      it 'allows block based access' do
+        @struct.block.based.access.must_equal true
+      end
+
+      it 'allows block and parameter based access' do
+        @struct.block.and.parameters.based.access.must_equal true
+      end
+
+      it 'allows block only access' do
+        @struct.block_only.access.must_equal true
+      end
+
+      it 'allows hash style access' do
+        @struct['method'][:based].access.must_equal true
+      end
+
+      it 'allows _set for invalid method names' do
+        @struct['1'].value.must_equal true
+      end
+    end
+
+    describe 'block based creation' do
+      before do
+        @struct = AttributeStruct.new do
+          enable true
+          access.user true
+          access do
+            port 80
+            transport :udp
+          end
+        end
+      end
+
+      it 'creates struct with block content' do
+        @struct.enable.must_equal true
+        @struct.access.user.must_equal true
+        @struct.access.port.must_equal 80
+        @struct.access.transport.must_equal :udp
+      end
+
+    end
+
+    describe 'nil behavior' do
+      before do
+        @struct = AttributeStruct.new
+      end
+
+      it 'should return as nil' do
+        @struct.must_be_nil
+      end
+    end
+    
+    describe 'array helper' do
+      before do
+        @struct = AttributeStruct.new do
+          my_array _array(
+            -> {
+              working true
+            },
+            :item
+          )
+        end
+      end
+
+      it 'should contain an array at my_array' do
+        @struct.my_array.must_be_kind_of Array
+      end
+
+      it 'should contain symbol in array' do
+        @struct.my_array.must_include :item
+      end
+
+      it 'should contain an AttrubuteStruct instance in array' do
+        assert @struct.my_array.detect{|i| i.is_a?(AttributeStruct)}
+      end
+
+      it 'should contain working attribute in array struct' do
+        @struct.my_array.detect{|i| i.is_a?(AttributeStruct)}.working.must_equal true
+      end
+    end
+
+    describe 'entry deletion' do
+      before do
+        @struct = AttributeStruct.new do
+          value1 true
+          value2 true
+        end
+        @struct._delete(:value2)
+      end
+
+      it 'should contain value1' do
+        @struct.value1.must_equal true
+      end
+
+      it 'should not contain value2 in keys' do
+        @struct._keys.wont_include 'value2'
+      end
+
+      it 'should report nil for value2' do
+        @struct.value2.must_be_nil
+      end
+    end
+
+    describe 'dumps' do
+      before do
+        @struct = AttributeStruct.new do
+          value1 true
+          value2 do
+            nested true
+          end
+        end
+      end
+
+      it 'should dump to a hash type value' do
+        @struct._dump.must_be_kind_of Hash
+      end
+
+      it 'should include all defined values' do
+        dump = @struct._dump
+        dump['value1'].must_equal true
+        dump['value2'].must_be_kind_of Hash
+        dump['value2']['nested'].must_equal true
+      end
+    end
+
+    describe 'loads' do
+      before do
+        @hash = {'value1' => true, 'value2' => {'nested' => true}}
+        @struct = AttributeStruct.new(@hash)
+      end
+
+      it 'should include all values defined in hash' do
+        @struct.value1.must_equal true
+        @struct.value2.nested.must_equal true
+      end
+    end
+  end
+end

data/test/specs/camel.rb

@@ -0,0 +1,43 @@
+require 'minitest/autorun'
+
+describe AttributeStruct do
+  describe 'Camel usage' do
+    before do
+      AttributeStruct.camel_keys = true
+      @struct = AttributeStruct.new do
+        value_one true
+        value_two do
+          nesting true
+        end
+      end
+    end
+    after do
+      AttributeStruct.camel_keys = false
+    end
+
+    it 'should camel case keys when dumped' do
+      @struct._dump.keys.must_include 'ValueOne'
+      @struct._dump.keys.must_include 'ValueTwo'
+    end
+
+    it 'should allow explicit disable on keys' do
+      @struct._set('not_camel'._no_hump, true)
+      @struct._dump.keys.must_include 'not_camel'
+    end
+
+    it 'should allow implicit disable on nested structs' do
+      @struct.disable_camel do |struct|
+        struct._camel_keys_set(:auto_disable)
+        not_camel true
+        not_camel_nest do
+          no_camel_here true
+        end
+      end
+      dump = @struct._dump
+      dump['DisableCamel'][:not_camel].must_equal true
+      dump['DisableCamel'][:not_camel_nest][:no_camel_here].must_equal true
+      dump['ValueOne'].must_equal true
+      dump['ValueTwo']['Nesting'].must_equal true
+    end
+  end
+end

data/test/specs/merging.rb

@@ -0,0 +1,55 @@
+require 'minitest/autorun'
+
+describe AttributeStruct do
+  describe 'Merging usage' do
+    before do
+      @struct1 = AttributeStruct.new do
+        value1 true
+        value2 do
+          nesting true
+        end
+      end
+      @struct2 = AttributeStruct.new do
+        value2 do
+          nesting false
+          squashing true
+        end
+      end
+    end
+
+    describe 'new struct from merge' do
+      before do
+        @struct = @struct1._merge(@struct2)
+      end
+
+      it 'should have correct value for value1' do
+        @struct.value1.must_equal true
+      end
+
+      it 'should have correct value for squashing' do
+        @struct.value2.squashing.must_equal true
+      end
+
+      it 'should have correct value for nesting' do
+        @struct.value2.nesting.must_equal false
+      end
+    end
+
+    describe 'update struct from merge' do
+      before do
+        @struct = AttributeStruct.new do
+          test_value true
+        end
+        @struct._merge!(@struct1)
+      end
+
+      it 'should contain test_value' do
+        @struct.test_value.must_equal true
+      end
+
+      it 'should contain value1' do
+        @struct.value1.must_equal true
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attribute_struct
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-08 00:00:00.000000000 Z
+date: 2013-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -38,9 +38,12 @@ files:
 - lib/attribute_struct/version.rb
 - lib/attribute_struct/attribute_hash.rb
 - lib/attribute_struct/monkey_camels.rb
+- test/spec.rb
+- test/specs/camel.rb
+- test/specs/merging.rb
+- test/specs/basic.rb
 - Gemfile
 - README.md
-- attribute_struct-0.1.0.gem
 - attribute_struct.gemspec
 - CHANGELOG.md
 - Gemfile.lock