vcs 0.2.148 → 0.3.0

data/ruby_ex/inactive_timeout.rb

@@ -1,137 +0,0 @@
-# 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

@@ -1,66 +0,0 @@
-# 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

@@ -1,100 +0,0 @@
-# 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

@@ -1,194 +0,0 @@
-# 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