ruby_ex 0.1.1

data/src/module/instance_method_visibility.rb

@@ -0,0 +1,71 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: instance_method_visibility.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+class Module
+
+  def instance_method_visibility(name)
+    if private_method_defined?(name)
+      :private
+    elsif protected_method_defined?(name)
+      :protected
+    elsif public_method_defined?(name)
+      :public
+    else
+      raise(NoMethodError,
+            "`#{name}' - not an instance method of `#{self.name}'")
+    end
+  end
+
+end # class Module
+
+
+test_section __FILE__ do
+
+
+
+class InstanceMethodVisibilityTest < Test::Unit::TestCase
+
+  class A
+
+    def pub; end
+    def pri; end
+    def pro; end
+
+    public :pub
+    private :pri
+    protected :pro
+
+  end # class A
+
+  def test_simple
+    assert_equal(:public, A.instance_method_visibility('pub'))
+    assert_equal(:private, A.instance_method_visibility('pri'))
+    assert_equal(:protected, A.instance_method_visibility('pro'))
+    assert_raises(NoMethodError) { A.instance_method_visibility('new') }
+  end
+
+  class AA
+    def f; end
+  end
+  class BB < AA
+    private :f
+  end
+
+  def test_inheritance
+    assert_equal(:public, AA.instance_method_visibility('f'))
+    assert(! BB.public_method_defined?('f'))
+    assert_equal(:private, BB.instance_method_visibility('f'))
+  end
+
+end # class InstanceMethodVisibilityTest
+
+
+end
+
+

data/src/node.rb

@@ -0,0 +1,81 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: node.rb 171 2005-03-29 09:12:47Z polrop $
+
+require 'ruby_ex'
+
+class Node
+
+  def initialize(data=nil, *sub_nodes)
+    @data = data
+    sub_nodes.each { |sub_node| check_sub_node_type(sub_node) }
+    @sub_nodes = sub_nodes
+  end
+
+  attr_reader :data, :sub_nodes
+
+  def [](sub_node_index)
+    @sub_nodes[sub_node_index]
+  end
+
+  def []=(sub_node_index, sub_node)
+    check_sub_node_type(sub_node)
+    @sub_nodes[sub_node_index] = sub_node
+  end
+
+  def <<(sub_node)
+    check_sub_node_type(sub_node)
+    @sub_nodes << sub_node
+  end
+
+  def each_pair(&block)
+    @sub_nodes.each_with_index { |sub_node, i| block[i, sub_node] }
+  end
+
+  def each_node(&block)
+    @sub_nodes.each_with_index { |sub_node, index| block[sub_node] }
+  end
+
+  alias :each :each_node
+
+  def each_index(&block)
+    @sub_nodes.each_with_index { |sub_node, index| block[index] }
+  end
+
+  def delete(sub_node)
+    @sub_nodes.delete(sub_node)
+  end
+
+  def nb_sub_nodes
+    @sub_nodes.size
+  end
+
+  alias size nb_sub_nodes
+  alias length nb_sub_nodes
+
+  def leaf?
+    @sub_nodes.empty?
+  end
+
+  def pre_depth_first(&block)
+    block[self]
+    @sub_nodes.each { |sub_node| sub_node.pre_depth_first(&block) }
+    nil
+  end
+
+#   FIXME: implement me
+#   def breadth_first(&block)
+#   end
+
+  protected
+  def check_sub_node_type(sub_node)
+    unless sub_node.is_a?(self.class)
+      raise(TypeError, "`#{sub_node}' - must be a #{self.class}")
+    end
+  end
+
+end # class Node
+

data/src/object_monitor.rb

@@ -0,0 +1,143 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: object_monitor.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+require 'observable'
+
+
+class ObjectMonitor
+  include Observable
+
+  attr_reader :nb_method
+
+  def initialize(object, *observers)
+    @object = object
+    add_observers(*observers)
+    @nb_method = 0
+  end
+
+  def method_missing(meth, *args, &block)
+    info = init_method_info(meth, *args, &block)
+    start_method(info)
+    result = nil
+    begin
+      result = @object.send(meth, *args, &block)
+    rescue Exception => exc
+      info[:stop_time] = Time.now
+      info[:error] = exc
+      stop_method(info)
+      raise exc
+    ensure
+      @nb_method += 1
+    end
+    info[:stop_time] = Time.now
+    info[:result] = result
+    stop_method(info)
+    result
+  end
+
+  protected
+  def init_method_info(meth, *args, &block)
+    {
+      :num => @nb_method,
+      :receiver => @object,
+      :method => meth,
+      :args => args,
+      :block => block,
+      :start_time => Time.now,
+      :stop_time => nil,
+      :thread => Thread.current,
+      :error => nil,
+      :result => nil,
+    }
+  end
+
+  protected
+  def start_method(info)
+    changed
+    notify_observers(:start_method, info)
+  end
+
+  protected
+  def stop_method(info)
+    changed
+    notify_observers(:stop_method, info)
+  end
+
+end # class ObjectMonitor
+
+
+test_section __FILE__ do
+
+
+class ObjectMonitorTest < Test::Unit::TestCase
+
+  class Foo
+
+    def hello
+      'hello'
+    end
+
+    def failed
+      raise 'failed msg'
+    end
+
+  end
+
+  class Obsv
+
+    attr_reader :last_msg
+
+    def initialize
+      @last_msg = []
+    end
+
+    def update(*args)
+      @last_msg << args
+    end
+
+  end
+
+  def test_normal
+    f = Foo.new
+    obsv = Obsv.new
+    fm = ObjectMonitor.new(f, obsv)
+    assert_equal(0, fm.nb_method)
+    assert_equal([], obsv.last_msg)
+    assert_equal('hello', fm.hello)
+    assert_equal(1, fm.nb_method)
+    assert_equal(:start_method,  obsv.last_msg[0][0])
+    assert_equal(2, obsv.last_msg[0].size)
+    assert_equal(:stop_method,  obsv.last_msg[1][0])
+    assert_equal(2, obsv.last_msg[0].size)
+  end
+
+  def test_exception
+    f = Foo.new
+    obsv = Obsv.new
+    fm = ObjectMonitor.new(f, obsv)
+    assert_equal(0, fm.nb_method)
+    assert_equal([], obsv.last_msg)
+    assert_raises(RuntimeError) { fm.failed }
+    assert_equal(1, fm.nb_method)
+    assert_equal(:start_method,  obsv.last_msg[0][0])
+    assert_equal(2, obsv.last_msg[0].size)
+    assert_equal(:stop_method,  obsv.last_msg[1][0])
+    assert_equal(2, obsv.last_msg[0].size)
+    assert_equal('hello', fm.hello)
+    assert_equal(2, fm.nb_method)
+  end
+
+  def test_accessor
+    assert_respond_to(ObjectMonitor.new(nil), :list_observers)
+  end
+
+end # class ObjectMonitorTest
+
+
+end

data/src/object_monitor_activity.rb

@@ -0,0 +1,34 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: object_monitor_activity.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+require 'observable'
+
+
+class ObjectMonitorActivity
+  include Observable
+
+  def initialize
+    @mutex = Mutex.new
+    @activity = {}
+  end
+
+  def update(msg, info)
+    case msg
+    when :start_method: @mutex.synchronize { @activity[info[:num]] = info }
+    when :stop_method: @mutex.synchronize { @activity.delete(info[:num]) }
+    else raise 'unknown message'
+    end
+  end
+
+  def snapshot
+    @mutex.synchronize { @activity.dup }
+  end
+
+end # class ObjectMonitorActivity
+

data/src/observable.rb

@@ -0,0 +1,138 @@
+# 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.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+require 'observer'
+
+
+module Observable
+
+  def add_observers(*observers)
+    observers.each { |observer| add_observer(observer) }
+  end
+
+  def observer?(observer)
+    if defined? @observer_peers
+      @observer_peers.include?(observer)
+    else
+      false
+    end
+  end
+
+  def list_observers
+    if defined? @observer_peers
+      @observer_peers.dup
+    else
+      []
+    end
+  end
+
+  def notify_observer(observer, *arg, &block)
+    if defined? @observer_state and @observer_state
+      if defined? @observer_peers
+        if @observer_peers.include?(observer)
+          observer.update(*arg, &block)
+        end
+      end
+      @observer_state = false
+    end
+  end
+
+  def self.included(klass)
+    klass.module_eval do
+      class << self
+        unless method_defined?(:notifier_methods_visibility)
+          def notifier_methods_visibility(visibility)
+            send(visibility, *instance_methods)
+          end
+        end
+      end
+    end
+  end
+
+end # module Observable
+
+
+test_section __FILE__ do
+
+
+class ObservableTest < Test::Unit::TestCase
+
+  class Notify
+    include Observable
+
+    def initialize(*obsv)
+      obsv.each { |o| add_observer(o) }
+    end
+
+  end # class Notify
+
+  class Obsv
+
+    attr_reader :last_msg
+
+    def initialize
+      @last_msg = nil
+    end
+
+    def update(arg)
+      @last_msg = arg
+    end
+
+  end # class Obsv
+
+  #
+  # Tests
+  #
+  def test_simple
+    o1 = Obsv.new
+    o2 = Obsv.new
+    n = Notify.new(o1, o2)
+    assert_equal(2, n.count_observers, 'bad number of observers')
+    assert(n.observer?(o1))
+    n.changed
+    n.notify_observers('all')
+    assert_equal('all', o1.last_msg, 'bad msg o1 1')
+    assert_equal('all', o2.last_msg, 'bad msg o2 1')
+    l = n.list_observers
+    assert_equal(o1, l[0], 'o1 is not at the right place in the list')
+    assert_equal(o2, l[1], 'o2 is not at the right place in the list')
+    n.changed
+    n.notify_observer(o1, 'o1')
+    assert_equal('o1', o1.last_msg, 'bad msg o1 2')
+    assert_equal('all', o2.last_msg, 'bad msg o2 2')
+    n.changed
+    n.notify_observer(o2, 'o2')
+    assert_equal('o1', o1.last_msg, 'bad msg o1 3')
+    assert_equal('o2', o2.last_msg, 'bad msg o2 3')
+    n.changed
+    n.notify_observer(o1, 'new_all')
+    n.changed
+    n.notify_observer(o2, 'new_all')
+    assert_equal('new_all', o1.last_msg, 'bad msg o1 4')
+    assert_equal('new_all', o2.last_msg, 'bad msg o2 4')
+  end
+
+  class ObservableMethodsVisibilityFoo
+    include Observable
+
+    notifier_methods_visibility(:protected)
+  end
+
+  def test_notifier_methods_visibility
+    fm = ObservableMethodsVisibilityFoo.new
+    assert_raises(NoMethodError) { fm.add_observer(Object.new) }
+    assert_raises(NoMethodError) { fm.notify_observer(Object.new) }
+    assert_raises(NoMethodError) { fm.list_observer }
+    assert_raises(NoMethodError) { fm.changed? }
+  end
+
+end # class ObservableTest
+
+
+end