angry_hash 0.2.2 → 0.3.0

data/Changelog.md

@@ -1,13 +1,14 @@
 ## 0.2.2
 
 Changes:
+
   - `#to_normal_hash` can now return a hash with symbol keys. The default is still to use string keys as is default within `AngryHash`.
 
 ## 0.2.1
 
 Changes:
 
-  - In `#merge` & friends `other` hash is now converted to an AngryHash before conversion.
+  - In `#merge` & friends `other` hash is now converted to an AngryHash before merging.
     This ensures subhashes in `other` but not `this` end up as AngryHashes in `this` after merging.
 
 ## 0.2.0

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/angry_hash.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{angry_hash}
-  s.version = "0.2.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lachie Cox"]
-  s.date = %q{2010-08-30}
+  s.date = %q{2010-10-20}
   s.description = %q{A stabler mash with different emphases. Used in plus2 projects AngryMob and Igor.}
   s.email = %q{lachie@plus2.com.au}
   s.extra_rdoc_files = [
@@ -25,9 +25,14 @@ Gem::Specification.new do |s|
      "VERSION",
      "angry_hash.gemspec",
      "lib/angry_hash.rb",
+     "lib/angry_hash/conversion/by_reference.rb",
+     "lib/angry_hash/conversion/duplicating.rb",
      "lib/angry_hash/dsl.rb",
      "lib/angry_hash/extension.rb",
-     "lib/angry_hash/merge_string.rb"
+     "lib/angry_hash/extension_aware.rb",
+     "lib/angry_hash/initialiser.rb",
+     "lib/angry_hash/merge_string.rb",
+     "lib/angry_hash/merging.rb"
   ]
   s.homepage = %q{http://github.com/plus2/angry_hash}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -40,7 +45,7 @@ Gem::Specification.new do |s|
      "examples/dsl.eg.rb",
      "examples/dup_eg.rb",
      "examples/eg_helper.rb",
-     "examples/extension_tracking.rb",
+     "examples/extension_tracking.eg.rb",
      "examples/merge_eg.rb",
      "examples/normal_hash.eg.rb"
   ]

data/examples/{extension_tracking.rb → extension_tracking.eg.rb}

@@ -1,5 +1,5 @@
 require 'eg_helper'
-require 'angry_hash/extension'
+require 'angry_hash'
 
 module Fixtures
   module CreditCard
@@ -104,3 +104,59 @@ eg 'extensions persist with dup_with_extension' do
   Assert(   new_user.credit_card.valid? )
   Assert( defined?( new_user.credit_card.valid? ) == 'method' )
 end
+
+def same_obj(a,b)
+  a.__id__ == b.__id__
+end
+
+eg 'extensions persist after deep_merge' do
+  user = AngryHash[ :name => 'Bob', :credit_card => {:number => 123}, :phone_numbers => {:home => {:number => '+41 0404555111'}} ]
+  user.extend Fixtures::User
+
+  Assert( user.phone_numbers.home.country_code == 41 )
+
+  new_user = user.deep_merge(:credit_card => {:number => 456})
+
+  Assert( new_user.phone_numbers.home.country_code == 41 )
+
+  Assert( ! same_obj( user.__id__, new_user.__id__ ) )
+  Assert( ! same_obj( user.phone_numbers.home.__id__, new_user.phone_numbers.home.__id__ ) )
+
+  Assert( new_user.credit_card.number == 456 )
+  Assert( new_user.phone_numbers.home.country_code == 41 )
+end
+
+eg 'extensions persist after reverse_deep_merge' do
+  user = AngryHash[ :name => 'Bob', :credit_card => {:number => 123}, :phone_numbers => {:home => {:number => '+41 0404555111'}} ]
+  user.extend Fixtures::User
+
+  Assert( user.phone_numbers.home.country_code == 41 )
+
+  # Do the reverse_deep_merge
+  new_user = user.reverse_deep_merge(:credit_card => {:number => 456})
+
+  Assert( new_user.phone_numbers.home.country_code == 41 )
+
+  Assert( ! same_obj( user.__id__, new_user.__id__ ) )
+  Assert( ! same_obj( user.phone_numbers.home.__id__, new_user.phone_numbers.home.__id__ ) )
+
+  Assert( new_user.credit_card.number == 123 )
+  Assert( new_user.phone_numbers.home.country_code == 41 )
+end
+
+eg 'extensions persist after AngryHash[]' do
+  user = AngryHash[ :name => 'Bob', :credit_card => {:number => 123}, :phone_numbers => {:home => {:number => '+41 0404555111'}} ]
+  user.extend Fixtures::User
+
+  user.__angry_hash_extension.tapp(:ahe)
+
+  num = user.phone_numbers.home
+  num.__angry_hash_extension.tapp(:ahe)
+  
+  Assert(num.country_code == 41)
+
+  args = AngryHash[ :nothing_special => {:phone => user.phone_numbers.home} ]
+
+  Show(args)
+  Assert(args.nothing_special.phone.country_code == 41)
+end

data/lib/angry_hash.rb

@@ -1,80 +1,49 @@
-
 class AngryHash < Hash
+  require 'angry_hash/conversion/by_reference'
+  require 'angry_hash/conversion/duplicating'
+  require 'angry_hash/extension'
+  require 'angry_hash/extension_aware'
+  require 'angry_hash/merging'
+  require 'angry_hash/initialiser'
+
   # config
   require 'angry_hash/dsl'
   include AngryHash::DSL
 
-  def self.[](other=nil)
-    if other
-      super(__convert(other))
-    else
-      new
-    end
-  end
+  extend AngryHash::Initialiser
+
 
   alias_method :regular_writer, :[]=    unless method_defined?(:regular_writer)
   alias_method :regular_reader, :[]     unless method_defined?(:regular_reader)
   alias_method :regular_update, :update unless method_defined?(:regular_update)
 
+  # store value under key, without dup-ing.
   def []=(key, value)
-    regular_writer(__convert_key(key), self.class.__convert_value_without_dup(value))
+    regular_writer(__convert_key(key), __convert_value_without_dup(value))
   end
 
+  # fetch value stored under key.
   def [](key)
     regular_reader(__convert_key(key))
   end
 
+  # override id to fetch value stored under 'id'.
   def id
     regular_reader('id')
   end
 
+  # store value under key by duping the value.
   def dup_and_store(key,value)
-    regular_writer(__convert_key(key), self.class.__convert_value(value))
+    regular_writer(__convert_key(key), __convert_value(value))
   end
 
-  alias_method :regular_merge, :merge unless method_defined?(:regular_merge)
-  def merge(hash)
-    regular_merge(self.class.__convert_without_dup(hash))
-  end
-
-  def merge!(other_hash)
-    other_hash.each_pair { |key, value| dup_and_store(key,value) }
-    self
-  end
-  alias_method :update, :merge!
-
+  # Duplicate the AngryHash
   def dup
     self.class[ self ]
   end
 
-  def deep_merge(other_hash)
-    other_hash = AngryHash[other_hash]
-
-    self.regular_merge( other_hash ) do |key, oldval, newval|
-      oldval = AngryHash.__convert_value(oldval)
-      newval = AngryHash.__convert_value(newval)
-
-      AngryHash === oldval && AngryHash === newval ? oldval.deep_merge(newval) : newval
-    end
-  end
-
-  def deep_merge!(other_hash)
-    replace(deep_merge(other_hash))
-    self
-  end
-  alias_method :deep_update, :deep_merge!
-
-  def reverse_deep_merge(other_hash)
-    self.class.__convert_value(other_hash).deep_merge(self)
-  end
-
-  def reverse_deep_merge!(other_hash)
-    replace(reverse_deep_merge(other_hash))
-    self
-  end
-  alias_method :reverse_deep_update, :reverse_deep_merge!
-
 
+  # override normal Hash methods
 
   def key?(key)
     super(__convert_key(key))
@@ -99,6 +68,8 @@ class AngryHash < Hash
     self
   end
 
+  ## Convert back to a plain hash
+
   def to_normal_hash(keys=nil)
     __to_hash(self,keys)
   end
@@ -132,6 +103,7 @@ class AngryHash < Hash
   end
 
 
+  # Support dot notation access
   def method_missing(method,*args,&blk)
     method_s = method.to_s
 
@@ -157,6 +129,7 @@ class AngryHash < Hash
     end
   end
 
+  # please be Strings
   def __convert_key(key)
     Symbol === key ? key.to_s : key
   end
@@ -164,67 +137,8 @@ class AngryHash < Hash
     Symbol === key ? key.to_s : key
   end
 
-
-  # non-duplicating convert
-  def self.__convert_without_dup(hash)
-    hash.inject(AngryHash.new) do |newhash,(k,v)|
-      newhash[__convert_key(k)] = __convert_value_without_dup(v)
-      newhash
-    end
-  end
-
-  def self.__convert_value_without_dup(v)
-    v = v.to_hash if v.respond_to?(:to_hash)
-
-    case v
-    when AngryHash
-      v
-    when Hash
-      __convert_without_dup(v)
-    when Array
-      v.map {|vv| __convert_value_without_dup(vv)}
-    else
-      v
-    end
-  end
-
-
-  # duplicating convert
-  def self.__convert(hash,cycle_watch=[])
-    new_hash = hash.inject(AngryHash.new) do |hash,(k,v)|
-      hash.regular_writer( __convert_key(k), __convert_value(v,cycle_watch) )
-      hash
-    end
-
-    new_hash
-  end
-
-  def self.__convert_value(v,cycle_watch=[])
-    id = v.__id__
-
-    return if cycle_watch.include? id
-
-    begin
-      cycle_watch << id
-
-      original_v = v
-      v = v.to_hash if v.respond_to?(:to_hash)
-
-      case v
-      when Hash
-        __convert(v,cycle_watch)
-      when Array
-        v.map {|vv| __convert_value(vv,cycle_watch)}
-      when Fixnum,Symbol,NilClass,TrueClass,FalseClass,Float,Bignum
-        v
-      else
-        v.dup
-      end
-    ensure
-      cycle_watch.pop
-    end
-  end
-  
+  include Merging
+  include Conversion::Duplicating
+  include Conversion::ByReference
+  include ExtensionAware
 end
-
-

data/lib/angry_hash/conversion/by_reference.rb

@@ -0,0 +1,30 @@
+class AngryHash
+  module Conversion
+    module ByReference
+
+      # non-duplicating convert
+      def __convert_without_dup(hash)
+        hash.inject(AngryHash.new) do |newhash,(k,v)|
+          newhash[__convert_key(k)] = __convert_value_without_dup(v)
+          newhash
+        end
+      end
+
+      def __convert_value_without_dup(v)
+        v = v.to_hash if v.respond_to?(:to_hash)
+
+        case v
+        when AngryHash
+          v
+        when Hash
+          __convert_without_dup(v)
+        when Array
+          v.map {|vv| __convert_value_without_dup(vv)}
+        else
+          v
+        end
+      end
+      
+    end
+  end
+end

data/lib/angry_hash/conversion/duplicating.rb

@@ -0,0 +1,56 @@
+class AngryHash
+  module Conversion
+    module Duplicating
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # duplicating convert
+        def __convert(hash,cycle_watch=[])
+          new_hash = hash.inject(AngryHash.new) do |hash,(k,v)|
+            hash.regular_writer( __convert_key(k), __convert_value(v,cycle_watch) )
+            hash
+          end
+
+          new_hash
+        end
+
+        def __convert_value(v,cycle_watch=[])
+          id = v.__id__
+
+          return if cycle_watch.include? id
+
+          begin
+            cycle_watch << id
+
+            original_v = v
+            v = v.to_hash if v.respond_to?(:to_hash)
+
+            case v
+            when Hash
+              __convert(v,cycle_watch)
+            when Array
+              v.map {|vv| __convert_value(vv,cycle_watch)}
+            when Fixnum,Symbol,NilClass,TrueClass,FalseClass,Float,Bignum,BigDecimal
+              v
+            else
+              v.dup
+            end
+          ensure
+            cycle_watch.pop
+          end
+        end
+      end
+
+      def __convert(hash,cycle_watch=[])
+        self.class.__convert(hash,cycle_watch)
+      end
+
+      def __convert_value(v,cycle_watch=[])
+        self.class.__convert_value(v,cycle_watch)
+      end
+
+    end
+  end
+end

data/lib/angry_hash/extension.rb

@@ -1,10 +1,4 @@
-require 'angry_hash'
-
 class AngryHash
-  def self.new_extended(mod,seed={})
-    self[ seed ].tap {|hash| hash.extend(mod) }
-  end
-
   module Extension
     class << self
       def included(base)
@@ -49,7 +43,13 @@ class AngryHash
         mixin_registry[target_class][field.to_s] = [:hash, mod, options]
       end
 
-      def extend_hash(hash, mod, parent_hash)
+      # Register a block extension - applied to objects of the defining module.
+      # This is in contrast to the other mixin types which are applied to subordinate objects.
+      def register_mixin_block(target_class, options)
+        mixin_registry[target_class]['*'] = [:block, options]
+      end
+
+      def extend_hash(hash, mod, parent_hash, block)
         if !parent_hash.nil? && hash.nil?
           hash = AngryHash.new
         end
@@ -57,6 +57,11 @@ class AngryHash
         hash.extend mod
 
         hash.__parent_hash = parent_hash if hash.respond_to?(:__parent_hash=)
+
+        if block
+          hash.instance_eval(&block)
+        end
+
         hash
       end
 
@@ -71,29 +76,44 @@ class AngryHash
         if mixin = mixin_registry[extension][field.to_s]
           kind,mod,options = *mixin
 
+          if options[:allow_nil] && obj.nil?
+            return nil
+          end
+
           if options.key?(:default) && obj.nil?
             obj = options[:default]
           end
 
+
+
+          # the result of `extend_self` block
+          extend_self = if (sub_ext = mixin_registry[mod]['*']) && sub_ext[0] == :block
+                          sub_ext[1][:block]
+                        end
+
           case kind
           when :single
-            obj = extend_hash(obj,mod,parent_obj)
+            obj = extend_hash(obj,mod,parent_obj,extend_self)
           when :array
             # XXX - this is ok for now... we really need to typecheck, perhaps wrap in a smart-array
             obj ||= []
-            obj = obj.map {|elt| extend_hash(elt, mod, parent_obj)}
+            obj = obj.map! {|elt| extend_hash(elt, mod, parent_obj, extend_self) }
           when :hash
             obj ||= {}
-            obj = obj.inject(AngryHash.new) do |h,(k,elt)|
-              h[k] = extend_hash(elt,mod,parent_obj)
+            obj.replace( obj.inject(AngryHash.new) {|h,(k,elt)|
+              h[k] = extend_hash(elt,mod,parent_obj, extend_self)
               h
-            end
+            })
           end
+          
+          
         end
 
         obj
       end
-    end
+    end # Extension module methods
+
+    ## Instance methods
 
     def [](key)
       Extension.mixin_to(self,key,super)
@@ -105,10 +125,12 @@ class AngryHash
 
     def dup_with_extension
       dup.tap {|new_hash|
-        new_hash.extend(__angry_hash_extension) if __angry_hash_extension
+        AngryHash.copy_extension(self,new_hash)
       }
     end
 
+    ## AngryHash extension attributes
+    # These should be copied using `AngryHash.copy_extension` when duping
     def __parent_hash=(hash)
       @__parent_hash = hash
     end
@@ -125,6 +147,7 @@ class AngryHash
       @__angry_hash_extension
     end
 
+
     module ClassMethods
       def defaults(default_form=nil)
         if default_form
@@ -151,6 +174,11 @@ class AngryHash
         Extension.register_mixin_hash(self,field,mod,options)
       end
 
+      def extend_self(options={}, &block)
+        options[:block] = block
+        Extension.register_mixin_block(self,options)
+      end
+
       def build(seed={})
         AngryHash[ seed ].tap {|hash|
           self.fill_in_defaults(hash)

data/lib/angry_hash/extension_aware.rb

@@ -0,0 +1,54 @@
+class AngryHash
+  ## Adds extension awareness to core AngryHash copying methods
+  module ExtensionAware
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def [](seed)
+        super.tap {|hash|
+          copy_extension(seed,hash)
+        }
+      end
+
+      def __convert(hash,cycle_watch=[])
+        super.tap {|new_hash|
+          copy_extension(hash,new_hash)
+        }
+      end
+
+      def new_extended(mod,seed={})
+        self[ seed ].tap {|hash| hash.extend(mod) }
+      end
+
+      def dup_with_extension(other)
+        if AngryHash === other
+          other.respond_to?(:dup_with_extension) ? other.dup_with_extension : other.dup
+        elsif Hash === other
+          dup_with_extension(AngryHash[other])
+        elsif
+          other.dup
+        end
+      end
+
+      def copy_extension(from,to_hash)
+        to_hash.tap {|to| 
+          to.extend(from.__angry_hash_extension) if from.respond_to?(:__angry_hash_extension)
+          to.__parent_hash = from.__parent_hash  if to.respond_to?(:__parent_hash=) && from.respond_to?(:__parent_hash)
+        }
+      end
+
+      # Given a hash, detect whether it's extended & by which module.
+      def extended_with(hash)
+        hash.__angry_hash_extension if hash.respond_to?(:__angry_hash_extension)
+      end
+    end
+
+    def reverse_deep_merge(other_hash)
+      super.tap {|merged|
+        self.class.copy_extension(self,merged)
+      }
+    end
+  end
+end

data/lib/angry_hash/initialiser.rb

@@ -0,0 +1,11 @@
+class AngryHash
+  module Initialiser
+    def [](other=nil)
+      if other
+        super(__convert(other))
+      else
+        new
+      end
+    end
+  end
+end

data/lib/angry_hash/merging.rb

@@ -0,0 +1,56 @@
+class AngryHash
+  module Merging
+    def self.included(base)
+      base.class_eval do
+        alias_method :regular_merge, :merge unless method_defined?(:regular_merge)
+      end
+    end
+
+
+    ## Merging
+
+    # Shallow merge hash.
+    def merge(hash)
+      super(__convert_without_dup(hash))
+    end
+
+    # Shallow merge! hash.
+    def merge!(other_hash)
+      other_hash.each_pair { |key, value| dup_and_store(key,value) }
+      self
+    end
+    alias_method :update, :merge!
+
+
+    # Merge deeply. The other hash's contents are favoured.
+    def deep_merge(other_hash)
+      other_hash = AngryHash[other_hash]
+
+      self.regular_merge( other_hash ) do |key, oldval, newval|
+        oldval = __convert_value(oldval)
+        newval = __convert_value(newval)
+
+        AngryHash === oldval && AngryHash === newval ? oldval.deep_merge(newval) : newval
+      end
+    end
+
+    # Merge deeply, replacing the AngryHash with the result.
+    def deep_merge!(other_hash)
+      replace(deep_merge(other_hash))
+      self
+    end
+    alias_method :deep_update, :deep_merge!
+
+    # Merge deeply in reverse. This hash's contents are favoured.
+    def reverse_deep_merge(other_hash)
+      __convert(other_hash).deep_merge(self)
+    end
+
+    # Merge deeply in reverse, replacing this AngryHash with the result. This hash's contents are favoured.
+    def reverse_deep_merge!(other_hash)
+      replace(reverse_deep_merge(other_hash))
+      self
+    end
+    alias_method :reverse_deep_update, :reverse_deep_merge!
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Lachie Cox
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-30 00:00:00 +10:00
+date: 2010-10-20 00:00:00 +11:00
 default_executable: 
 dependencies: []
 
@@ -36,9 +36,14 @@ files:
 - VERSION
 - angry_hash.gemspec
 - lib/angry_hash.rb
+- lib/angry_hash/conversion/by_reference.rb
+- lib/angry_hash/conversion/duplicating.rb
 - lib/angry_hash/dsl.rb
 - lib/angry_hash/extension.rb
+- lib/angry_hash/extension_aware.rb
+- lib/angry_hash/initialiser.rb
 - lib/angry_hash/merge_string.rb
+- lib/angry_hash/merging.rb
 - LICENSE
 - README.md
 has_rdoc: true
@@ -77,6 +82,6 @@ test_files:
 - examples/dsl.eg.rb
 - examples/dup_eg.rb
 - examples/eg_helper.rb
-- examples/extension_tracking.rb
+- examples/extension_tracking.eg.rb
 - examples/merge_eg.rb
 - examples/normal_hash.eg.rb