vcs 0.1 → 0.2.148

data/ruby_ex/inactive_timeout.rb

@@ -0,0 +1,137 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: inactive_timeout.rb 92 2005-01-10 12:23:55Z polrop $
+
+
+require 'thread'
+
+
+module InactiveTimeout
+
+  def inactive_timeout_initialize(inactive_timeout=0)
+    @inactive_timeout = inactive_timeout
+    @inactive_timeout_update_time = Time.now
+    @inactive_timeout_mutex = Mutex.new
+    if @inactive_timeout > 0
+      @inactive_timeout_thread = inactive_timeout_start_thread
+    end
+  end
+
+  def inactive_timeout=(inactive_timeout)
+    @inactive_timeout_mutex.synchronize do
+      @inactive_timeout = inactive_timeout
+    end
+  end
+
+  def inactive_timeout
+    @inactive_timeout_mutex.synchronize { @inactive_timeout }
+  end
+
+  def inactive_timeout_update_time
+    @inactive_timeout_mutex.synchronize do
+      @inactive_timeout_update_time
+    end
+  end
+
+  protected
+  def inactive_timeout_update(time=Time.now)
+    @inactive_timeout_mutex.synchronize do
+      @inactive_timeout_update_time = time
+    end
+  end
+
+  # Every @inactive_timeout seconds, this method is called if the enlapsed
+  # time since @inactive_timeout_update_time is greater than @inactive_timeout.
+  # Return true to stop the timeout thread.
+  protected
+  def inactive_timeout_callback
+    true
+  end
+
+  protected
+  def inactive_timeout_start_thread
+    Thread.new do
+      begin
+        time = @inactive_timeout_mutex.synchronize { @inactive_timeout }
+        while time > 0
+          sleep(time)
+          time = @inactive_timeout_mutex.synchronize do
+            @inactive_timeout - (Time.now - @inactive_timeout_update_time)
+          end
+        end
+      end until inactive_timeout_callback
+    end
+  end
+
+end # module InactiveTimeout
+
+
+if defined? TEST_MODE or __FILE__ == $0
+
+
+require 'test/unit/ui/yaml/testrunner'
+
+
+class InactiveTimeoutTest < Test::Unit::TestCase
+
+  class Foo
+    include InactiveTimeout
+
+    attr_reader :obj
+
+    def initialize(obj, inactive_timeout=0)
+      inactive_timeout_initialize(inactive_timeout)
+      @obj = obj
+    end
+
+    def method_missing(meth, *args, &block)
+      inactive_timeout_update
+      @obj.send(meth, *args, &block)
+    end
+
+    protected
+    def inactive_timeout_callback
+      @obj = nil
+      super
+    end
+
+  end
+
+  class Bar
+
+    def hello
+      'hello bar'
+    end
+
+  end
+
+  def test_accessors
+    f = Foo.new(Bar.new)
+    assert_equal(0, f.inactive_timeout)
+    t0 = f.inactive_timeout_update_time
+    assert_equal(t0, f.inactive_timeout_update_time)
+    assert_equal('hello bar', f.hello)
+    assert(t0 < f.inactive_timeout_update_time)
+    assert_not_nil(f.obj)
+  end
+
+  def test_simple
+    f = Foo.new(Bar.new, 0.2)
+    assert_not_nil(f.obj)
+    assert_equal(0.2, f.inactive_timeout)
+    3.times do
+      sleep(0.1)
+      assert_equal('hello bar', f.hello)
+    end
+    assert_not_nil(f.obj)
+    sleep(0.5)
+    assert_nil(f.obj)
+  end
+
+end # class InactiveTimeoutTest
+
+end
+

data/ruby_ex/indexed_node.rb

@@ -0,0 +1,66 @@
+# 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 '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
+
+
+if defined? TEST_MODE or __FILE__ == $0
+
+require 'test/unit'
+
+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/ruby_ex/io_marshal.rb

@@ -0,0 +1,100 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: io_marshal.rb 63 2004-12-06 13:09:14Z polrop $
+
+
+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
+#
+if defined? TEST_MODE or $0 == __FILE__
+
+
+require 'test/unit/ui/yaml/testrunner'
+
+
+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
+

data/ruby_ex/ioo.rb

@@ -0,0 +1,194 @@
+# Copyright: Copyright (c) 2004  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: ioo.rb 186 2005-04-03 00:07:45Z ertai $
+
+require 'delegate'
+
+# With this class you can easily overwrite only write or read methods
+# to change the whole IO.
+#
+# This is very usefull to produce a crypted IO for example.
+module ImplIOO
+
+  def << ( obj )
+    write obj
+    self
+  end
+
+  def each ( sep_string=$/, &block )
+    begin
+      loop { block[readline(sep_string)] }
+    rescue EOFError
+      return self
+    end
+  end
+  alias :each_line :each
+
+  def each_byte ( &block )
+    begin
+      loop { block[readchar] }
+    rescue EOFError
+      return nil
+    end
+  end
+
+  def getc
+    begin
+      readchar
+    rescue EOFError
+      nil
+    end
+  end
+
+  def gets ( sep_string=$/ )
+    begin
+      readline(sep_string)
+    rescue EOFError
+      nil
+    end
+  end
+
+  def print ( *args )
+    if args.empty?
+      write $_
+    else
+      args.each { |x| write x }
+    end
+    nil
+  end
+
+  def printf ( fmt, *args )
+    write Kernel.sprintf(fmt, *args)
+    nil
+  end
+
+  def putc ( c )
+    case c
+    when Numeric then write c.chr
+    when String
+      if c.size == 1
+        write c
+      else
+        c = c[0].chr
+        write c
+      end
+    else
+      c = c.to_s[0].chr
+      write c
+    end
+    c
+  end
+
+  def puts ( *args )
+    if args.size == 0
+      write "\n"
+    else
+      args.each do |x|
+        x = x.to_s
+        write x
+        write "\n" unless x[-1] == ?\n
+      end
+    end
+    nil
+  end
+
+  def readchar
+    raise EOFError if eof?
+    read(1)[0]
+  end
+
+  def readline ( sep_string=$/ )
+    raise EOFError if eof?
+    buf = ''
+    begin
+      while (char = readchar) != ?\n
+        buf += char.chr
+      end
+      return buf + char.chr
+    rescue EOFError
+      return buf
+    end
+  end
+
+  def readlines ( sep_string=$/ )
+    res = []
+    each_line(sep_string) { |line| res << line }
+    res
+  end
+
+end # module ImplIOO
+
+class IOO < DelegateClass(IO)
+  include ImplIOO
+end # class IOO
+
+require 'socket'
+class TCPSocket
+  alias :real_send :send
+  alias :real_recv :recv
+end
+
+class IOOTCPSocket < DelegateClass(TCPSocket)
+  include ImplIOO
+
+  def recv ( integer, flags=nil )
+    read(integer)
+  end
+
+  def read ( integer=nil, buffer='' )
+    raise ArgumentError unless buffer.is_a? String
+    raise NotImplementedError if integer.nil?
+    raise ArgumentError unless integer.is_a? Numeric
+    buffer += real_recv(integer, 0)
+    return buffer
+  end
+
+  def send ( obj, flags=nil )
+    write(obj)
+  end
+
+  def write ( obj )
+    real_send(obj.to_s, 0)
+    nil
+  end
+
+end # class IOOTCPSocket
+
+
+if defined? TEST_MODE or $0 == __FILE__
+
+  require 'mktemp'
+  require 'test/unit'
+  class TestIOO < Test::Unit::TestCase
+
+    def setup
+      @tmp = Tempfile.mktemp('ioo')
+      @tmp.open('w') do |tmp|
+        tmp.puts 'foo'
+        tmp.puts
+        tmp.puts 'bar'
+      end
+      @readlines = @tmp.readlines
+    end
+
+    def teardown
+      @tmp.clean
+      @tmp = nil
+    end
+      
+    def test_readlines
+      @tmp.open do |tmp|
+        assert_not_nil(tmp)
+        f = nil
+        assert_nothing_raised { f = IOO.new(tmp) }
+        assert_not_nil(f)
+        assert_equal(@readlines, f.readlines)
+      end
+    end
+
+  end # class TestIOO
+
+end