attribute_struct 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e1db29333317313d771dfeebe9c6aa4065fbb7e
-  data.tar.gz: b0be69a6c207580f1b4f8ce483dc1647c0654580
+  metadata.gz: 62a1d8f5b662295b8d042e63ab3db10675590f8c
+  data.tar.gz: c6aa3dff93e00ac5af116d7ad1f181fb92277894
 SHA512:
-  metadata.gz: 3145317f6dc5dc195adc2fe9cc3c1b8ea228c3e46c8b1bb2001c7a2388b87704078433cd3d5a618146b8408ef2fcddef80aaaf1bee1ec118a45ea106b1b304ee
-  data.tar.gz: decbcd90e9ed1c434c1b006d3373a097651808436df41f0a7c47624f11374aef6d402465a3405e630270f3ae7ee28117022c346c7ceba8c9d997fd7731746c6a
+  metadata.gz: 17a711517062fe06ab4af95af64dcb4b45bc9d8050a204d42767f63e712e39552c07a2ec7915bb465e9ff9c20b9ce50447e7a870d01ad6c0bc9ab34d51977044
+  data.tar.gz: 2367c34c291b7c8a7f0e79f75782f08ce80b4d065aa0319e81c798c60ca656aa0e86d6fd719beda54b90af8df932646592c77bf299f0f39b3522cb1b169f00e3

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.4.0
+* Support cloning of AttributeStruct instances
+* Allow non-Stringish types to be used for data keys
+* Include Augmented AttributeStruct to include kernelization
+
 # v0.3.4
 * Fix value overwrite when accessed via parameter and updated via block
 

data/README.md

@@ -244,6 +244,38 @@ end.dump!
 # => {"This"=>{"Is"=>{"A"=>{"Deeply"=>{"NestedCamel"=>{"Hash"=>true}}}}},"horse" => true}
 ```
 
+### Augmented AttributeStruct
+
+An augmented version of the AttributeStruct is available that includes
+the `Kernel` module to provide many common methods. This can reduce the
+usability of the struct by defining methods that may collide with desired
+key entries. It is important to be aware of this when using the augmented
+version. To create an augmented version:
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct::Augmented.new do
+  rand_value rand
+end.dump!
+
+# => {"rand_value"=>0.7983473046826768}
+```
+
+Kernel methods can also be injected into raw AttributeStruct instance. Again,
+caution must be used to prevent unintended collisions:
+
+```ruby
+require 'attribute_struct'
+
+AttributeStruct.new do
+  kernelify!
+  rand_value rand
+end.dump!
+
+# => {"rand_value"=>0.24500702285393017}
+```
+
 ## In the wild
 
 Libraries utilizing AttributeStruct:

data/lib/attribute_struct/attribute_hash.rb

@@ -185,7 +185,10 @@ class AttributeStruct
     # @return [Hash] The mash as a Hash with symbolized keys.
     def symbolize_keys
       h = Hash.new(default)
-      each { |key, val| h[key.to_sym] = val }
+      each do |key, val|
+        key = key.to_sym if key.is_a?(String) || key.is_a?(Symbol)
+        h[key] = val
+      end
       h
     end
 

data/lib/attribute_struct/attribute_struct.rb

@@ -2,6 +2,7 @@ require 'attribute_struct'
 
 class AttributeStruct < BasicObject
 
+  autoload :Augmented, 'attribute_struct/augmented'
   autoload :Mash, 'attribute_struct/attribute_hash'
 
   class << self
@@ -105,6 +106,7 @@ class AttributeStruct < BasicObject
   def initialize(init_hash=nil, &block)
     @_camel_keys = _klass.camel_keys
     @_arg_state = __hashish.new
+    @_objectified = false
     @table = __hashish.new
     if(init_hash)
       _load(init_hash)
@@ -165,6 +167,20 @@ class AttributeStruct < BasicObject
     @_camel_style = ::AttributeStruct.validate_camel_style(val)
   end
 
+  # Enable/disable root constant lookups
+  #
+  # @param enable [TrueClass, FalseClass]
+  # @return [TrueClass, FalseClass]
+  def _objectify(enable=true)
+    @_objectified = !!enable
+  end
+  alias_method :objectify!, :_objectify
+
+  # @return [TrueClass, FalseClass]
+  def objectified?
+    @_objectified
+  end
+
   # Direct data access
   #
   # @param key [String, Symbol]
@@ -197,11 +213,17 @@ class AttributeStruct < BasicObject
   # @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
+    if(objectified? && _args.empty? && _block.nil?)
+      _o_lookup = _objectified_constant_lookup(_sym)
+      return _o_lookup if _o_lookup
+    end
+    if(_sym.is_a?(::String) || _sym.is_a?(::Symbol))
+      if((_s = _sym.to_s).end_with?('='))
+        _s.slice!(-1, _s.length)
+        _sym = _s
+      end
+      _sym = _process_key(_sym)
     end
-    _sym = _process_key(_sym)
     if(!_args.empty? || _block)
       if(_args.empty? && _block)
         _base = @table.fetch(_sym, UNSET_VALUE)
@@ -472,23 +494,27 @@ class AttributeStruct < BasicObject
   # @param args [Object] argument list (:force will force processing)
   # @return [String, Symbol]
   def _process_key(key, *args)
-    key = ::CamelString.new(key.to_s)
-    if(_camel_keys && _camel_keys_action && !key._hump_format_requested?)
-      case _camel_keys_action
-      when :auto_disable
-        key._no_hump
-      when :auto_enable
-        key._hump
+    if(key.is_a?(::String) || key.is_a?(::Symbol))
+      key = ::CamelString.new(key.to_s)
+      if(_camel_keys && _camel_keys_action && !key._hump_format_requested?)
+        case _camel_keys_action
+        when :auto_disable
+          key._no_hump
+        when :auto_enable
+          key._hump
+        end
       end
-    end
-    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)
-          camel_args << false
+      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)
+            camel_args << false
+          end
         end
+        ::Bogo::Utility.camel(*camel_args)
+      else
+        key
       end
-      ::Bogo::Utility.camel(*camel_args)
     else
       key
     end
@@ -499,9 +525,13 @@ class AttributeStruct < BasicObject
   def _klass
     ::AttributeStruct
   end
-  alias_method :klass!, :_klass
-  alias_method :class!, :_klass
-  alias_method :class, :_klass
+
+  # @return [Class] this clas
+  def klass!
+    _klass
+  end
+  alias_method :class!, :klass!
+  alias_method :class, :klass!
 
   # @return [AttributeStruct] new struct instance
   # @note will set self as parent and propogate camelizing status
@@ -512,6 +542,8 @@ class AttributeStruct < BasicObject
     end
     n._camel_keys = _camel_keys
     n._camel_style = _camel_style if _camel_style
+    n._objectify if objectified?
+    n._kernelify if kernelified?
     n._parent(self)
     n
   end
@@ -576,6 +608,62 @@ class AttributeStruct < BasicObject
     _klass.instance_methods.map(&:to_sym).include?(name.to_sym)
   end
 
+  # Lookup constant in root namespace
+  #
+  # @param konst [Symbol, String]
+  # @return [Object, NilClass]
+  def _objectified_constant_lookup(konst)
+    if(konst.to_s[0].match(/[A-Z]/) && ::Object.const_defined?(konst))
+      ::Object.const_get(konst)
+    end
+  end
+
+  # Inject Kernel methods
+  #
+  # @return [TrueClass]
+  def _kernelify
+    unless(kernelified?)
+      @_kernelified = true
+      (::Kernel.public_instance_methods + ::Kernel.private_instance_methods).each do |m_name|
+        self.instance_eval("def #{m_name}(*a, &b); ::Kernel.instance_method(:#{m_name}).bind(self).curry.call(*a, &b); end")
+      end
+    end
+    true
+  end
+  alias_method :kernelify!, :_kernelify
+
+  # @return [TrueClass, FalseClass] Kernel methods have been injected
+  def kernelified?
+    !!@_kernelified
+  end
+
+  # @return [Numeric]
+  def hash
+    ::Kernel.instance_method(:hash).bind(self).curry.call
+  end
+
+  # @return [AttributeStruct] clone of current instance
+  def _clone(_new_parent=nil)
+    _cloned_inst = _klass_new
+    _cloned_inst.__table = __hashish[
+      @table.map{ |_key, _value|
+        if(_key.is_a?(::AttributeStruct))
+          _key = _key._clone
+        else
+          _key = _do_dup(_key)
+        end
+        if(_value.is_a?(::AttributeStruct))
+          _value = _value._clone
+        else
+          _value = _do_dup(_value)
+        end
+        [_key, _value]
+      }
+    ]
+    _cloned_inst._parent(_new_parent) if _new_parent
+    _cloned_inst
+  end
+  alias_method :clone!, :_clone
 end
 
 require 'attribute_struct/attribute_hash'

data/lib/attribute_struct/augmented.rb

@@ -0,0 +1,26 @@
+require 'attribute_struct'
+
+class AttributeStruct
+  # AttributeStruct expanded class that include the Kernel module
+  # and automatically objectifies the instance
+  class Augmented < ::AttributeStruct
+
+    include ::Kernel
+
+    # Create a new Augmented AttributeStruct instance. Passes arguments
+    # and block directly to parent for initialization. Automatically
+    # objectifies the instance
+    #
+    # @return [self]
+    def initialize(*args, &block)
+      super(*args, &block)
+      @_objectified = true
+    end
+
+    # @return [Class]
+    def _klass
+      ::AttributeStruct::Augmented
+    end
+
+  end
+end

data/lib/attribute_struct/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attribute_struct
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-10 00:00:00.000000000 Z
+date: 2017-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo
@@ -58,6 +58,7 @@ files:
 - lib/attribute_struct.rb
 - lib/attribute_struct/attribute_hash.rb
 - lib/attribute_struct/attribute_struct.rb
+- lib/attribute_struct/augmented.rb
 - lib/attribute_struct/irb_compat.rb
 - lib/attribute_struct/monkey_camels.rb
 - lib/attribute_struct/version.rb
@@ -86,4 +87,3 @@ signing_key:
 specification_version: 4
 summary: Attribute structures
 test_files: []
-has_rdoc: