attribute_struct 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.1.0
+* Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

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

data/README.md

@@ -0,0 +1,52 @@
+## 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.
+
+### Usage
+
+```ruby
+require 'attribute_struct'
+
+struct = AttributeStruct.new
+struct.settings do
+  ui.admin do
+    enabled true
+    port 8080
+    bind '*'
+  end
+  ui.public do
+    enabled true
+    port 80
+    bind '*'
+  end
+  client('general') do
+    enabled false
+  end
+end
+```
+
+Now we have an attribute structure that we can
+query and modify. To force it to a hash, we
+can simply dump it:
+
+```ruby
+require 'pp'
+
+pp struct._dump
+```
+
+which gives:
+
+```ruby
+{"settings"=>
+  {"ui"=>
+    {"admin"=>{"enabled"=>true, "port"=>8080, "bind"=>"*"},
+     "public"=>{"enabled"=>true, "port"=>80, "bind"=>"*"}},
+   "client"=>{"general"=>{"enabled"=>false}}}}
+```
+
+## Information
+
+* Repo: https://github.com/chrisroberts/attribute_struct

data/attribute_struct.gemspec

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'attribute_struct/version'
+Gem::Specification.new do |s|
+  s.name = 'attribute_struct'
+  s.version = AttributeStruct::VERSION.version
+  s.summary = 'Attribute structures'
+  s.author = 'Chris Roberts'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'http://github.com/chrisroberts/attribute_struct'
+  s.description = 'Attribute structures'
+  s.require_path = 'lib'
+  s.add_dependency 'hashie', '~> 2.0.5'
+  s.files = Dir['**/*']
+end

data/lib/attribute_struct/attribute_hash.rb

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

data/lib/attribute_struct/attribute_struct.rb

@@ -0,0 +1,193 @@
+class AttributeStruct
+  
+  class << self
+    
+    attr_reader :camel_keys
+    attr_accessor :force_chef
+
+    def camel_keys=(val)
+      load_the_camels if val
+      @camel_keys = !!val
+    end
+
+    def load_the_camels
+      unless(@camels_loaded)
+        require 'attrubute_struct/monkey_camels'
+        @camels_loaded = true
+      end
+    end
+
+    def load_the_hash
+      unless(@hash_loaded)
+        if(defined?(Chef) || force_chef)
+          require 'chef/mash'
+          require 'chef/mixin/deep_merge'
+        else
+          require 'attribute_struct/attribute_hash'
+        end
+        @hash_loaded
+      end
+    end
+
+  end
+
+  attr_reader :_camel_keys
+  
+  def initialize(*args, &block)
+    self.class.load_the_hash
+    @_camel_keys = self.class.camel_keys
+    @table = __hashish.new
+    unless(args.empty?)
+      if(args.size == 1 && args.first.is_a?(Hash))
+        _load(args.first)
+      end
+    end
+  end
+
+  def _camel_keys=(val)
+    self.class.load_the_camels if val
+    @_camel_keys = !!val
+  end
+  
+  def [](key)
+    _data[_process_key(key)]
+  end
+
+  def _set(key, val=nil, &block)
+    if(val)
+      self.method_missing(key, val, &block)
+    else
+      self.method_missing(key, &block)
+    end
+  end
+  
+  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
+    if(!args.empty? || block)
+      if(args.empty? && block)
+        base = @table[sym]
+        if(block.arity == 0)
+          base.instance_exec(&block)
+        else
+          base.instance_exec(base, &block)
+        end
+        @table[sym] = base
+      elsif(!args.empty? && block)
+        base = @table[sym]
+        base = self.class.new unless base.is_a?(self.class)
+        @table[sym] = base
+        leaf = base
+        args.each do |arg|
+          leaf = base[arg]
+          unless(leaf.is_a?(self.class))
+            leaf = self.class.new
+            base._set(arg, leaf)
+            base = leaf
+          end
+        end
+        if(block.arity == 0)
+          leaf.instance_exec(&block)
+        else
+          leaf.instance_exec(leaf, &block)
+        end
+      else
+        @table[sym] = args.first
+      end
+    end
+    @table[sym]
+  end
+
+  def nil?
+    _data.empty?
+  end
+
+  def _keys
+    _data.keys
+  end
+  
+  def _data
+    @table
+  end
+
+  def _dump
+    __hashish[
+      *(@table.map{|key, value|
+          [key, value.is_a?(self.class) ? value._dump : value]
+        }.flatten(1))
+    ]
+  end
+
+  def _load(hashish)
+    @table.clear
+    hashish.each do |key, value|
+      if(value.is_a?(Hash))
+        self._set(key)._load(value)
+      else
+        self._set(key, value)
+      end
+    end
+    self
+  end
+
+  def _merge(target)
+    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)
+  end
+
+  def _merge!(target)
+    result = _merge(target)._dump
+    _load(result)
+    self
+  end
+  
+  def __hashish
+    defined?(Mash) ? Mash : AttributeHash
+  end
+  
+  def do_dup(v)
+    begin
+      v.dup
+    rescue
+      v.is_a?(Symbol) ? v.to_s : v
+    end
+  end
+
+  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) }
+    else
+      val = do_dup(thing)
+    end
+    if(thing.is_a?(Hash))
+      val = __hashish[*val.flatten(1)]
+    end
+    val
+  end
+
+  def _process_key(key)
+    key = key.to_s
+    if(_camel_keys && key._camel?)
+      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)
+      end
+      key
+    end
+  end
+end

data/lib/attribute_struct/monkey_camels.rb

@@ -0,0 +1,59 @@
+module MonkeyCamels
+
+  class << self
+    def included(klass)
+      klass.class_eval do
+
+        include Humps
+        
+        alias_method :un_camel_to_s, :to_s
+        alias_method :to_s, :camel_to_s
+        alias_method :un_camel_initialize_copy, :initialize_copy
+        alias_method :initialize_copy, :camel_initialize_copy
+      end
+    end
+  end
+
+  def camel_initialize_copy(orig)
+    new_val = un_camel_initialize_copy(orig)
+    orig._camel? ? new_val : new_val._no_hump
+  end
+  
+  def camel_to_s
+    val = un_camel_to_s
+    _camel? ? val : val._no_hump
+  end
+
+  module Humps
+    
+    def _camel?
+      !@__not_camel
+    end
+
+    def _no_hump
+      @__not_camel = true
+      self
+    end
+
+    def _hump
+      @__not_camel = false
+      self
+    end
+
+  end
+
+end
+
+# Force some monkeys around
+String.send(:include, MonkeyCamels)
+Symbol.send(:include, MonkeyCamels)
+
+# Specialized type
+class CamelString < String
+  def initialize(val=nil)
+    super
+    if(val.respond_to?(:_camel?))
+      _no_hump unless val._camel?
+    end
+  end
+end

data/lib/attribute_struct/version.rb

@@ -0,0 +1,6 @@
+class AttributeStruct
+  class Version < Gem::Version
+  end
+
+  VERSION = Version.new('0.1.0')
+end

data/lib/attribute_struct.rb

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

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: attribute_struct
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+description: Attribute structures
+email: chrisroberts.code@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/attribute_struct.rb
+- lib/attribute_struct/attribute_struct.rb
+- lib/attribute_struct/version.rb
+- lib/attribute_struct/attribute_hash.rb
+- lib/attribute_struct/monkey_camels.rb
+- Gemfile
+- README.md
+- attribute_struct.gemspec
+- CHANGELOG.md
+- Gemfile.lock
+homepage: http://github.com/chrisroberts/attribute_struct
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Attribute structures
+test_files: []
+has_rdoc: