ruby_ex 0.1.1

data/src/observable_pool.rb

@@ -0,0 +1,291 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: observable_pool.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+require 'observable'
+require 'thread'
+
+
+module ObservablePool
+
+  class Observer
+    include Observable
+
+    attr_reader :observable
+
+    def initialize(observable, mutex)
+      @observable = observable
+      @observable.add_observer(self)
+      @mutex = mutex
+    end
+
+    def update(*args, &block)
+      @mutex.synchronize do
+        changed
+        notify_observers(@observable, *args, &block)
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      @observable.send(meth, *args, &block)
+    end
+
+  end # class Observer
+
+  def add_observable(observable)
+    unless observable.is_a?(Observable)
+      raise(ArgumentError, "observable object must be Observale")
+    end
+    @observable_peer_mutex = Mutex.new unless defined? @observable_peer_mutex
+    @observable_peers = {} unless defined? @observable_peers
+    sync_observer = Observer.new(observable, @observable_peer_mutex)
+    @observable_peers[observable] = sync_observer
+    @global_observer_peers = [] unless defined? @global_observer_peers
+    @global_observer_peers.each do |observer|
+      sync_observer.add_observer(observer)
+    end
+    sync_observer
+  end
+
+  def add_observables(*observables)
+    observables.each { |observable| add_observable(observable) }
+  end
+
+  def delete_observable(observable)
+    @observable_peers.delete(observable) if defined? @observable_peers
+  end
+
+  def delete_observables
+    @observable_peers.clear if defined? @observable_peers
+  end
+
+  def observable(observable)
+    @observable_peers[observable] if defined? @observable_peers
+  end
+
+  def observable?(observable)
+    @observable_peers.has_key?(observable) if defined? @observable_peers
+  end
+
+  def list_observables
+    if defined? @observable_peers
+      @observable_peers.keys
+    else
+      []
+    end
+  end
+
+  def list_observables_observed(observer)
+    observables = []
+    if defined? @observable_peers
+      @observable_peers.each do |observable, obsv|
+        if obsv.list_observers.include?(observer)
+          observables << observable
+        end
+      end
+    end
+    observables
+  end
+
+  def count_observables
+    if defined? @observable_peers
+      @observable_peers.size
+    else
+      0
+    end
+  end
+
+  def each_observables(&block)
+    if defined? @observable_peers
+      @observable_peers.each do |observable, observer|
+        block[observable, observer]
+      end
+    end
+  end
+
+  def list_all_observers
+    observers = []
+    if defined? @observable_peers
+      @observable_peers.each do |observable, observer|
+        observers += observer.list_observers
+      end
+    end
+    observers.uniq
+  end
+
+  def count_all_observers
+    list_observers.size
+  end
+
+  def add_global_observer(observer)
+    if defined? @observable_peers
+      @observable_peers.each do |observable, obsv|
+        obsv.add_observer(observer) unless observable.observer?(observer)
+      end
+    end
+    @global_observer_peers = [] unless defined? @global_observer_peers
+    @global_observer_peers << observer
+  end
+
+  def add_global_observers(*observers)
+    observers.each { |observer| add_global_observer(observer) }
+  end
+
+  def delete_global_observer(observer)
+    if defined? @observable_peers
+      @observable_peers.each do |observable, obsv|
+        obsv.delete_observer(observer)
+      end
+    end
+    @global_observer_peers.delete(observer) if defined? @global_observer_peers
+  end
+
+  def delete_global_observers
+    if defined? @global_observer_peers
+      @global_observer_peers.dup.each do |global_observer|
+        delete_global_observer(global_observer)
+      end
+    end
+  end
+
+  def list_global_observers
+    if defined? @global_observer_peers
+      @global_observer_peers.dup
+    else
+      []
+    end
+  end
+
+  def count_global_observers
+    if defined? @global_observer_peers
+      @globale.observer_peers.size
+    else
+      0
+    end
+  end
+
+  def global_observer?(observer)
+    if defined? @global_observer_peers
+      @global_observer_peers.include?(observer)
+    else
+      false
+    end
+  end
+
+end # class ObservablePool
+
+
+test_section __FILE__ do
+
+
+class ObservablePoolTest < Test::Unit::TestCase
+
+  class Notifier
+    include Observable
+
+  end
+
+  class NotifierPool
+    include ObservablePool
+
+  end
+
+  class Obsv
+
+    attr_reader :last_msg
+
+    def initialize
+      @last_msg = nil
+    end
+
+    def update(*args, &block)
+      @last_msg = args
+    end
+
+  end
+
+  def test_simple
+    n1 = Notifier.new
+    n2 = Notifier.new
+    o1 = Obsv.new
+    o2 = Obsv.new
+    o3 = Obsv.new
+    op = NotifierPool.new
+    assert_equal(0, op.count_observables)
+    assert_equal([], op.list_observables)
+    op.add_observables(n1)
+    op.add_observable(n2)
+    op.observable(n2).add_observers(o1, o3)
+    assert_equal(2, op.count_observables)
+    [ n1, n2 ].each { |x| assert(op.list_observables.include?(x)) }
+    assert_equal(1, n1.count_observers)
+    assert_equal([], n1.list_observers[0].list_observers)
+    assert_equal(1, n2.count_observers)
+    assert_equal(2, n2.list_observers[0].count_observers)
+    [o1, o3].each do |x|
+      assert(n2.list_observers[0].list_observers.include?(x),
+             "#{x} not observer")
+    end
+    op.observable(n1).add_observers(o2, o3)
+    assert_equal(2, op.observable(n1).count_observers)
+    [o1, o2, o3].each do |x|
+      assert(op.list_all_observers.include?(x), "#{x} not observer")
+    end
+    n2.changed
+    n2.notify_observers('msg2')
+    assert_equal([ n2, 'msg2'], o1.last_msg)
+    assert_nil(o2.last_msg)
+    assert_equal([ n2, 'msg2'], o3.last_msg)
+    n1.changed
+    n1.notify_observers('msg1')
+    assert_equal([n2, 'msg2'], o1.last_msg)
+    assert_equal([n1, 'msg1'], o2.last_msg)
+    assert_equal([n1, 'msg1'], o3.last_msg)
+    [n1, n2].each do |x|
+      assert(op.list_observables_observed(o3).include?(x), "#{x} not observer")
+    end
+  end
+
+  def test_global_observer
+    n1 = Notifier.new
+    n2 = Notifier.new
+    n3 = Notifier.new
+    o1 = Obsv.new
+    o2 = Obsv.new
+    o3 = Obsv.new
+    op = NotifierPool.new
+    assert_equal(0, op.count_global_observers)
+    assert_equal([], op.list_global_observers)
+    op.add_observables(n1)
+    op.add_observable(n2)
+    op.observable(n1).add_observers(o1)
+    op.observable(n2).add_observers(o2)
+    op.add_global_observers(o3)
+    [o1, o3].each do |x|
+      assert(n1.list_observers[0].list_observers.include?(x),
+             "#{x} not observer")
+    end
+    [o2, o3].each do |x|
+      assert(n2.list_observers[0].list_observers.include?(x),
+             "#{x} not observer")
+    end
+    assert_equal([o3], op.list_global_observers)
+    op.add_observable(n3)
+    assert([o3], n3.list_observers[0].list_observers)
+    op.delete_global_observers
+    assert_equal([], op.list_global_observers)
+    assert([], n3.list_observers[0].list_observers)
+    assert([o2], n2.list_observers[0].list_observers)
+    assert([o1], n1.list_observers[0].list_observers)
+  end
+
+end # class ObservablePoolTest
+
+
+end
+

data/src/orderedhash.rb

@@ -0,0 +1,252 @@
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#    updated by: Nicolas Pouillard  <ertai@lrde.epita.fr>
+#
+# DESCRIPTION
+#    Override hash to make it creation order preserved.
+#    This will be obsolete - it is better to use special OrderedHash class
+#    than overriding.
+#    Public domain.
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+#
+# USAGE
+#    just require this file, examples are at the end
+#    you can try to run this file (ruby orderedhash.rb)
+#
+
+# $LastChangedBy: ertai $
+# $Id: orderedhash.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+module OrderedHash_ext
+
+  def store ( a, b )
+    @order.push a unless has_key? a
+    super a,b
+  end
+
+  def []= ( a, b )
+    @order.push a unless has_key? a
+    super a,b
+  end
+
+  def == ( hsh2 )
+    return false if !hsh2.respond_to? :order or @order != hsh2.order
+    super hsh2
+  end
+
+  def clear
+    @order = []
+    super
+  end
+
+  def delete ( key )
+    @order.delete key
+    super
+  end
+
+  def each_key
+    @order.each { |k| yield k }
+    self
+  end
+
+  def each_value
+    @order.each { |k| yield self[k] }
+    self
+  end
+
+  def each
+    @order.each { |k| yield(k, self[k]) }
+    self
+  end
+
+  alias :each_pair :each
+
+  def delete_if
+    @order.clone.each do |k|
+      delete k if yield(k, self[k])
+    end
+    self
+  end
+
+  def values
+    ary = []
+    @order.each { |k| ary << self[k] }
+    ary
+  end
+
+  def keys
+    @order
+  end
+
+  def invert
+    hsh2 = self.class.new
+    @order.each { |k| hsh2[self[k]] = k }
+    hsh2
+  end
+
+  def reject ( &block )
+    self.dup.delete_if(&block)
+  end
+
+  def reject! ( &block )
+    hsh2 = reject(&block)
+    self == hsh2 ? nil : hsh2
+  end
+
+  def replace ( hsh2 )
+    @order = hsh2.keys 
+    super hsh2
+  end
+
+  def shift
+    key = @order.first
+    key ? [key,delete(key)] : super
+  end
+
+  def to_a
+    ary = []
+    each { |k,v| ary << [k,v] }
+    ary
+  end
+
+  def to_s
+    to_a.to_s
+  end
+
+  def update ( hsh2 )
+    hsh2.each { |k,v| self[k] = v }
+    self
+  end
+
+  def merge! ( hsh2 )
+    hsh2.each { |k,v| self[k] = v }
+    self
+  end
+
+  def merge ( hsh2 )
+    self.dup.update(hsh2)
+  end
+
+  def select
+    ary = []
+    each { |k,v| ary << [k,v] if yield k,v }
+    ary
+  end
+
+  def ordered?
+    !@order.nil?
+  end
+
+end # module OrderedHash_ext
+
+
+class OHash < Hash
+
+  attr_accessor :order
+
+  alias :unordered_keys :keys
+
+  include OrderedHash_ext
+
+  def initialize ( *a )
+    @order = unordered_keys
+    super
+  end
+
+  def self.[] ( *args )
+    hsh = OHash.new
+    if Hash === args[0]
+      hsh.replace args[0]
+    elsif (args.size % 2) != 0
+      raise ArgumentError, "odd number of elements for Hash"
+    else
+      hsh[args.shift] = args.shift while args.size > 0
+    end
+    hsh
+  end
+  
+end # class OHash
+
+
+class Hash
+
+  def ordered?
+    false
+  end
+
+end # class Hash
+
+
+test_section __FILE__ do
+  class OrderedHashTest < Test::Unit::TestCase
+
+    def check_ordered ( h, ref )
+      h.store(4,3)
+      h.store(2,3) 
+      assert_equal(h.to_a, ref)
+    end
+
+    def test_ordered
+      check_ordered(OHash.new, [[4, 3], [2, 3]])
+    end
+
+    def test_unorderd
+      check_ordered(Hash.new, [[2, 3], [4, 3]])
+    end
+    
+    def test_simply
+      # You can do simply
+      hsh = OHash.new
+      hsh['z'] = 1
+      hsh['a'] = 2
+      hsh['c'] = 3
+      assert_equal(hsh.keys, ['z','a','c'])
+    end
+
+    def test_preserve
+      # or using OrderedHash[] method
+      hsh = OHash['z', 1, 'a', 2, 'c', 3] 
+      hsh2 = OHash['a', 2, 'z', 1, 'c', 3] 
+      assert_equal(hsh.keys, ['z','a','c'])
+      assert_not_equal(hsh, hsh2)
+    end
+
+    def test_dont_preserve
+      # but this don't preserve order
+      hsh = OHash['z'=>1, 'a'=>2, 'c'=>3]
+      hsh2 = OHash['a'=>2, 'z'=>1, 'c'=>3]
+      assert_equal(hsh, hsh2)
+    end
+
+    def test_unorderd_empty
+      check_ordered({}, [[2, 3], [4, 3]])
+    end
+
+    def test_little_ordered
+      a = (0..11).to_a
+      h = OHash[*a]
+      assert_equal(h.to_s, a.to_s)
+    end
+    
+    def test_big_ordered
+      a = (0..501).to_a
+      h = OHash[*a]
+      assert_equal(h.to_s, a.to_s)
+    end
+
+    def test_eql
+      assert_nothing_raised { OHash.new == {} }
+      assert_not_equal OHash.new, {}
+      assert_equal OHash.new, OHash.new
+      assert_equal OHash[1,2,3,4], OHash[1,2,3,4]
+      assert_not_equal OHash[1,2,3,4], OHash[3,4,1,2]
+    end
+    
+  end # OrderedHashTest
+
+end