attribute_struct 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cfb863d08beb7bf41c350da383961c01f2bc0989
-  data.tar.gz: fd2abc4187313555e34abfb97bb4b3e840bda142
+SHA256:
+  metadata.gz: a88c87931988bfa2b2e576583dbfb8ee6a8b1c5091cb1c62b58f39dddf7f89ec
+  data.tar.gz: 743c6adaaa2992229bcc42e5daf0cebd9a59c91a12f3f83c06a7a4eba672e02f
 SHA512:
-  metadata.gz: f734064ce0705b4df778bb9183e6d8a70eda70fa70923292e3ddd4dcf69942d55d39b7ab854761c371f08c28bfce870a9966ace91756898d80bd290f7c0f418d
-  data.tar.gz: 47ea98e60b46b984f83edb14abc54baca279d7434125be0469b836b1b4b53f97eb5e58feb6549140744351b61327337d711467077d0fdbf083a1de17a3855752
+  metadata.gz: c8df0dcb1c017726e1a2a3b698979fb1e257df3b18e02a7812a27ba7c7e7cfb50fe1fdbdc20625497d4b6eab339ef793d086c70504cc4ec3b7051cac9b75cdb1
+  data.tar.gz: fa93e5e6850bd7d3cb516b6d6e6ca770a6660b561a13c5abf0da15df5b86a3c81ca7c0644c84fcc07cea100225b80c686002a00d5051057da9981633fb5c4c53

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v0.5.0
+* Clean up loading and nest constants
+
+# v0.4.4
+* Add `#key?` method to check for key existence
+
 # v0.4.2
 * Set cloned data via #_data on new instance
 

data/CONTRIBUTING.md

@@ -1,22 +1,18 @@
 # Contributing
 
-## Branches
+## Fixes
 
-### `master` branch
+Have a fix to some bug you want to submit? Well you're
+awesome. Please just include a description of the bug
+(or link to originating issue) and test coverage on the
+modifications.
 
-The master branch is the current stable released version.
+## New Features
 
-### `develop` branch
-
-The develop branch is the current edge of development.
-
-## Pull requests
-
-* https://github.com/chrisroberts/attribute_struct/pulls
-
-Please base all pull requests off the `develop` branch. Merges to
-`master` only occur through the `develop` branch. Pull requests
-based on `master` will likely be cherry picked.
+Have a new feature you want to add? Well you're awesome
+too! It may be a good idea to submit an issue first to
+describe the desired feature and get any feedback. Please
+be sure to include tests.
 
 ## Issues
 

data/LICENSE

@@ -1,4 +1,4 @@
-   Copyright 2016 Chris Roberts
+   Copyright 2022 Chris Roberts
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -10,4 +10,4 @@
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

data/attribute_struct.gemspec

@@ -1,16 +1,18 @@
-$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
-require 'attribute_struct/version'
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + "/lib/"
+require "attribute_struct/version"
 Gem::Specification.new do |s|
-  s.name = 'attribute_struct'
+  s.name = "attribute_struct"
   s.version = AttributeStruct::VERSION.version
-  s.summary = 'Attribute structures'
-  s.author = 'Chris Roberts'
-  s.license = 'Apache 2.0'
-  s.email = 'chrisroberts.code@gmail.com'
-  s.homepage = 'http://github.com/chrisroberts/attribute_struct'
-  s.description = 'Attribute structures'
-  s.require_path = 'lib'
-  s.add_runtime_dependency 'bogo', '>= 0.1.31', '< 0.3.0'
-  s.add_development_dependency 'minitest'
-  s.files = Dir['lib/**/*'] + %w(attribute_struct.gemspec README.md CHANGELOG.md CONTRIBUTING.md LICENSE)
+  s.summary = "Attribute structures"
+  s.author = "Chris Roberts"
+  s.license = "Apache 2.0"
+  s.email = "chrisroberts.code@gmail.com"
+  s.homepage = "http://github.com/chrisroberts/attribute_struct"
+  s.description = "Attribute structures"
+  s.require_path = "lib"
+  s.add_runtime_dependency "bogo", ">= 0.1.31", "< 0.3.0"
+  s.add_development_dependency "rspec", "~> 3.5"
+  s.add_development_dependency "rake", "~> 13"
+  s.add_development_dependency "minitest"
+  s.files = Dir["lib/**/*"] + %w(attribute_struct.gemspec README.md CHANGELOG.md CONTRIBUTING.md LICENSE)
 end

data/lib/attribute_struct/attribute_hash.rb

@@ -1,5 +1,3 @@
-require 'attribute_struct'
-
 class AttributeStruct
 
   # Copyright (c) 2009 Dan Kubb
@@ -75,7 +73,7 @@ class AttributeStruct
     def initialize_copy(orig)
       super
       # Handle nested values
-      each do |k,v|
+      each do |k, v|
         if v.kind_of?(Mash) || v.is_a?(Array)
           self[k] = v.dup
         end
@@ -150,7 +148,7 @@ class AttributeStruct
     #
     # @return [Array] The values at each of the provided keys
     def values_at(*indices)
-      indices.collect {|key| self[convert_key(key)]}
+      indices.collect { |key| self[convert_key(key)] }
     end
 
     # @param hash<Hash> The hash to merge with the mash.
@@ -174,7 +172,7 @@ class AttributeStruct
     #   { :one => 1, :two => 2, :three => 3 }.except(:one)
     #     #=> { "two" => 2, "three" => 3 }
     def except(*keys)
-      super(*keys.map {|k| convert_key(k)})
+      super(*keys.map { |k| convert_key(k) })
     end
 
     # Used to provide the same interface as Hash.
@@ -206,6 +204,7 @@ class AttributeStruct
     end
 
     protected
+
     # @param key<Object> The key to convert.
     #
     # @param [Object]
@@ -242,12 +241,12 @@ class AttributeStruct
     #
     # @return [AttributeStruct::Mash] merged hash
     def deep_merge(hash)
-      unless(hash.is_a?(Hash))
+      unless (hash.is_a?(Hash))
         raise ArgumentError.new "Expecting `Hash` type. Received: `#{hash.class}`"
       end
       new_self = self.dup
-      hash.each do |k,v|
-        if(new_self[k].is_a?(Hash) && v.is_a?(Hash))
+      hash.each do |k, v|
+        if (new_self[k].is_a?(Hash) && v.is_a?(Hash))
           new_self[k] = new_self[k].deep_merge(v)
         else
           new_self[k] = v
@@ -263,7 +262,6 @@ class AttributeStruct
       self.replace(self.deep_merge(hash))
       self
     end
-
   end
 
   AttributeHash = Mash

data/lib/attribute_struct/attribute_struct.rb

@@ -1,10 +1,8 @@
-require 'attribute_struct'
+require "attribute_struct/attribute_hash"
+require "attribute_struct/augmented"
+require "attribute_struct/monkey_camels"
 
 class AttributeStruct < BasicObject
-
-  autoload :Augmented, 'attribute_struct/augmented'
-  autoload :Mash, 'attribute_struct/attribute_hash'
-
   class << self
 
     # @return [Hash] valid styles and mapped value
@@ -14,7 +12,7 @@ class AttributeStruct < BasicObject
       :no_leading => :no_leading,
       :dromedary => :leading,
       :leading_hump => :leading,
-      :leading => :leading
+      :leading => :leading,
     }
 
     # @return [Truthy, Falsey] global flag for camel keys
@@ -46,17 +44,19 @@ class AttributeStruct < BasicObject
     # @return [Symbol]
     # @raises [ArgumentError]
     def validate_camel_style(style)
-      if(VALID_CAMEL_STYLES.has_key?(style))
+      if (VALID_CAMEL_STYLES.has_key?(style))
         VALID_CAMEL_STYLES[style]
       else
-        raise ArgumentError.new "Unsupported camel style provided `#{style.inspect}`! (Allowed: #{VALID_CAMEL_STYLES.keys(&:inspect).join(', ')})"
+        valid_types = VALID_CAMEL_STYLES.keys(&:inspect).join(", ")
+        raise ArgumentError.new "Unsupported camel style provided " \
+                                "`#{style.inspect}`! (Allowed: #{valid_types})"
       end
     end
 
     # Loads helpers for camel casing
     def load_the_camels
-      unless(@camels_loaded)
-        require 'attribute_struct/monkey_camels'
+      unless defined?(@camels_loaded)
+        require "attribute_struct/monkey_camels"
         @camels_loaded = true
       end
     end
@@ -68,7 +68,7 @@ class AttributeStruct < BasicObject
 
     # Create AttributeStruct instance and dump the resulting hash
     def build(&block)
-      raise ArgumentError.new 'Block required for build!' unless block
+      raise ArgumentError.new "Block required for build!" unless block
       new(&block)._dump
     end
 
@@ -80,7 +80,6 @@ class AttributeStruct < BasicObject
       self.send(:include, IrbCompat)
       true
     end
-
   end
 
   # value used to identify unset value
@@ -103,15 +102,18 @@ class AttributeStruct < BasicObject
   #
   # @param init_hash [Hash] hash to initialize struct
   # @yield block to execute within struct context
-  def initialize(init_hash=nil, &block)
+  def initialize(init_hash = nil, &block)
     @_camel_keys = _klass.camel_keys
+    @_camel_keys_set = nil
+    @_parent = nil
     @_arg_state = __hashish.new
+    @_kernelified = false
     @_objectified = false
     @table = __hashish.new
-    if(init_hash)
+    if (init_hash)
       _load(init_hash)
     end
-    if(block)
+    if (block)
       self.instance_exec(&block)
     end
   end
@@ -123,15 +125,17 @@ class AttributeStruct < BasicObject
   def _build(&block)
     self.instance_exec(&block)
   end
+
   alias_method :build!, :_build
 
   # Set state into current context
   #
   # @param args [Hashish] hashish type holding data for context
   # @return [Hashish]
-  def _set_state(args={})
+  def _set_state(args = {})
     _arg_state.merge!(args)
   end
+
   alias_method :set_state!, :_set_state
 
   # Value of requested state
@@ -139,15 +143,16 @@ class AttributeStruct < BasicObject
   # @param key [Symbol, String]
   # @param traverse [TrueClass, FalseClass] traverse towards root for matching key
   # @return [Object, NilClass]
-  def _state(key, traverse=true)
-    if(_arg_state.has_key?(key))
+  def _state(key, traverse = true)
+    if (_arg_state.has_key?(key))
       _arg_state[key]
     else
-      if(traverse && _parent)
+      if (traverse && _parent)
         _parent._state(key)
       end
     end
   end
+
   alias_method :state!, :_state
 
   # Enable/disable camel keys
@@ -171,9 +176,10 @@ class AttributeStruct < BasicObject
   #
   # @param enable [TrueClass, FalseClass]
   # @return [TrueClass, FalseClass]
-  def _objectify(enable=true)
+  def _objectify(enable = true)
     @_objectified = !!enable
   end
+
   alias_method :objectify!, :_objectify
 
   # @return [TrueClass, FalseClass]
@@ -196,13 +202,14 @@ class AttributeStruct < BasicObject
   # @param val [Object]
   # @yield block to execute within context
   # @return [Object]
-  def _set(key, val=UNSET_VALUE, &block)
-    if(val != UNSET_VALUE)
+  def _set(key, val = UNSET_VALUE, &block)
+    if (val != UNSET_VALUE)
       self.method_missing(key, val, &block)
     else
       self.method_missing(key, &block)
     end
   end
+
   alias_method :set!, :_set
 
   # Provides struct DSL behavior
@@ -213,66 +220,66 @@ 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(objectified? && _args.empty? && _block.nil?)
+    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?('='))
+    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
-    if(!_args.empty? || _block)
-      if(_args.empty? && _block)
+    if (!_args.empty? || _block)
+      if (_args.empty? && _block)
         _base = @table.fetch(_sym, UNSET_VALUE)
-        if(_state(:value_collapse) && !_base.is_a?(self.class!))
+        if (_state(:value_collapse) && !_base.is_a?(self.class!))
           _orig = _base
           _base = _klass_new
         else
-          unless(_base.is_a?(self.class!))
+          unless (_base.is_a?(self.class!))
             _base = _klass_new
           end
         end
         @table[_sym] = _base
-        if(_block.arity == 0)
+        if (_block.arity == 0)
           _base.instance_exec(&_block)
         else
           _base.instance_exec(_base, &_block)
         end
-        if(_orig.is_a?(::NilClass))
+        if (_orig.is_a?(::NilClass))
           @table[_sym] = _base
         else
-          if(_orig == UNSET_VALUE)
+          if (_orig == UNSET_VALUE)
             @table[_sym] = _base
           else
-            unless(_orig.is_a?(CollapseArray))
+            unless (_orig.is_a?(CollapseArray))
               _orig = CollapseArray.new.push(_orig)
             end
             _orig << _base
             @table[_sym] = _orig
           end
         end
-      elsif(!_args.empty? && _block)
+      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))
+          unless (_leaf.is_a?(_klass))
             _leaf = _klass_new
             _base._set(_arg, _leaf)
             _base = _leaf
           end
         end
-        if(!_leaf.nil? && _state(:value_collapse))
+        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))
+        if (_orig)
+          unless (_orig.is_a?(CollapseArray))
             _orig = CollapseArray.new.push(_orig)
           end
           _orig << _leaf
@@ -280,19 +287,19 @@ class AttributeStruct < BasicObject
           _orig = _leaf
         end
       else
-        if(_args.size > 1 && _args.all?{|_i| _i.is_a?(::String) || _i.is_a?(::Symbol)} && !_state(:value_collapse))
+        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))
+            unless (_memo[_k].is_a?(_klass))
               _memo._set(_k, _klass_new)
             end
             _memo[_k]
           end
           return _endpoint # custom break out
         else
-          if(_args.size > 1)
+          if (_args.size > 1)
             _val = _args.map do |_v|
-              if(_v.is_a?(::Hash) && _state(:hash_load_struct))
+              if (_v.is_a?(::Hash) && _state(:hash_load_struct))
                 _val = _klass_new
                 _val._load(_v)
               else
@@ -300,15 +307,15 @@ class AttributeStruct < BasicObject
               end
             end
           else
-            if(_args.first.is_a?(::Hash) && _state(:hash_load_struct))
+            if (_args.first.is_a?(::Hash) && _state(:hash_load_struct))
               _val = _klass_new
               _val._load(_args.first)
             else
               _val = _args.first
             end
           end
-          if(_state(:value_collapse) && !(_leaf = @table[_sym]).nil?)
-            unless(_leaf.is_a?(CollapseArray))
+          if (_state(:value_collapse) && !(_leaf = @table[_sym]).nil?)
+            unless (_leaf.is_a?(CollapseArray))
               _leaf = CollapseArray.new.push(_leaf)
             end
             _leaf << _val
@@ -340,18 +347,31 @@ class AttributeStruct < BasicObject
   def is_a?(klass)
     (_klass.ancestors + [::AttributeStruct]).include?(klass)
   end
+
   alias_method :kind_of?, :is_a?
 
+  # Check if key exists within struct
+  #
+  # @param key [String, Symbol]
+  # @return [TrueClass, FalseClass]
+  def key?(key)
+    self._keys.include?(_process_key(key))
+  end
+
+  alias_method :has_key?, :key?
+
   # @return [Array<String,Symbol>] keys within struct
   def _keys
     _data.keys
   end
+
   alias_method :keys!, :_keys
 
   # @return [AttributeStruct::AttributeHash, Mash] underlying struct data
   def _data
     @table
   end
+
   alias_method :data!, :_data
 
   # Delete entry from struct
@@ -361,6 +381,7 @@ class AttributeStruct < BasicObject
   def _delete(key)
     _data.delete(_process_key(key))
   end
+
   alias_method :delete!, :_delete
 
   # Process and unpack items for dumping within deeply nested
@@ -369,8 +390,8 @@ class AttributeStruct < BasicObject
   # @param item [Object]
   # @return [Object]
   def _dump_unpacker(item)
-    if(item.is_a?(::Enumerable))
-      if(item.respond_to?(:keys))
+    if (item.is_a?(::Enumerable))
+      if (item.respond_to?(:keys))
         item.class[
           *item.map do |entry|
             _dump_unpacker(entry)
@@ -383,7 +404,7 @@ class AttributeStruct < BasicObject
           end
         ]
       end
-    elsif(item.is_a?(::AttributeStruct))
+    elsif (item.is_a?(::AttributeStruct))
       item.nil? ? UNSET_VALUE : item._dump
     else
       item
@@ -399,6 +420,7 @@ class AttributeStruct < BasicObject
     end.compact
     __hashish[*processed.flatten(1)]
   end
+
   alias_method :dump!, :_dump
 
   # Clear current struct data and replace
@@ -407,22 +429,22 @@ class AttributeStruct < BasicObject
   # @return [self]
   def _load(hashish)
     @table.clear
-    if(_root._camel_keys_action == :auto_discovery)
-      starts = hashish.keys.map{|k|k[0,1]}
-      unless(starts.detect{|k| k =~ /[A-Z]/})
+    if (_root._camel_keys_action == :auto_discovery)
+      starts = hashish.keys.map { |k| k[0, 1] }
+      unless (starts.detect { |k| k =~ /[A-Z]/ })
         _camel_keys_set(:auto_disable)
       else
         _camel_keys_set(:auto_enable) unless _parent.nil?
       end
     end
     hashish.each do |key, value|
-      if(value.is_a?(::Enumerable))
+      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))
+      if (value.is_a?(::Hash))
         self._set(key)._load(value)
       else
         self._set(key, value)
@@ -430,6 +452,7 @@ class AttributeStruct < BasicObject
     end
     self
   end
+
   alias_method :load!, :_load
 
   # Perform deep merge
@@ -475,14 +498,14 @@ class AttributeStruct < BasicObject
   #
   # @param thing [Object] struct to copy. defaults to self
   # @return [Object] new instance
-  def _deep_copy(thing=nil)
+  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)
     end
-    if(thing.is_a?(::Hash))
+    if (thing.is_a?(::Hash))
       val = __hashish[*val.flatten(1)]
     end
     val
@@ -494,9 +517,9 @@ class AttributeStruct < BasicObject
   # @param args [Object] argument list (:force will force processing)
   # @return [String, Symbol]
   def _process_key(key, *args)
-    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?)
+    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
@@ -504,10 +527,10 @@ 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)
+        if (key._hump_style || _camel_style == :no_leading)
+          unless (key._hump_style == :leading_hump)
             camel_args << false
           end
         end
@@ -519,6 +542,7 @@ class AttributeStruct < BasicObject
       key
     end
   end
+
   alias_method :process_key!, :_process_key
 
   # @return [Class] this class
@@ -530,6 +554,7 @@ class AttributeStruct < BasicObject
   def klass!
     _klass
   end
+
   alias_method :class!, :klass!
   alias_method :class, :klass!
 
@@ -537,7 +562,7 @@ class AttributeStruct < BasicObject
   # @note will set self as parent and propogate camelizing status
   def _klass_new(*args, &block)
     n = _klass.new(*args, &block)
-    unless(_camel_keys_action == :auto_discovery)
+    unless (_camel_keys_action == :auto_discovery)
       n._camel_keys_set(_camel_keys_action)
     end
     n._camel_keys = _camel_keys
@@ -555,6 +580,7 @@ class AttributeStruct < BasicObject
   def _camel_keys_set(v)
     @_camel_keys_set = v
   end
+
   alias_method :camel_keys_set!, :_camel_keys_set
 
   # @return [Symbol, NilClass] :auto_disable or :auto_enable
@@ -563,20 +589,22 @@ class AttributeStruct < BasicObject
   end
 
   # @return [AttributeStruct, NilClass] parent of this struct
-  def _parent(obj=nil)
+  def _parent(obj = nil)
     @_parent = obj if obj
     @_parent
   end
+
   alias_method :parent!, :_parent
 
   # @return [AttributeStruct, NilClass] root of the struct or nil if self is root
   def _root
     r = self
-    until(r._parent == nil)
+    until (r._parent == nil)
       r = r._parent
     end
     r
   end
+
   alias_method :root!, :_root
 
   # Create an Array and evaluate discovered AttributeStructs
@@ -585,9 +613,9 @@ class AttributeStruct < BasicObject
   # @return [Array]
   def _array(*args)
     args.map do |maybe_block|
-      if(maybe_block.is_a?(::Proc))
+      if (maybe_block.is_a?(::Proc))
         klass = _klass_new
-        if(maybe_block.arity > 0)
+        if (maybe_block.arity > 0)
           klass.instance_exec(klass, &maybe_block)
         else
           klass.instance_exec(&maybe_block)
@@ -598,6 +626,7 @@ class AttributeStruct < BasicObject
       end
     end
   end
+
   alias_method :array!, :_array
 
   # Instance responds to method name
@@ -613,7 +642,7 @@ class AttributeStruct < BasicObject
   # @param konst [Symbol, String]
   # @return [Object, NilClass]
   def _objectified_constant_lookup(konst)
-    if(konst.to_s[0].match(/[A-Z]/) && ::Object.const_defined?(konst))
+    if (konst.to_s[0].match(/[A-Z]/) && ::Object.const_defined?(konst))
       ::Object.const_get(konst)
     end
   end
@@ -622,7 +651,7 @@ class AttributeStruct < BasicObject
   #
   # @return [TrueClass]
   def _kernelify
-    unless(kernelified?)
+    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")
@@ -630,6 +659,7 @@ class AttributeStruct < BasicObject
     end
     true
   end
+
   alias_method :kernelify!, :_kernelify
 
   # @return [TrueClass, FalseClass] Kernel methods have been injected
@@ -643,28 +673,29 @@ class AttributeStruct < BasicObject
   end
 
   # @return [AttributeStruct] clone of current instance
-  def _clone(_new_parent=nil)
+  def _clone(_new_parent = nil)
     _cloned_inst = _klass_new
     _cloned_inst._data.replace __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]
-      }
-    ]
+                                 @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'
-require 'attribute_struct/version'
+require "attribute_struct/attribute_hash"
+require "attribute_struct/version"

data/lib/attribute_struct/augmented.rb

@@ -1,10 +1,7 @@
-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
@@ -21,6 +18,5 @@ class AttributeStruct
     def _klass
       ::AttributeStruct::Augmented
     end
-
   end
 end

data/lib/attribute_struct/irb_compat.rb

@@ -1,14 +1,15 @@
 # Helper methods for IRB interactions
-module IrbCompat
+module AttributeStruct
+  module IrbCompat
 
-  # @return [String] object inspection
-  def inspect
-    "<[#{self._klass}:#{@table.object_id}] - table: #{@table.inspect}>"
-  end
+    # @return [String] object inspection
+    def inspect
+      "<[#{self._klass}:#{@table.object_id}] - table: #{@table.inspect}>"
+    end
 
-  # @return [String] string of instance
-  def to_s
-    "<#{self._klass}:#{@table.object_id}>"
+    # @return [String] string of instance
+    def to_s
+      "<#{self._klass}:#{@table.object_id}>"
+    end
   end
-
 end

data/lib/attribute_struct/monkey_camels.rb

@@ -1,13 +1,8 @@
-require 'attribute_struct'
-
-unless(defined?(MonkeyCamels))
-
+class AttributeStruct
   module MonkeyCamels
-
     class << self
       def included(klass)
         klass.class_eval do
-
           include Humps
 
           alias_method :un_camel_to_s, :to_s
@@ -21,9 +16,9 @@ unless(defined?(MonkeyCamels))
     # Create a camel copy based on settings
     #
     # @return [String]
-    def camel_initialize_copy(orig, hump=nil)
+    def camel_initialize_copy(orig, hump = nil)
       new_val = un_camel_initialize_copy(orig)
-      if(hump.nil?)
+      if (hump.nil?)
         orig._camel? ? new_val : new_val._no_hump
       else
         new_val._no_hump if hump == false
@@ -39,15 +34,22 @@ unless(defined?(MonkeyCamels))
     end
 
     module Humps
-
       # @return [TrueClass, FalseClass] specific style requested
       def _hump_format_requested?
-        @__not_camel != nil
+        if defined?(@__not_camel)
+          @__not_camel != nil
+        else
+          false
+        end
       end
 
       # @return [TrueClass, FalseClass] camelized
       def _camel?
-        !@__not_camel
+        if defined?(@__not_camel)
+          !@__not_camel
+        else
+          true
+        end
       end
 
       # @return [self] disable camelizing
@@ -55,6 +57,7 @@ unless(defined?(MonkeyCamels))
         @__not_camel = true
         self
       end
+
       alias_method :disable_camel!, :_no_hump
 
       # @return [self] enable camelizing
@@ -62,12 +65,16 @@ unless(defined?(MonkeyCamels))
         @__not_camel = false
         self
       end
+
       alias_method :camel!, :_hump
 
       # @return [Symbol, NilClass] style of hump
       def _hump_style
-        @__hump_style
+        if defined?(@__hump_style)
+          @__hump_style
+        end
       end
+
       alias_method :hump_style!, :_hump_style
 
       # Set hump style to non-leading upcase
@@ -78,6 +85,7 @@ unless(defined?(MonkeyCamels))
         @__hump_style = :no_leading_hump
         self
       end
+
       alias_method :bactrian!, :_bactrian
       alias_method :no_leading_hump!, :_bactrian
 
@@ -89,26 +97,26 @@ unless(defined?(MonkeyCamels))
         @__hump_style = :leading_hump
         self
       end
+
       alias_method :dromedary!, :_dromedary
       alias_method :leading_hump!, :_dromedary
-
     end
-
   end
 
   # Force some monkeys around
-  String.send(:include, MonkeyCamels)
-  Symbol.send(:include, MonkeyCamels)
+  ::String.send(:include, MonkeyCamels)
+  ::Symbol.send(:include, MonkeyCamels)
 
   # Specialized String type
-  class CamelString < String
-    def initialize(val=nil)
+  class CamelString < ::String
+    def initialize(val = nil)
       super
-      if(val.respond_to?(:_camel?))
+      if (val.respond_to?(:_camel?))
         _no_hump unless val._camel?
         @__hump_style = val._hump_style
+      else
+        @__hump_style = nil
       end
     end
   end
-
 end

data/lib/attribute_struct/version.rb

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

data/lib/attribute_struct.rb

@@ -1,8 +1,4 @@
-require 'bogo'
-require 'attribute_struct/attribute_struct'
+require "bogo"
 
-autoload :MonkeyCamels, 'attribute_struct/monkey_camels'
-autoload :CamelString, 'attribute_struct/monkey_camels'
-autoload :IrbCompat, 'attribute_struct/irb_compat'
-
-require 'attribute_struct/version'
+require "attribute_struct/attribute_struct"
+require "attribute_struct/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attribute_struct
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-11 00:00:00.000000000 Z
+date: 2022-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo
@@ -30,6 +30,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -81,8 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 3.4.0.dev
 signing_key: 
 specification_version: 4
 summary: Attribute structures