attribute_struct 0.2.28 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41547b7309813fb1da48c6e17e0d063215d08963
-  data.tar.gz: 9ebfd315aab3eecc4a92d6a08c3276bddd9538ba
+  metadata.gz: 8589e76432a36f05a1450f97e802269ef8edb8df
+  data.tar.gz: 6364945c9d3ccb645eb54e2a419675a7d4f2ad61
 SHA512:
-  metadata.gz: bb2c29323b1d75a607f097d49e79e5f91649810ae7c066651c09cd890fbe6c0c0266df29930d16c8f8cd5887345dcb9169064cbeb3145d129ca6742590c7194f
-  data.tar.gz: bfd1e337210551aea3a1c090ba09b84431b44a1f90d0eaa88d6e25fbfa4412289b6af1400dfb95cb255661d5e17ab3154c0c0f06bc584086bd127da4444e30ab
+  metadata.gz: 1bf46e3d433e2718593b6981303a88226b38aff6b421028d1b23f79fb7bdf765a7f800a2c0d35a4d33323f17f3a2a33f73b201d8aee88fec0b68aa1b4757d8b6
+  data.tar.gz: e26b766049f6bd19ba1b9e54bae280ae97372d5b438ee15bd1c44f97d8d20b2c802461a9f14721a3eaa98ee65f83f9a4a412fbe2faee590b4b980ff97aed05e1

data/CHANGELOG.md

@@ -1,80 +1,85 @@
-## v0.2.28
+# v0.3.0
+* Only allow forced key processing when camel casing is enabled
+* Refactored dump implementation to better handle deeply nested structs
+* Add missing bang method aliases
+
+# v0.2.28
 * Set internal data at creation time, not after evaluation
 
-## v0.2.26
+# v0.2.26
 * Add support for lowercase leading camel casing
 
-## v0.2.24
+# v0.2.24
 * Fix `#_root` helper to properly check for parent
 * Always use the `#_klass_new` helper
 * Support optional arguments/block to `#_klass_new`
 
-## v0.2.22
+# v0.2.22
 * Add more helper method bang aliases
 * Properly persist camel data on Hash keys
 * Support optional automatic AttributeStruct loading on Hash set
 
-## v0.2.20
+# v0.2.20
 * Fix: remove nil structs
 
-## v0.2.18
+# v0.2.18
 * Fix `AttributeStruct#dump!` to properly handle nil-type values
 
-## v0.2.16
+# v0.2.16
 * Fix regression mixed argument and block set returning second level struct
 
-## v0.2.14
+# v0.2.14
 * Fix `:value_collapse` option to prevent multiple nestings
 
-## v0.2.12
+# v0.2.12
 * Implementation updates to monkey camels helper
 * Provide bang style helper methods for all helpers
 
-## v0.2.10
+# v0.2.10
 * Add support for multi parameter set
 
-## v0.2.8
+# v0.2.8
 * Fix class mismatch issue
 
-## v0.2.6
+# v0.2.6
 * Vendor `Mash` and expand to provide required deep_merge functionality
 * Remove external dependencies
 
-## v0.2.4
+# v0.2.4
 * Revert #class method removal (required by hash helpers when duping)
 * Set base prior to path walking
 * Initialize struct if nil is encountered
 * Collapse values at leaf
 
-## v0.2.2
+# v0.2.2
 * Update block evaluation assignment to prevent value knockout
 * Fix `#is_a?` behavior and include base class in check list
 * Add `#respond_to?` method
 * Add irb helper module
 
-## v0.2.0
+# v0.2.0
 * Add support for value setting into given context level
 * Add #build helper method
 * Introduce `:value_collapse` option for multi set combination instead of replacement
 * Provide bang suffix aliases
 
-## v0.1.8
+# v0.1.8
 * Basic (optional) auto camel detection on import
 * Add hash helper methods out to class
 
-## v0.1.6
+# v0.1.6
 * Add helpers for walking up the tree
 * Update hashie dependency restriction
 
-## v0.1.4
+# 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
+# v0.1.2
 * Fix naming in require
 
-## v0.1.0
+# v0.1.0
 * Initial release

data/LICENSE

@@ -1,4 +1,4 @@
-   Copyright 2014 Chris Roberts
+   Copyright 2016 Chris Roberts
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.md

@@ -1,66 +1,256 @@
 # AttributeStruct
 
-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.
+AttributeStruct is a DSL helper library. It provides support for programmatic
+generation of complex data structures.
 
-## Build Status
+## How it works
 
-* [![Build Status](https://api.travis-ci.org/chrisroberts/attribute_struct.png)](https://travis-ci.org/chrisroberts/attribute_struct)
+Under the hood, AttributeStruct makes use of Ruby's `BasicObject` class and the
+`#method_missing` method to bring a clean and concise way of generating data
+structures. Deeply nested Hashes can be built using method chaining, block
+structures, or both. Evaluation of a structure is performed top down, allowing
+access to previously set data values within the structure during evaluation.
 
-## Usage
+## Examples
+
+### Setting values
+
+#### Method chaining
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a.deeply.nested.hash true
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"hash"=>true}}}}}}
+```
+
+#### Block nesting
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this do
+    is do
+      a do
+        deeply do
+          nested do
+            hash true
+          end
+        end
+      end
+    end
+  end
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"hash"=>true}}}}}}
+```
+
+#### Mixed block nesting and method chaining
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a do
+    deeply.nested do
+      hash true
+    end
+  end
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"hash"=>true}}}}}}
+```
+
+### Structure re-entry
+
+#### Block re-entry
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a do
+    deeply.nested do
+      hash true
+    end
+    deeply do
+      nested.other_hash true
+    end
+  end
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"hash"=>true,"other_hash"=>true}}}}}}
+```
+
+#### Method re-entry
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a do
+    deeply.nested do
+      hash true
+    end
+  end
+  this.is.a.deeply.nested.other_hash true
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"hash"=>true,"other_hash"=>true}}}}}}
+```
+
+### Data removal
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a do
+    deeply.nested do
+      hash true
+    end
+  end
+  this.is.a.deeply.nested.other_hash true
+  this.is.a.deeply.nested.delete!(:hash)
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"other_hash"=>true}}}}}}
+```
+
+### Data Access
+
+#### Current data
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a do
+    deeply.nested do
+      hash 'my_value'
+    end
+  end
+  this.is.a.deeply.nested do
+    other_hash data![:hash]
+  end
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"hash"=>"my_value","other_hash"=>"my_value"}}}}}}
+```
+
+#### Current data keys
 
 ```ruby
 require 'attribute_struct'
 
-struct = AttributeStruct.new
-struct.settings do
-  ui.admin do
-    enabled true
-    port 8080
-    bind '*'
+AttributeStruct.new do
+  this.is.a do
+    deeply.nested do
+      hash 'my_value'
+    end
   end
-  ui.public do
-    enabled true
-    port 80
-    bind '*'
+  this.is.a.deeply.nested do
+    other_hash keys!
   end
-  client('general') do
-    enabled false
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nested"=>{"hash"=>"my_value","other_hash"=>["hash"]}}}}}}
+```
+
+### Hierarchy access
+
+#### Parent structure
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a do
+    deeply do
+      state 'sunny'
+      nested do
+        hash parent!.state
+      end
+    end
   end
-end
+end.dump!
+
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"state"=>"sunny", "nested"=>{"hash"=>"sunny"}}}}}}
 ```
 
-Now we have an attribute structure that we can
-query and modify. To force it to a hash, we
-can simply dump it:
+#### Root structure
 
 ```ruby
-require 'pp'
+require 'attribute_struct'
+
+AttributeStruct.new do
+  this.is.a do
+    deeply do
+      state 'sunny'
+      nested do
+        hash root!.this.is.a.deeply.state
+      end
+    end
+  end
+end.dump!
 
-pp struct._dump
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"state"=>"sunny", "nested"=>{"hash"=>"sunny"}}}}}}
 ```
 
-which gives:
+### Camel case
+
+#### Camel case keys
 
 ```ruby
-{"settings"=>
-  {"ui"=>
-    {"admin"=>{"enabled"=>true, "port"=>8080, "bind"=>"*"},
-     "public"=>{"enabled"=>true, "port"=>80, "bind"=>"*"}},
-   "client"=>{"general"=>{"enabled"=>false}}}}
+require 'attribute_struct'
+
+AttributeStruct.new do
+  self._camel_keys = true
+  this.is.a.deeply.nested_camel.hash true
+end.dump!
+
+# => {"This"=>{"Is"=>{"A"=>{"Deeply"=>{"NestedCamel"=>{"Hash"=>true}}}}}}
 ```
 
-## IRB
+#### Camel case with lead lower
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  self._camel_keys = true
+  self._camel_style = :no_leading
+  this.is.a.deeply.nested_camel.hash true
+end.dump!
 
-IRB expects some things to be around like `#inspect` and `#to_s`. Before
-using `AttributeStruct` in IRB, enable compat mode:
+# => {"this"=>{"is"=>{"a"=>{"deeply"=>{"nestedCamel"=>{"hash"=>true}}}}}}
+```
+
+#### Disable camel on individual key
 
 ```ruby
-> require 'attribute_struct'
-> AttributeStruct.irb_compat!
+require 'attribute_struct'
+
+AttributeStruct.new do
+  self._camel_keys = true
+  this.is.a.deeply.nested_camel.hash true
+  this.set!('horse'.no_hump!, true)
+end.dump!
+
+# => {"This"=>{"Is"=>{"A"=>{"Deeply"=>{"NestedCamel"=>{"Hash"=>true}}}}},"horse" => true}
 ```
 
+## In the wild
+
+Libraries utilizing AttributeStruct:
+
+* SparkleFormation: http://www.sparkleformation.io
+* Bogo Config: https://github.com/spox/bogo-config
+
 ## Information
 
 * Repo: https://github.com/chrisroberts/attribute_struct

data/lib/attribute_struct/attribute_struct.rb

@@ -8,7 +8,7 @@ class AttributeStruct < BasicObject
 
     # @return [Hash] valid styles and mapped value
     VALID_CAMEL_STYLES = {
-      :bactrain => :no_leading,
+      :bactrian => :no_leading,
       :no_leading_hump => :no_leading,
       :no_leading => :no_leading,
       :dromedary => :leading,
@@ -87,10 +87,13 @@ class AttributeStruct < BasicObject
 
   # @return [Truthy, Falsey] current camelizing setting
   attr_reader :_camel_keys
+  alias_method :camel_keys!, :_camel_keys
   # @return [Symbol] current camel style
   attr_reader :_camel_style
+  alias_method :camel_style!, :_camel_style
   # @return [AtributeStruct::AttributeHash, Mash] holding space for state
   attr_reader :_arg_state
+  alias_method :arg_state!, :_arg_state
 
   # Create new instance
   #
@@ -300,6 +303,11 @@ class AttributeStruct < BasicObject
     _data.empty?
   end
 
+  # @return [TrueClass, FalseClass] struct is present (not empty)
+  def present?
+    !nil?
+  end
+
   # Determine if self is a class
   #
   # @param klass [Class]
@@ -330,22 +338,39 @@ class AttributeStruct < BasicObject
   end
   alias_method :delete!, :_delete
 
-  # @return [AttributeStruct::AttributeHash, Mash] dump struct to hashish
-  def _dump
-    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) && value.nil?)
-        next
-      elsif(value.is_a?(_klass) && !value.nil?)
-        val = value._dump
+  # Process and unpack items for dumping within deeply nested
+  # enumerable types
+  #
+  # @param item [Object]
+  # @return [Object]
+  def _dump_unpacker(item)
+    if(item.is_a?(::Enumerable))
+      if(item.respond_to?(:keys))
+        item.class[
+          *item.map do |entry|
+            _dump_unpacker(entry)
+          end.flatten(1)
+        ]
       else
-        val = value.nil? ? nil : value
+        item.class[
+          *item.map do |entry|
+            _dump_unpacker(entry)
+          end
+        ]
       end
-      [key, val]
+    elsif(item.is_a?(::AttributeStruct))
+      item.nil? ? :__unset__ : item._dump
+    else
+      item
+    end
+  end
+
+  # @return [AttributeStruct::AttributeHash, Mash] dump struct to hashish
+  def _dump
+    processed = @table.keys.map do |key|
+      value = @table[key]
+      val = _dump_unpacker(value)
+      [_dump_unpacker(key), val] unless val == :__unset__
     end.compact
     __hashish[*processed.flatten(1)]
   end
@@ -453,7 +478,7 @@ class AttributeStruct < BasicObject
         key._hump
       end
     end
-    if((_camel_keys && key._camel?) || args.include?(:force))
+    if(_camel_keys && (key._camel? || args.include?(:force)))
       camel_args = [key]
       if(key._hump_style || _camel_style == :no_leading)
         unless(key._hump_style == :leading_hump)

data/lib/attribute_struct/monkey_camels.rb

@@ -73,13 +73,13 @@ unless(defined?(MonkeyCamels))
       # Set hump style to non-leading upcase
       #
       # @return [self]
-      def _bactrain
+      def _bactrian
         @__not_camel = false
         @__hump_style = :no_leading_hump
         self
       end
-      alias_method :bactrain!, :_bactrain
-      alias_method :no_leading_hump!, :_bactrain
+      alias_method :bactrian!, :_bactrian
+      alias_method :no_leading_hump!, :_bactrian
 
       # Set hump style to leading upcase
       #

data/lib/attribute_struct/version.rb

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

metadata

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