angry_hash 0.0.3 → 0.0.4

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/angry_hash.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{angry_hash}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lachie Cox"]
-  s.date = %q{2010-04-29}
+  s.date = %q{2010-05-19}
   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 = [
@@ -17,8 +17,11 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "angry_hash.gemspec",
+     "examples/accessors_eg.rb",
      "examples/creation_eg.rb",
+     "examples/dup_eg.rb",
      "examples/eg_helper.rb",
+     "examples/merge_eg.rb",
      "lib/angry_hash.rb",
      "lib/angry_hash/merge_string.rb"
   ]

data/examples/accessors_eg.rb

@@ -0,0 +1,35 @@
+require 'eg_helper'
+
+eg.setup do
+  @a = AngryHash[
+    :b => { 
+      :c => 'c',
+      :d => 'd' 
+    }
+  ]
+end
+
+def same_obj(a,b)
+  a.__id__ == b.__id__
+end
+
+eg 'accessor! with existing subhash' do
+  Assert( same_obj( @a.b!, @a.b ) )
+end
+
+eg 'accessor! creating and returning' do
+  d = @a.d!
+  Assert( same_obj( d, @a.d ) )
+end
+
+eg 'accessor= AngryHash' do
+  d    = AngryHash.new
+  @a.d = d
+  Assert( same_obj( d, @a.d ) )
+end
+
+eg 'accessor= Hash' do
+  d = {}
+  @a.d = d
+  Assert( ! same_obj( d, @a.d ) )
+end

data/examples/creation_eg.rb

@@ -24,15 +24,19 @@ eg.helpers do
 end
 
 eg 'creation duplicates' do
-  a1 = AngryHash[ :a => { :b => 1 }, :c => [ 1, :d, {:e => :f}, nil, true, false, 1.0, [ 'x', 'y' ] ] ]
+  a1 = AngryHash[ 
+    :a => { :b => 1 },
+    :c => [ 1, :d, {:e => :f}, nil, true, false, 1.0, [ 'x', 'y' ] ] 
+  ]
   a2 = AngryHash[ a1 ]
 
   pp oids(a1)
   pp oids(a2)
 
-  Check(a1.c[2].__id__ != a2.c[2].__id__).is(true)
-  Check(a1.c[7].__id__ != a2.c[7].__id__).is(true)
+  Assert(a1.a.__id__ != a2.a.__id__)
+  Assert(a1.c[2].__id__ != a2.c[2].__id__)
+  Assert(a1.c[7].__id__ != a2.c[7].__id__)
 end
 
-eg 'cycle detection' do
-end
+#eg 'cycle detection' do
+#end

data/examples/dup_eg.rb

@@ -0,0 +1,68 @@
+require 'eg_helper'
+
+eg.setup do
+  @original = { 'database' => {
+    "micropower_micropower_sandbox"=>
+    {"app_owner"=>"micropower_micropower_sandbox", "server"=>:db},
+      "amc_accred_staging"=>
+    {"app_owner"=>"amc_accred", "server"=>:plus2staging_local_mysql},
+      "post_froggy"=>
+    {"app_owner"=>"froggy_owner",
+      "backup"=>{"to_s3"=>true},
+      "server"=>:postfrog},
+      "isg_url_shortener"=>
+    {"app_owner"=>"isg_sandbox_v5", "server"=>:isg_forums_mysql},
+      "isg_forums"=>{"app_owner"=>"isg_forums", "server"=>:isg_forums_mysql},
+      "eggs_eggs"=>
+    {"app_owner"=>"eggs_eggs",
+      "backup"=>{"to_s3"=>true},
+      "server"=>:db,
+      "admin_owner"=>"eggs_admin"},
+      "myfrogdb"=>{"app_owner"=>:myfroggy, "server"=>:myfrog},
+      "amc_exam_staging"=>
+    {"app_owner"=>"amc_exam", "server"=>:plus2staging_local_mysql},
+      "micropower_golfo"=>{"app_owner"=>:golfo, "server"=>:linode_golfo_mysql},
+      "linode_golfo"=>{"app_owner"=>:golfo, "server"=>:linode_golfo_mysql},
+      "halal_staging"=>
+    {"app_owner"=>"halal", "server"=>:plus2staging_local_postgres},
+      "eggs_enag"=>
+    {"app_owner"=>"eggs_enag", "backup"=>{"to_s3"=>true}, "server"=>:db},
+      "amc_store"=>
+    {"app_owner"=>"amc_store", "backup"=>{"to_s3"=>true}, "server"=>:amc},
+      "weatherzone_wengine"=>
+    {"app_owner"=>"weatherzone_wengine", "server"=>:linode_postgres},
+      "weatherzone_wzfb_staging"=>
+    {"app_owner"=>"weatherzone_wzfb_staging", "server"=>:db},
+      "amc_ncmr"=>
+    {"app_owner"=>"amc_ncmr", "backup"=>{"to_s3"=>true}, "server"=>:amc},
+      "westpac_thinkbank_staging"=>
+    {"app_owner"=>"westpac_thinkbank_staging", "server"=>:db},
+      "micropower_micropower_staging"=>
+    {"app_owner"=>"micropower", "server"=>:staging_mysql},
+      "weatherzone_wx_staging"=>
+    {"app_owner"=>"weatherzone_wx_staging", "server"=>:db},
+      "isg_sandbox_v4"=>
+    {"app_owner"=>"isg_sandbox_v5", "server"=>:isg_forums_mysql},
+      "eggs_aecl"=>
+    {"app_owner"=>"eggs_aecl", "backup"=>{"to_s3"=>true}, "server"=>:db},
+      "eggs_hwag"=>
+    {"app_owner"=>"eggs_hwag", "backup"=>{"to_s3"=>true}, "server"=>:db},
+      "plus2_gemcutter"=>{"app_owner"=>"plus2_gemcutter", "server"=>:db},
+      "isg_sandbox_v5"=>
+    {"app_owner"=>"isg_sandbox_v5", "server"=>:isg_forums_mysql},
+      "amc_exam"=>
+    {"app_owner"=>"amc_exam", "backup"=>{"to_s3"=>true}, "server"=>:amc},
+      "weatherzone_wzfb"=>
+    {"app_owner"=>"weatherzone_wzfb", "backup"=>{"to_s3"=>true}, "server"=>:db},
+      "amc_store_staging"=>
+    {"app_owner"=>"amc_store", "server"=>:plus2staging_local_mysql}
+  }}    
+end
+
+eg 'duping copies symbols' do
+  ah = AngryHash[ @original ]
+  ah2 = AngryHash[ ah ]
+
+  Assert( ! ah2.database.isg_sandbox_v5.server.nil? )
+  Assert( ah2.database.isg_sandbox_v5.server == @original['database']['isg_sandbox_v5']['server'] )
+end

data/examples/eg_helper.rb

@@ -1,6 +1,16 @@
 require 'pathname'
 root = Pathname('../..').expand_path(__FILE__)
 require 'pp'
+
+UseGem = false
+
+if UseGem
+  require 'rubygems'
+  require 'angry_hash'
+else
+  $:.unshift root+'lib'
+  require root+'lib/angry_hash'
+end
+
+require 'rubygems'
 require 'exemplor'
-$:.unshift root+'lib'
-require 'angry_hash'

data/examples/merge_eg.rb

@@ -0,0 +1,134 @@
+require 'eg_helper'
+require 'yajl'
+
+eg.setup do
+  @a = AngryHash[
+    :b => { 
+      :c => 'c',
+      :d => 'd' 
+    }
+  ]
+
+  @b = AngryHash[
+    :b => {
+      :d => 'dd',
+      :e => 'e'
+    }
+  ]
+end
+
+def same_obj(a,b)
+  a.__id__ == b.__id__
+end
+
+eg 'merges' do
+  merged = @a.merge(@b)
+
+  Assert( ! same_obj( merged, @a ) )
+  Assert( ! same_obj( merged, @b ) )
+
+  Assert( ! merged.b.c? )
+  Assert( merged.b.d == 'dd' )
+  Assert( merged.b.e == 'e' )
+end
+
+eg 'merge dups' do
+  a = AngryHash[
+    :a => {:b => "cows"}
+  ]
+  b = AngryHash[
+    :a => {:c => "bows"}
+  ]
+
+  merged = a.merge(b)
+
+  Assert( ! same_obj( merged.a.b, a.a.b ) )
+  Assert(   same_obj( merged.a.c, b.a.c ) )
+end
+
+eg 'updates' do
+  merged = @a.update(@b)
+
+  Assert(   same_obj( merged, @a ) )
+  Assert( ! same_obj( merged, @b ) )
+
+  Assert( ! merged.b.c? )
+  Assert( merged.b.d == 'dd' )
+  Assert( merged.b.e == 'e' )
+end
+
+eg 'deep_merge' do
+  merged = @a.deep_merge(@b)
+
+  Show(merged)
+
+  Assert( ! same_obj( merged, @a ) )
+  Assert( ! same_obj( merged, @b ) )
+
+  Assert( merged.b.c == 'c')
+  Assert( merged.b.d == 'dd')
+  Assert( merged.b.e == 'e')
+end
+
+eg 'deep_update' do
+  rv = @a.deep_update(@b)
+
+  Show(@a)
+  Assert(   same_obj( rv, @a ) )
+  Assert( ! same_obj( @a, @b ) )
+
+  Assert( ! rv.nil? )
+  Assert( @a.b.c == 'c')
+  Assert( @a.b.d == 'dd')
+  Assert( @a.b.e == 'e')
+end
+
+eg 'reverse_deep_merge' do
+  merged = @a.reverse_deep_merge(@b)
+
+  Show(merged)
+  Assert( ! merged.nil? )
+  Assert( ! same_obj( merged, @a ) )
+  Assert( ! same_obj( merged, @b ) )
+
+  Assert( merged.b.c == 'c')
+  Assert( merged.b.d == 'd')
+  Assert( merged.b.e == 'e')
+end
+
+eg 'deep regression' do
+  provider = AngryHash[
+    :network => {
+      :public => {
+        :gateway => '69.164.204.1',
+        :netmask => '255.255.255.0'
+      },
+      :private => {
+        :netmask => '255.255.128.0'
+      }
+  }]
+
+  server = AngryHash[
+    :public_ip  => '72.14.191.135',
+    :private_ip => '192.168.146.105',
+    :network => {
+      :public => {:gateway => '72.14.191.1'}
+    }]
+
+  server.provider = provider
+  server.network!.reverse_deep_merge!(server.provider.network || {})
+
+  Show( Yajl::Encoder.encode( server ) )
+end
+
+eg 'merge with symbol key' do
+  orig = AngryHash[{
+    "hosts_db"=>:db,
+    "run_list"=>["role[database]"],
+    "provider"=>"octopus"
+  }]
+
+  merged = orig.merge(:key=>"db")
+
+  Assert( merged.keys[1].is_a?(String) )
+end

data/lib/angry_hash.rb

@@ -4,25 +4,39 @@ class AngryHash < Hash
     super(__convert(other))
   end
 
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-  alias_method :regular_reader, :[] unless method_defined?(:regular_reader)
+  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)
 
   def []=(key, value)
-    regular_writer(__convert_key(key), AngryHash.__convert_value(value))
+    regular_writer(__convert_key(key), self.class.__convert_value_without_dup(value))
   end
+
   def [](key)
     regular_reader(__convert_key(key))
   end
 
-  def update(other_hash)
-    other_hash.each_pair { |key, value| self[key] = value }
+  def dup_and_store(key,value)
+    regular_writer(__convert_key(key), self.class.__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 :merge!, :update
+  alias_method :update, :merge!
+
+  def dup
+    self.class[ self ]
+  end
 
   def deep_merge(other_hash)
-    self.merge(other_hash) do |key, oldval, newval|
+    self.regular_merge(other_hash) do |key, oldval, newval|
       oldval = AngryHash.__convert_value(oldval)
       newval = AngryHash.__convert_value(newval)
 
@@ -32,11 +46,20 @@ class AngryHash < Hash
 
   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(self.class.__convert_value(other_hash).deep_merge(self))
+    replace(reverse_deep_merge(other_hash))
+    self
   end
+  alias_method :reverse_deep_update, :reverse_deep_merge!
+
 
 
   def key?(key)
@@ -93,13 +116,15 @@ class AngryHash < Hash
 
     case method_s[-1]
     when ?=
+      #regular_writer(key,args.first)
       self[ key ] = args.first
 
     when ??
       !! self[key]
 
     when ?!
-      self[key] ||= AngryHash.new
+      self[key] = AngryHash.new unless self.key?(key)
+      self[key]
 
     else
       self[method_s]
@@ -113,27 +138,82 @@ class AngryHash < Hash
     Symbol === key ? key.to_s : key
   end
 
-  def self.__convert(hash)
-    hash.inject(AngryHash.new) do |hash,(k,v)|
-      hash[__convert_key(k)] = __convert_value(v)
-      hash
+
+  # 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(v)
+  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(v)
+      __convert_without_dup(v)
     when Array
-      v.map {|v| Hash === v ? __convert_value(v) : v}
+      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
+
+    #puts "re-extend? #{AngryHash === hash} #{hash.__extending_modules.inspect if (AngryHash === hash)}"
+    #if AngryHash === hash && hash.__extended?
+      #puts "rex"
+      #hash.__extending_modules.each {|mod| puts "rexmod=#{mod}"; new_hash.extend(mod)}
+    #end
+
+    new_hash
+  end
+
+  #def __extending_modules
+    #@extending_modules ||= []
+  #end
+  #def __extended?
+    #!__extending_modules.empty?
+  #end
+  #def extend(mod)
+    #puts "extending with #{mod}"
+    #__extending_modules << mod
+    #puts "extending mods: #{__extending_modules.inspect}"
+    #super
+  #end
+  
+
+
+  def self.__convert_value(v,cycle_watch={})
+    return if cycle_watch.key?(v.__id__)
+
+    original_v = v
+    v = v.to_hash if v.respond_to?(:to_hash)
+
+    case v
+    when Hash
+      cycle_watch[original_v.__id__] = true
+      __convert(v,cycle_watch)
+    when Array
+      cycle_watch[original_v.__id__] = true
+      v.map {|vv| __convert_value(vv,cycle_watch)}
+    when Fixnum,Symbol,NilClass,TrueClass,FalseClass,Float
+      v
+    else
+      cycle_watch[original_v.__id__] = true
+      v.dup
+    end
+  end
   
 end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Lachie Cox
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-29 00:00:00 +10:00
+date: 2010-05-19 00:00:00 +10:00
 default_executable: 
 dependencies: []
 
@@ -31,8 +31,11 @@ files:
 - Rakefile
 - VERSION
 - angry_hash.gemspec
+- examples/accessors_eg.rb
 - examples/creation_eg.rb
+- examples/dup_eg.rb
 - examples/eg_helper.rb
+- examples/merge_eg.rb
 - lib/angry_hash.rb
 - lib/angry_hash/merge_string.rb
 has_rdoc: true