angry_mob 0.1.0

data/vendor/angry_hash/angry_hash.gemspec

@@ -0,0 +1,47 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{angry_hash}
+  s.version = "0.1.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-07}
+  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",
+     "Rakefile",
+     "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/merge_string.rb"
+  ]
+  s.homepage = %q{http://github.com/plus2/angry_hash}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A stabler mash with different emphases.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/vendor/angry_hash/examples/accessors_eg.rb

@@ -0,0 +1,46 @@
+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
+
+eg 'accessor?' do
+  Assert(   @a.b? )
+  Assert( ! @a.c? )
+  Assert(   @a.b.c? )
+  Assert( ! @a.b.x? )
+
+  @a.b.f = false
+
+  Assert( ! @a.b.f? )
+end

data/vendor/angry_hash/examples/creation_eg.rb

@@ -0,0 +1,43 @@
+require 'eg_helper'
+
+eg.helpers do
+  def oids(v)
+    sub = case v 
+          when Hash
+            hh = {}
+            v.each {|kk,vv| hh[kk] = oids(vv)}
+            hh
+          when Array
+            v.map {|vv| oids(vv)}
+          else
+            v
+          end
+
+    n = {:class => v.class, :oid => v.__id__, :sub => sub}
+    if v.respond_to?(:__id__)
+      n[:oid] = v.__id__
+    else
+      n[:oid] = 0
+    end
+    n
+  end
+end
+
+eg 'creation duplicates' do
+  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)
+
+  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

data/vendor/angry_hash/examples/dsl.eg.rb

@@ -0,0 +1,18 @@
+require 'eg_helper'
+
+eg 'eval a block as dsl' do
+  original = AngryHash[ :a => 'x', :b => {:c => 1}, :d => 'z' ]
+
+  original.__eval_as_dsl do
+    foo 'bar'
+    a 'y'
+    b :e => 2
+  end
+
+  Assert(original.foo == 'bar')
+  Assert(original.a   == 'y')
+  Assert(original.d   == 'z')
+
+  Assert(original.b.c == 1)
+  Assert(original.b.e == 2)
+end

data/vendor/angry_hash/examples/dup_eg.rb

@@ -0,0 +1,86 @@
+require 'eg_helper'
+
+require 'angry_hash/extension_tracking'
+AngryHash.send :include, AngryHash::ExtensionTracking
+
+eg.setup do
+  @original = { 'database' => {
+    "micropower_micropower_sandbox" => {"app_owner" => "micropower_micropower_sandbox", "server" => :db},
+    "post_froggy"                   => {"app_owner" => "froggy_owner", "backup"                  => {"to_s3"                       => true}, "server" => :postfrog},
+    "myfrogdb"                      => {"app_owner" => :myfroggy, "server"                       => :myfrog},
+    "eggs_hwag"                     => {"app_owner" => "eggs_hwag", "backup"                     => {"to_s3"                       => true}, "server" => :db},
+    "isg_sandbox_v5"                => {"app_owner" => "isg_sandbox_v5", "server"                => :isg_forums_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
+
+def same_obj(a,b)
+  a.__id__ == b.__id__
+end
+
+def diff_obj(a,b)
+  ! same_obj(a,b)
+end
+
+eg 'dup is deep' do
+  ah  = AngryHash[ @original ]
+  ah2 = ah.dup
+
+  Assert( diff_obj ah                            , ah2 )
+  Assert( diff_obj ah.database                   , ah2.database )
+  Assert( diff_obj ah.database.post_froggy       , ah2.database.post_froggy )
+  Assert( diff_obj ah.database.post_froggy.backup, ah2.database.post_froggy.backup )
+
+end
+
+module Extendo
+  def as_dag
+    dag = dup
+    dag
+  end
+
+  def is_extended?
+    true
+  end
+end
+
+eg 'duping from ext' do
+  ah = AngryHash[ @original ]
+  ah.extend(Extendo)
+
+  ah2 = ah.as_dag
+
+  Show( ah.__id__ )
+  Show( ah2.__id__ )
+  
+  Show( ah2 )
+end
+
+module ExtendoDb
+  def is_db_extended?
+    true
+  end
+end
+
+eg 'extension preservation' do
+  ah = AngryHash[ @original ]
+  Assert( ! ah.is_extended? )
+  Assert( ! ah.database.post_froggy.is_db_extended? )
+
+  ah.extend(Extendo)
+  ah.database.post_froggy.extend(ExtendoDb)
+
+  Assert(   ah.is_extended? )
+  Assert(   ah.database.post_froggy.is_db_extended? )
+
+  ah2 = ah.dup
+  Show( ah2.is_extended? )
+  Show( ah2.database.post_froggy.is_db_extended? )
+end

data/vendor/angry_hash/examples/eg_helper.rb

@@ -0,0 +1,24 @@
+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'
+
+class Object
+  def tapp(tag=nil)
+    print "#{tag}=" if tag
+    pp self
+    self
+  end
+end

data/vendor/angry_hash/examples/merge_eg.rb

@@ -0,0 +1,135 @@
+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")
+
+  Show( merged )
+  Assert( merged.keys[1].is_a?(String) )
+end

data/vendor/angry_hash/lib/angry_hash.rb

@@ -0,0 +1,215 @@
+
+class AngryHash < Hash
+  require 'angry_hash/dsl'
+  include AngryHash::DSL
+
+  def self.[](other)
+    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_update, :update unless method_defined?(:regular_update)
+
+  def []=(key, value)
+    regular_writer(__convert_key(key), self.class.__convert_value_without_dup(value))
+  end
+
+  def [](key)
+    regular_reader(__convert_key(key))
+  end
+
+  def id
+    regular_reader('id')
+  end
+
+  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 :update, :merge!
+
+  def dup
+    self.class[ self ]
+  end
+
+  def deep_merge(other_hash)
+    # XXX this should convert other to AHash!
+    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!
+
+
+
+  def key?(key)
+    super(__convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def fetch(key, *extras)
+    super(__convert_key(key), *extras)
+  end
+  def values_at(*indices)
+    indices.collect {|key| self[__convert_key(key)]}
+  end
+
+  def delete(key)
+    super __convert_key(key)
+  end    
+
+  def to_hash
+    self
+  end
+
+  def to_normal_hash
+    __to_hash(self)
+  end
+  def __to_hash(value,cycle_guard={})
+    return cycle_guard[value.hash] if cycle_guard.key?(value.hash)
+
+    case value
+    when Hash
+      new_hash = cycle_guard[value.hash] = {}
+
+      value.inject(new_hash) do |hash,(k,v)|
+        hash[k] = __to_hash(v,cycle_guard)
+      hash
+      end
+    when Array
+      new_array = cycle_guard[value.hash] = []
+
+      value.each {|v| new_array << __to_hash(v,cycle_guard)}
+    else
+      value
+    end
+  end
+
+
+  def method_missing(method,*args,&blk)
+    method_s = method.to_s
+
+    key = method_s[0..-2]
+
+    case method_s[-1]
+    when ?=
+      return super unless args.size == 1 && !block_given?
+      self[ key ] = args.first
+
+    when ??
+      return super unless args.empty? && !block_given?
+      !! self[key]
+
+    when ?!
+      return super unless args.empty?
+      self[key] = AngryHash.new unless self.key?(key)
+      self[key]
+
+    else
+      return super unless args.empty? && !block_given?
+      self[method_s]
+    end
+  end
+
+  def __convert_key(key)
+    Symbol === key ? key.to_s : key
+  end
+  def self.__convert_key(key)
+    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
+        v
+      else
+        v.dup
+      end
+    ensure
+      cycle_watch.pop
+    end
+  end
+  
+end
+
+