angry_hash 0.1.1 → 0.2.0

data/Changelog.md

@@ -0,0 +1,5 @@
+## 0.2.0
+
+Features:
+
+  - Extension tracking extracted from PeaceLove. PeaceLove will use this in favour of its own implementation in the its version.

data/License

@@ -0,0 +1,19 @@
+Copyright (c) 2010 PLUS2 Pty. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -7,7 +7,8 @@ begin
     gemspec.email = "lachie@plus2.com.au"
     gemspec.homepage = "http://github.com/plus2/angry_hash"
     gemspec.authors = ["Lachie Cox"]
-    gemspec.test_files = []
+    gemspec.test_files = Dir['examples/**/*']
+    gemspec.files -= gemspec.test_files
     gemspec.executables = []
   end
   Jeweler::GemcutterTasks.new

data/Readme.md

@@ -0,0 +1,114 @@
+# AngryHash
+
+A stabler mash with different emphases.
+
+# Install
+
+    gem install angry_hash
+
+# Usage
+    grr = AngryHash[]   #=> {}
+    grr = AngryHash.new #=> {}
+
+    grr = AngryHash[ :look => { :a => ['hash'] } ]
+
+    # reach into the hash using dot notation
+    grr.look.a[0] #=> 'hash'
+
+    # instantiate a sub-hash (idempotently):
+    grr.look.another       #=> nil
+    grr.look.another!.one = "nice"
+
+    grr.look.another!.one #=> "nice"
+    grr.look.another.one  #=> "nice"
+
+    # truth in hashes
+    grr.green  = true
+    grr.yellow = [:goldenrod,:canary]
+    grr.red    = false
+
+    grr.green?  #=> true
+    grr.yellow? #=> true
+    grr.red?    #=> false
+    grr.blue?   #=> false
+
+
+## Merging Deeply
+
+### Merge
+
+Deep merges are non-destructive, as in normal hash merges.
+
+Merge favours the other hash's keys. Reverse merge favours the target's keys.
+
+    grr = AngryHash[ :a => {:b => :c}, :z => :x ]
+    arr = AngryHash[ :a => {:d => :e}, :z => :y ]
+
+    grr.deep_merge( arr )         #=> {"a" => {"b" => :c, "d" => :e}, "z" => :y}
+    grr.reverse_deep_merge( arr ) #=> {"a" => {"b" => :c, "d" => :e}, "z" => :x}
+
+    # grr & arr are unmodified
+    grr #=> { "a" => {"b" => :c}, "z" => :x }
+    arr #=> { "a" => {"d" => :e}, "z" => :y }
+
+### Update
+
+Deep updates replace the contents of the hash with the merged version.
+
+They're also known as `deep_merge!` and `reverse_deep_merge!`
+
+    grr = AngryHash[ :a => {:b => :c}, :z => :x ]
+    arr = AngryHash[ :a => {:d => :e}, :z => :y ]
+
+    grr.deep_update( arr )
+
+    # grr is updated, arr is unmodified
+    grr #=> { "a" => {"b" => :c, "d" => :e}, "z" => :y }
+    arr #=> { "a" => {"d" => :e}, "z" => :y }
+
+    grr.reverse_deep_update( arr )
+
+    # grr is updated, arr is unmodified
+    grr #=> { "a" => {"b" => :c,  "d" => :e}, "z" => :x }
+    arr #=> { "a" => {"d" => :e}, "z" => :y }
+    
+# Extensions
+
+`TODO` write up this section.
+
+# Gotchas
+
+## AngryHashes are Hashes
+
+This is good and bad. Its good because you can use all the normal hash methods.
+
+    AngryHash[ :a => :b, :c => :d ].each {|k,v| ... }
+
+Unfortunately this also means that that if your hash keys collide with the names of Hash methods (or those of its ancestors) you can't use dot notation:
+
+    h = AngryHash[ :hash => 'hooray' ]
+
+    h.hash    #=> 12345...
+    h['hash'] #=> 'hooray'
+    h[:hash]  #=> 'hooray'
+    
+I'm planning on creating a sanitised `AngryProxy` to wrap `AngryHash`es for the times you really want guaranteed access via dot notation.
+
+## id
+
+Since `Object#id` is deprecated in Ruby 1.8 and has been removed in 1.9, I decided it was safe to override `id` in `AngryHash`:
+
+    h = AngryHash[ :id => 'abc' ]
+
+    h.id     #=> 'abc'
+    h.__id__ #=> 12345...
+
+# About
+
+`AngryHash`'s code is hosted on GitHub and can be found at http://github.com/plus2/angry_hash
+
+Please report problems at http://github.com/plus2/angry_hash/issues.
+
+`AngryHash` is by Lachie Cox for PLUS2 & YesMaster.
+
+You're free to use AngryHash under the MIT license; see License for details.

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/angry_hash.gemspec

@@ -5,27 +5,24 @@
 
 Gem::Specification.new do |s|
   s.name = %q{angry_hash}
-  s.version = "0.1.1"
+  s.version = "0.2.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-23}
+  s.date = %q{2010-08-25}
   s.description = %q{A stabler mash with different emphases. Used in plus2 projects AngryMob and Igor.}
   s.email = %q{lachie@plus2.com.au}
   s.files = [
     ".gitignore",
+     "Changelog.md",
+     "License",
      "Rakefile",
+     "Readme.md",
      "VERSION",
      "angry_hash.gemspec",
-     "examples/accessors_eg.rb",
-     "examples/creation_eg.rb",
-     "examples/dsl.eg.rb",
-     "examples/dup_eg.rb",
-     "examples/eg_helper.rb",
-     "examples/merge_eg.rb",
      "lib/angry_hash.rb",
      "lib/angry_hash/dsl.rb",
-     "lib/angry_hash/extension_tracking.rb",
+     "lib/angry_hash/extension.rb",
      "lib/angry_hash/merge_string.rb"
   ]
   s.homepage = %q{http://github.com/plus2/angry_hash}
@@ -33,6 +30,15 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{A stabler mash with different emphases.}
+  s.test_files = [
+    "examples/accessors_eg.rb",
+     "examples/creation_eg.rb",
+     "examples/dsl.eg.rb",
+     "examples/dup_eg.rb",
+     "examples/eg_helper.rb",
+     "examples/extension_tracking.rb",
+     "examples/merge_eg.rb"
+  ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/examples/extension_tracking.rb

@@ -0,0 +1,106 @@
+require 'eg_helper'
+require 'angry_hash/extension'
+
+module Fixtures
+  module CreditCard
+    def valid?
+      number % 2 == 1
+    end
+  end
+  module Course
+    def shouty
+      name.upcase
+    end
+  end
+
+  module PhoneNumber
+    def country_code
+      number.to_s[/^\+(\d+)/,1].to_i
+    end
+  end
+
+  module User
+    include AngryHash::Extension
+
+    extend_value :credit_card, CreditCard
+    extend_array :courses, Course
+    extend_hash :phone_numbers, PhoneNumber
+
+    extend_hash :parents, User
+
+    def shouty
+      name.upcase
+    end
+  end
+
+end
+
+eg 'tracks extensions to values' do
+  user = AngryHash[ :name => 'Bob', :credit_card => {:number => 123} ]
+  user.extend Fixtures::User
+
+  Assert( user.shouty == 'BOB' )
+  Assert( user.credit_card.number == 123 )
+  Assert( user.credit_card.valid? )
+
+  user.credit_card.number = 456
+  Assert( ! user.credit_card.valid? )
+end
+
+eg 'tracks extensions to hashes' do
+  user = AngryHash[ :name => 'Bob', :credit_card => {:number => 123}, :phone_numbers => {:home => {:number => '0404555111'}, :chalet => {:number => '+12 9481 1111'}} ]
+  user.extend Fixtures::User
+
+  Assert( user.phone_numbers.home.country_code == 0 )
+  Assert( user.phone_numbers.chalet.country_code == 12 )
+end
+
+eg 'tracks extensions to arrays' do
+  user = AngryHash[ :name => 'Bob', :credit_card => {:number => 123}, :courses => [ {:name => 'Money for artists'}, {:name => 'Papier mache with your fortune'} ] ]
+  user.extend Fixtures::User
+
+  Assert( user.courses[0].shouty == 'MONEY FOR ARTISTS' )
+  Assert( user.courses[1].shouty == 'PAPIER MACHE WITH YOUR FORTUNE' )
+end
+
+eg 'tracks deep and reflexive extensions' do
+  user = AngryHash.new_extended( Fixtures::User, :name => 'Bob', 
+      :parents => {
+          :mum => {:name => 'Maggie', :parents => {:dad => {:name => 'Bill'}, :mum => {:name => 'Nancy'}}},
+          :dad => {:name => 'John'}
+      }
+  )
+
+  Assert( user.parents.mum.parents.dad.shouty == 'BILL' )
+end
+
+eg 'extensions persist with dup_with_extension' do
+  user = AngryHash[ :name => 'Bob', :credit_card => {:number => 123} ]
+  user.extend Fixtures::User
+
+  Assert( user.credit_card.valid? )
+
+  # new_user is expected to be extended
+  new_user   = user.dup_with_extension
+
+  # clean_user is expected *not* to be extended
+  clean_user = user.dup
+
+  # make sure dup worked
+  Assert( user.__id__ != new_user.__id__ )
+  Assert( user.__id__ != clean_user.__id__  )
+
+  # make sure dup worked deeply
+  Assert( user.credit_card.__id__ != new_user.credit_card.__id__ )
+  Assert( user.credit_card.__id__ != clean_user.credit_card.__id__ )
+
+  # the non-extended user's CC is invalid because `valid?` is accessing a nil value in the hash, rather than calling the method `valid?`
+  Assert(   clean_user.credit_card.number == 123 )
+  Assert( ! clean_user.credit_card.valid? )
+  Assert( defined?( clean_user.credit_card.valid? ) == nil )
+
+  # extended user's CC is valid. `valid?` refers to the method on the `CreditCard` module.
+  Assert(   new_user.credit_card.number == 123 )
+  Assert(   new_user.credit_card.valid? )
+  Assert( defined?( new_user.credit_card.valid? ) == 'method' )
+end

data/lib/angry_hash/extension.rb

@@ -0,0 +1,162 @@
+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)
+        base.extend ClassMethods
+
+        base.module_eval do
+          def self.extend_object(obj)
+            super
+            Extension.mark_extension(obj,self)
+          end
+        end
+      end
+
+      def mark_extension(hash,mod)
+        #puts "mark_extension hash=#{hash.class} mod=#{mod}"
+        
+        if (previous_mod = hash.__angry_hash_extension) && previous_mod != mod
+          raise "hash #{hash} has already been extended by a different AngryHash::Extension (was: #{previous_mod}, now: #{mod})"
+        end
+        hash.__angry_hash_extension = mod
+
+        setup_extended_hash(hash,mod)
+      end
+
+      # A record of extensions to fields of classes.
+      def mixin_registry
+        @mixin_registry ||= Hash.new {|h,k| h[k] = {}}
+      end
+
+      # Register a value extension
+      def register_mixin(target_class,field,mod,options)
+        mixin_registry[target_class][field.to_s] = [:single, mod, options]
+      end
+
+      # Register an array extension
+      def register_mixin_array(target_class, field, mod, options)
+        mixin_registry[target_class][field.to_s] = [:array, mod, options]
+      end
+
+      # Register a hash extension
+      def register_mixin_hash(target_class, field, mod, options)
+        mixin_registry[target_class][field.to_s] = [:hash, mod, options]
+      end
+
+      def extend_hash(hash, mod, parent_hash)
+        if !parent_hash.nil? && hash.nil?
+          hash = AngryHash.new
+        end
+
+        hash.extend mod
+
+        hash.__parent_hash = parent_hash if hash.respond_to?(:__parent_hash=)
+        hash
+      end
+
+      def setup_extended_hash(hash, mod)
+        mod.fill_in_defaults(hash) if mod.respond_to?(:fill_in_defaults)
+        hash
+      end
+
+      def mixin_to(parent_obj, field, obj)
+        extension = parent_obj.__angry_hash_extension
+
+        if mixin = mixin_registry[extension][field.to_s]
+          kind,mod,options = *mixin
+
+          if options.key?(:default) && obj.nil?
+            obj = options[:default]
+          end
+
+          case kind
+          when :single
+            obj = extend_hash(obj,mod,parent_obj)
+          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)}
+          when :hash
+            obj ||= {}
+            obj = obj.inject(AngryHash.new) do |h,(k,elt)|
+              h[k] = extend_hash(elt,mod,parent_obj)
+              h
+            end
+          end
+        end
+
+        obj
+      end
+    end
+
+    def [](key)
+      Extension.mixin_to(self,key,super)
+    end
+
+    def id
+      self['id']
+    end
+
+    def dup_with_extension
+      dup.tap {|new_hash|
+        new_hash.extend(__angry_hash_extension) if __angry_hash_extension
+      }
+    end
+
+    def __parent_hash=(hash)
+      @__parent_hash = hash
+    end
+
+    def __parent_hash
+      @__parent_hash
+    end
+
+    def __angry_hash_extension=(mod)
+      @__angry_hash_extension = mod
+    end
+
+    def __angry_hash_extension
+      @__angry_hash_extension
+    end
+
+    module ClassMethods
+      def defaults(default_form=nil)
+        if default_form
+          @default_form = default_form
+        end
+        @default_form
+      end
+
+      def fill_in_defaults(hash)
+        if defaults
+          hash.reverse_deep_update(defaults)
+        end
+      end
+
+      def extend_value(field,mod,options={})
+        Extension.register_mixin(self,field,mod,options)
+      end
+
+      def extend_array(field,mod,options={})
+        Extension.register_mixin_array(self,field,mod,options)
+      end
+
+      def extend_hash(field,mod,options={})
+        Extension.register_mixin_hash(self,field,mod,options)
+      end
+
+      def build(seed={})
+        AngryHash[ seed ].tap {|hash|
+          self.fill_in_defaults(hash)
+          hash.extend self
+        }
+      end
+    end
+  end
+end

data/lib/angry_hash.rb

@@ -1,10 +1,15 @@
 
 class AngryHash < Hash
+  # config
   require 'angry_hash/dsl'
   include AngryHash::DSL
 
-  def self.[](other)
-    super(__convert(other))
+  def self.[](other=nil)
+    if other
+      super(__convert(other))
+    else
+      new
+    end
   end
 
   alias_method :regular_writer, :[]=    unless method_defined?(:regular_writer)

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Lachie Cox
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-23 00:00:00 +10:00
+date: 2010-08-25 00:00:00 +10:00
 default_executable: 
 dependencies: []
 
@@ -28,18 +28,15 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- Changelog.md
+- License
 - Rakefile
+- Readme.md
 - VERSION
 - angry_hash.gemspec
-- examples/accessors_eg.rb
-- examples/creation_eg.rb
-- examples/dsl.eg.rb
-- examples/dup_eg.rb
-- examples/eg_helper.rb
-- examples/merge_eg.rb
 - lib/angry_hash.rb
 - lib/angry_hash/dsl.rb
-- lib/angry_hash/extension_tracking.rb
+- lib/angry_hash/extension.rb
 - lib/angry_hash/merge_string.rb
 has_rdoc: true
 homepage: http://github.com/plus2/angry_hash
@@ -71,5 +68,11 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A stabler mash with different emphases.
-test_files: []
-
+test_files: 
+- examples/accessors_eg.rb
+- examples/creation_eg.rb
+- examples/dsl.eg.rb
+- examples/dup_eg.rb
+- examples/eg_helper.rb
+- examples/extension_tracking.rb
+- examples/merge_eg.rb

data/lib/angry_hash/extension_tracking.rb

@@ -1,12 +0,0 @@
-class AngryHash
-	module ExtensionTracking
-		def self.included(base)
-			# base.extend ClassMethods
-		end
-	end
-
-	def extend(mod)
-		puts "extending AH #{__id__} with #{mod}"
-		super
-	end
-end