ruby_ex 0.1.1

data/src/hookable.rb

@@ -0,0 +1,283 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: hookable.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+require 'hooker'
+
+
+module Hookable
+
+  def self.included ( aClass )
+    super
+
+    aClass.module_eval do
+
+      def self.inheritable_attributes
+        if @inheritable_attributes.nil? or @inheritable_attributes.empty?
+          @inheritable_attributes = HashWithRecursiveCloneDup.new
+        end
+        @inheritable_attributes
+      end
+
+
+      class_inheritable_array :hooks
+      class_inheritable_array :hookers
+      inheritable_attributes[:hookers] = []
+      inheritable_attributes[:hooks] = []
+
+
+      def hook_trigger ( name, *args )
+        self.class.hook_trigger(name, *args)
+        return unless defined? @hookers
+        @hookers.each do |hooker|
+          @@hook_trigger_internal[hooker, name, *args]
+        end
+      end
+
+
+      def self.hook_trigger ( name, *args )
+        raise ArgumentError, "Unknown hook #{name}" unless hooks.include? name
+        hookers.each do |hooker|
+          @@hook_trigger_internal[hooker, name, *args]
+        end
+      end
+
+
+      def self.hooker_subscribe ( hooker )
+        hookers << hooker
+      end
+
+
+      def hooker_subscribe ( hooker )
+        @hookers ||= []
+        @hookers << hooker
+      end
+
+
+      def self.subscribe_hook ( *hook_names, &block )
+        hooker_subscribe ProcHooker.new(*hook_names, &block)
+      end
+
+
+      def subscribe_hook ( *hook_names, &block )
+        hooker_subscribe ProcHooker.new(*hook_names, &block)
+      end
+
+
+      def self.hook_declare ( name, *groups )
+        hooks << name
+      end
+
+
+      @@hook_trigger_internal = lambda do |hooker, name, *args|
+        if hooker.respond_to?(name)
+          hooker.send(name, *args)
+        else
+          if hooker.respond_to? :default_hook and not hooker.default_hook.nil?
+            hooker.send(hooker.default_hook, name, *args)
+          elsif hooker.respond_to?(:method_missing)
+            hooker.send(name, *args)
+          end
+        end
+      end
+
+    end
+
+  end
+
+
+  class ProcHooker < Proc
+    include Hooker
+    def initialize ( *hook_names, &block )
+      hook_method :call, *hook_names
+      super(&block)
+    end
+  end
+
+  
+  class HashWithRecursiveCloneDup < Hash
+
+    def initialize_copy ( aHash )
+      aHash.each { |k, v| self[k] = v.dup }
+    end
+
+  end # class HashWithRecursiveCloneDup
+
+end # module Hookable
+
+
+
+test_section __FILE__ do
+
+  class HookableHookerTest < Test::Unit::TestCase
+
+    class HookerTest
+      include Hooker
+
+      attr_reader :stack
+
+      def log ( *args )
+        @stack ||= []
+        @stack << args
+      end
+
+      def method_missing ( *a )
+        log(:method_missing, *a)
+      end
+
+      def hook1 ( *a )
+        log(:hook1, *a)
+      end
+
+      def reset
+        @stack.clear if @stack
+      end
+    end
+
+
+    STATIC_HOOKER_TEST = HookerTest.new
+
+
+    class HookableTest
+      include Hookable
+
+      hook_declare :hook1
+
+      hook_declare :hook2, :group1
+
+      def run
+        run1
+        run2
+      end
+
+      def run1
+        hook_trigger :hook1
+      end
+
+      def run2
+        hook_trigger :hook2, 42
+        hook_trigger :hook3 rescue nil
+      end
+
+      def << ( hooker )
+        hooker_subscribe hooker
+      end
+
+      hooker_subscribe STATIC_HOOKER_TEST
+
+      def self.ref
+        [
+          [[:hook1], [:method_missing, :hook2, 42]],
+          [[:hook1], [:default, :hook2, 42]],
+          [[:hook_1_and_2], [:hook_1_and_2, 42]],
+          [[:hook1], [:method_missing, :default_by_method_missing, :hook2, 42]],
+          [[:hook1], [:hook2, 42]],
+          [[:hook1], [:method_missing, :hook2_by_dynamic_hook_method, 42]]
+        ]
+      end
+
+    end
+
+
+
+    class SubHookableTest < HookableTest
+      hook_declare :hook3
+
+      def self.ref
+        [
+          [[:hook1], [:method_missing, :hook2, 42], [:method_missing, :hook3]],
+          [[:hook1], [:default, :hook2, 42], [:default, :hook3]],
+          [[:hook_1_and_2], [:hook_1_and_2, 42], [:method_missing, :hook3]],
+          [[:hook1], [:method_missing, :default_by_method_missing, :hook2, 42],
+                     [:method_missing, :default_by_method_missing, :hook3]],
+          [[:hook1], [:hook2, 42], [:default, :hook3]],
+          [[:hook1], [:method_missing, :hook2_by_dynamic_hook_method, 42],
+                     [:method_missing, :hook3]]
+        ]
+      end
+
+    end
+
+
+
+    class HookerTest1 < HookerTest
+      def default ( *a )
+        log(:default, *a)
+      end
+      hook_default_method :default
+    end
+
+
+
+    class HookerTest2 < HookerTest
+      def hook_1_and_2 ( *a )
+        log(:hook_1_and_2, *a)
+      end
+      hook_method :hook_1_and_2, :hook1, :hook2
+    end
+
+
+
+    class HookerTest3 < HookerTest
+      hook_default_method :default_by_method_missing
+    end
+
+
+
+    class HookerTest4 < HookerTest
+    end
+
+
+
+    class HookerTest21 < HookerTest1
+      def hook2 ( *a )
+        log(:hook2, *a)
+      end
+    end
+
+
+
+    def test_hookable
+      hookable_checker HookableTest.new
+    end
+
+
+
+    def test_sub_hookable
+      hookable_checker SubHookableTest.new
+    end
+
+
+
+    def hookable_checker ( support )
+      hookers = []
+      hookers << HookerTest1.new
+      hookers << HookerTest2.new
+      hookers << HookerTest3.new
+      hookers << HookerTest21.new
+      hooker4 = HookerTest4.new
+      hookers << hooker4
+      hookers.each do |hooker|
+        support << hooker
+      end
+      STATIC_HOOKER_TEST.reset
+      hookers.unshift STATIC_HOOKER_TEST
+      hooker4.hook_method(:hook2_by_dynamic_hook_method, :hook2)
+      @a = []
+      support.subscribe_hook(:hook2) do |*a|
+        assert_nothing_raised do
+          @a << [:proc_hooker_call, :hook2, *a]
+        end
+      end
+      support.run
+      hookers.zip(support.class.ref).each do |hooker, ref|
+        assert_equal(ref, hooker.stack)
+      end
+      assert_equal([[:proc_hooker_call, :hook2, 42]], @a)
+    end
+
+  end
+
+end

data/src/hooker.rb

@@ -0,0 +1,54 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: hooker.rb 233 2005-05-17 08:35:52Z ertai $
+
+require 'rubygems'
+require_gem 'activesupport'
+require 'active_support/class_inheritable_attributes'
+
+
+
+module Hooker
+
+  def self.included ( aClass )
+    super
+
+    aClass.class_eval do
+
+      class_inheritable_accessor :default_hook
+
+
+      def self.hook_default_method ( method )
+        raise unless method.is_a? Symbol
+        self.default_hook = method
+      end
+
+
+      def hook_method ( *a )
+        @@generic_hook_method[method(:instance_eval), *a]
+      end
+
+
+      def self.hook_method ( *a )
+        @@generic_hook_method[method(:module_eval), *a]
+      end
+
+
+      @@generic_hook_method = lambda do |eval_meth, method, *hook_names|
+        raise unless method.is_a? Symbol
+        hook_names.each do |hook_name|
+          raise unless hook_name.is_a? Symbol
+          eval_meth[%Q{
+            def #{hook_name} ( *a, &b )
+              #{method}(*a, &b)
+            end
+          }]
+        end
+      end
+
+    end
+
+  end
+
+end # module Hooker

data/src/indexed_node.rb

@@ -0,0 +1,65 @@
+# 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'
+require 'abstract_node'
+
+
+class IndexedNode < AbstractNode
+  include Concrete
+
+  def initialize(data=nil, *sub_nodes)
+    @sub_nodes = sub_nodes
+    super
+  end
+
+  def <<(sub_node)
+    check_sub_node_type(sub_node)
+    @sub_nodes << sub_node
+  end
+
+end # class IndexedNode
+
+
+test_section __FILE__ do
+
+class IndexedNodeTest < Test::Unit::TestCase
+
+  def test_simple
+    s11 = IndexedNode.new(11)
+    s12 = IndexedNode.new(12)
+    s = IndexedNode.new(1, s11, s12)
+    assert_equal(1, s.data)
+    assert_equal(s11, s.sub_nodes[0])
+    assert_equal(s12, s.sub_nodes[1])
+  end
+
+  def test_crochet_equal
+    s = IndexedNode.new(1)
+    assert_nothing_raised { s[0] = IndexedNode.new(10) }
+    assert_raises(TypeError) { s[1] = nil }
+  end
+
+  def test_merge
+    s = IndexedNode.new(1)
+    s11 = IndexedNode.new(11)
+    s12 = IndexedNode.new(12)
+    s.merge!({ 0 => s11, 1 => s12 })
+  end
+
+  def test_chevron
+    s = IndexedNode.new(1)
+    assert_equal(0, s.size)
+    s << IndexedNode.new(2)
+    assert_equal(1, s.size)
+  end
+
+end # class IndexedNodeTest
+
+end
+

data/src/io_marshal.rb

@@ -0,0 +1,99 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: io_marshal.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+
+class IO
+
+  def dump(*objs)
+    objs.each do |obj|
+      data = Marshal.dump(obj)
+      write(data.size.to_s)
+      write("\0")
+      write(data)
+    end
+  end
+
+  def load(num_objs=nil, non_block=false)
+    objs = []
+    n = num_objs
+    begin
+      return nil if eof? and non_block
+      objs << load_one_object(non_block)
+      unless n.nil?
+        n -= 1
+        break if n <= 0
+      end
+    end until eof?
+    objs
+  end
+
+  def load_one_object(non_block=false)
+    size = ''
+    while (c = read(1)) != "\0" do
+      if c.nil?
+        if non_block
+          return nil
+        else
+          sleep(0.1)
+          redo
+        end
+      end
+      size += c
+    end
+    size = size.to_i
+    data = read(size)
+    Marshal.load(data)
+  end
+
+end # class IO
+
+
+#
+# Unit test suite
+#
+test_section __FILE__ do
+
+
+class IOMarshalTest < Test::Unit::TestCase
+
+  #
+  # Tests
+  #
+  def test_simple
+    obj1 = 12
+    obj2 = 'hello'
+    obj3 = { 'a' => 12, 'b' => 42 }
+    rd, wr = IO.pipe
+    if pid = fork # father
+      wr.close
+      o1, o2 = rd.load(2)
+      assert_equal(obj1, o1)
+      assert_equal(obj2, o2)
+      o3 = rd.load
+      assert_equal([obj3], o3)
+      assert_equal(nil, rd.load(4, true))
+      assert_equal(nil, rd.load_one_object(true))
+      Process.waitpid(pid)
+      rd.close
+    else #  son
+      rd.close
+      sleep(0.5)
+      wr.dump(obj1)
+      wr.dump(obj2, obj3)
+      wr.close
+      exit
+    end
+  end
+
+
+end # class IOMarshalTest
+
+
+end
+