vcs 0.2.148 → 0.3.0

data/ruby_ex/drb/session_server.rb

@@ -1,53 +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: session_server.rb 91 2005-01-09 22:24:40Z polrop $
-
-
-require 'drb/extserv'
-
-
-module DRb
-
-  class SessionServer < ExtServ
-
-    attr_reader :name
-
-    alias sid name
-
-  end # class SessionServer
-
-end # module DRb
-
-
-if __FILE__ == $0
-
-require 'drb/drb'
-require 'drb/extserv'
-require 'yaml'
-require 'tempfile'
-
-class Foo
-
-  def hello
-    'hello'
-  end
-
-  def salut
-    'salut'
-  end
-
-end # class SessionManagerTest
-
-
-raise "usage: #{$0} <uri> <name>" unless ARGV.size == 2
-uri = ARGV.shift
-name = ARGV.shift
-
-server = DRb::DRbServer.new("druby://localhost:0", Foo.new, {})
-ext_srv = DRb::SessionServer.new(uri, name, server)
-server.thread.join
-
-end

data/ruby_ex/dtime.rb

@@ -1,143 +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: dtime.rb 146 2005-02-01 11:02:42Z polrop $
-
-
-require 'module/attr_once'
-
-
-class DTime
-
-  def initialize(delta)
-    @delta = delta.abs
-    @min, @sec = @delta.divmod(60)
-    @hour, @min = @min.floor.divmod(60)
-    @day, @hour = @hour.divmod(24)
-  end
-
-  attr_reader :delta, :sec, :min, :hour, :day
-
-  def to_s
-    @delta.to_s.freeze
-  end
-
-  def inspect
-    "#@day days #@hour hours #@min mins #@sec secs".freeze
-  end
-
-  def to_a
-    [ @day, @hour, @min, @sec ].freeze
-  end
-
-  def to_i
-    @delta.to_i
-  end
-
-  alias to_f delta
-
-  def hash
-    @delta.hash
-  end
-
-  def to_hash
-    { :days => @day, :hours => @hour, :mins => @min, :secs => @sec }.freeze
-  end
-
-  def floor
-    @delta.floor
-  end
-
-  def round
-    @delta.round
-  end
-
-  def to_yaml(opts={})
-    ((@day != 0 ? "#@day days " : '') +
-     (@hour != 0 ? "#@hour hours " : '') +
-     (@min != 0 ? "#@min mins " : '') +
-     "#@sec secs").to_yaml(opts)
-  end
-
-  attr_once :to_s, :inspect, :to_a, :to_i, :hash, :to_hash, :floor,
-            :round, :to_yaml
-
-end # class DTime
-
-
-if defined? TEST_MODE or __FILE__ == $0
-
-
-require 'test/unit/ui/yaml/testrunner'
-require 'yaml'
-
-
-class DTimeTest < Test::Unit::TestCase
-
-  def test_simple
-    d = DTime.new(260.33)
-    assert_equal(260, d.delta.floor)
-    assert_equal(20, d.sec.floor)
-    assert_equal(4, d.min)
-    assert_equal(0, d.hour)
-    assert_equal(0, d.day)
-  end
-
-  def test_complex
-    d = DTime.new(265678.42000)
-    assert_equal(265678, d.delta.floor)
-    assert_equal(58, d.sec.floor)
-    assert_equal(47, d.min)
-    assert_equal(1, d.hour)
-    assert_equal(3, d.day)
-    assert_equal([ 3, 1, 47 ], d.to_a[0..2])
-    assert_equal(58, d.to_a[3].floor)
-    h = d.to_hash
-    assert_equal(3, h[:days])
-    assert_equal(1, h[:hours])
-    assert_equal(47, h[:mins])
-    assert_equal(58, h[:secs].floor)
-  end
-
-  def test_conversion
-    d = DTime.new(260.75)
-    assert_equal('260.75', d.to_s)
-    assert_equal('0 days 0 hours 4 mins 20.75 secs', d.inspect)
-    assert_equal(260, d.to_f.floor)
-    assert_equal(260, d.to_i)
-    assert_equal(260, d.floor)
-    assert_equal(261, d.round)
-  end
-
-  def test_negative
-    d = DTime.new(-265678.42000)
-    assert_equal(265678, d.delta.floor)
-    assert_equal(58, d.sec.floor)
-    assert_equal(47, d.min)
-    assert_equal(1, d.hour)
-    assert_equal(3, d.day)
-  end
-
-  def test_marshal
-    d = DTime.new(-265678.42000)
-    assert_equal(d.floor, Marshal.load(Marshal.dump(d)).floor)
-  end
-
-  def test_to_yaml
-    d = DTime.new(265678.42000)
-    assert_equal('--- 3 days 1 hours 47 mins 58.4199999999837 secs', d.to_yaml)
-    d = DTime.new(5678.42000)
-    assert_equal('--- 1 hours 34 mins 38.4200000000001 secs', d.to_yaml)
-    d = DTime.new(158.42000)
-    assert_equal('--- 2 mins 38.42 secs', d.to_yaml)
-    d = DTime.new(58.42000)
-    assert_equal('--- 58.42 secs', d.to_yaml)
-  end
-
-end # class DTimeTest
-
-
-end
-

data/ruby_ex/dumpable_proc.rb

@@ -1,63 +0,0 @@
-# Copyright: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
-# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: ertai $
-# $Id: dumpable_proc.rb 190 2005-04-04 14:46:40Z ertai $
-
-require 'yaml'
-require 'delegate'
-
-class DumpableProc < DelegateClass(Proc)
-
-  def initialize ( str )
-    @str = str.freeze
-    super(eval("proc { #@str }"))
-  end
-
-  def _dump ( depth )
-    Marshal.dump([self.class, @str])
-  end
-
-  def self._load ( data )
-    klass, str = Marshal.load(data)
-    klass.new(str)
-  end
-
-  def to_yaml ( opts={} )
-    "#{to_yaml_type} #@str"
-  end
-
-  def to_s
-    @str
-  end
-
-  def to_yaml_type
-    '!proc'
-  end
-
-end
-
-YAML.add_builtin_type('!proc') do |type, val|
-  DumpableProc.new(val.to_s)
-end
-
-if defined? TEST_MODE or $0 == __FILE__
-
-require 'test/unit'
-
-class DumpableProcTest < Test::Unit::TestCase
-
-  def test_simple
-    p = DumpableProc.new('|x| 3 + x')
-    assert_equal(7, p[4])
-    str = nil
-    assert_nothing_raised { str = Marshal.dump(p) }
-    p2 = nil
-    assert_nothing_raised { p2 = Marshal.load(str) }
-    assert_equal(9, p2[6])
-  end
-
-end
-
-end

data/ruby_ex/exception.rb

@@ -1,32 +0,0 @@
-# Copyright:: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
-# License::   Gnu General Public License.
-# Revision::  $Id: exception.rb 200 2005-04-22 22:55:31Z ertai $
-
-
-class Exception
-
-  #FIXME: write a ruby_pp which print exception backtrace exactly as ruby does
-  #       by cuting long and repetitive backtrace.
-
-  def long_pp
-    str = short_pp + "\n"
-    backtrace[1..-1].each { |x| str += "  from #{x}\n" } if backtrace
-    str.chomp!
-    str
-  end
-
-  def short_pp
-    if backtrace.nil?
-      tiny_pp
-    else
-      "#{backtrace[0]}: #{tiny_pp}"
-    end
-  end
-
-  def tiny_pp
-    exc_name = inspect.sub(/^#<(\w+):.+$/, '\1')
-    "#{self} (#{exc_name})"
-  end
-
-end # class Exception

data/ruby_ex/filetype.rb

@@ -1,229 +0,0 @@
-require 'pathname_ex'
-require 'abstract'
-
-module FileType
-
-  @@subclasses = []
-
-  def self.register ( klass )
-    @@subclasses << klass
-  end
-
-  class Generic
-    include Abstract
-
-    attr_reader :path, :base, :ext
-
-    def initialize ( path )
-      @path = Pathname.new(path)
-      re = self.class.extension
-      raise ArgumentError, "bad class #{self.class}" if re.nil?
-      unless @path.to_s =~ re
-        raise ArgumentError, "#{@path} do not match /#{re.source}/"
-      end
-      @base, @ext = $`, $&
-      if @ext.empty?
-        @base = self
-      else
-        @base = FileType.guess(@base)
-      end
-    end
-
-    def extsplit
-      [@base, @ext]
-    end
-
-    def self.inherited ( klass )
-      FileType.register(klass)
-    end
-
-    def to_s
-      @path.to_s
-    end
-
-    def self.extension
-      const_get(:EXTENSION)
-    end
-
-    def self.match_type ( path, max, best )
-      ext_re = self.extension
-      if path.to_s =~ ext_re and $&.size > max
-        return [$&.size, self]
-      end
-      return [max, best]
-    end
-    
-    def + ( arg )
-      @path + arg.to_s
-    end
-
-  end # class Generic
-
-  class Unknown < Generic
-    include Concrete
-    EXTENSION = /(\.[^.\/]+)?$/
-  end # class Unknown
-
-  class ExtractError < Exception
-  end
-
-  module Extractable
-
-    def self.included ( aClass )
-
-      aClass.module_eval do
-    
-        def mk_cmd
-          base, ext = @base.extsplit
-          @tmp = TempPath.new(base.path.basename, ext)
-          cmd = self.class.const_get(:EXTRACT_COMMAND).gsub(/%I/, @path.to_s)
-          cmd.gsub!(/%O/, @tmp.to_s)
-          cmd
-        end
-
-        def extract
-          cmd = mk_cmd
-          unless system(cmd)
-            @tmp.rmtree if @tmp.exist?
-            err = "
-              |Cannot extract a file:
-              |  path: #{to_s}
-              |  type: #{self.class}
-              |  command: #{cmd}
-              |  exit status: #{$? >> 8}
-              "
-            raise ExtractError, err.gsub(/^\s*|/, '')
-          end
-          FileType.guess(@tmp)
-        end
-
-        alias :default :extract
-
-      end
-
-    end
-    
-  end # module Extractable
-
-  # FIXME Use the zlib if gzip not available.
-  class Gz < Generic
-    include Extractable
-    include Concrete
-    EXTENSION = /(\.(gz|z|Z)|-gz|-z|_z)$/
-    EXTRACT_COMMAND = 'gzip -d -c "%I" > "%O"'
-  end # class Gz
-
-  class Bz2 < Generic
-    include Extractable
-    include Concrete
-    EXTENSION = /\.(bz2|bz)$/
-    EXTRACT_COMMAND = 'bzip2 -d -c "%I" > "%O"'
-  end # class Bz2
-
-  class Zip < Generic
-    include Extractable
-    include Concrete
-    EXTENSION = /\.zip$/
-    EXTRACT_COMMAND = 'unzip -p "%I" > "%O"'
-  end # class Zip
-
-  module ExtractableDir
-
-    def self.included ( aClass )
-
-      aClass.module_eval do
-    
-        include Extractable
-
-        alias :mk_cmd_extractable :mk_cmd
-        
-        def mk_cmd
-          cmd = mk_cmd_extractable
-          @tmp.mkpath
-          @log = TempPath.new
-          cmd.gsub!(/%L/, @log.to_s)
-        end
-
-        alias :extract_extractable :extract
-
-        def extract
-          dir = extract_extractable
-          # We want the longest common path
-          longest = nil
-          @log.each_line do |line|
-            path = line.split(/\//)
-            longest = path if longest.nil?
-            longest &= path
-            raise CorruptedTarball, self if longest.empty?
-          end
-          dir.path + longest.join('/')
-        end
-
-      end
-
-    end
-
-  end # module ExtractableDir
-
-  class Tar < Generic
-    include ExtractableDir
-    include Concrete
-    EXTENSION = /\.tar$/
-    EXTRACT_COMMAND = 'tar xvf "%I" -C "%O" > "%L"'
-  end # class Tar
-
-  class TarGz < Generic
-    include ExtractableDir
-    include Concrete
-    EXTENSION = /\.(tar\.gz|tgz)$/
-    EXTRACT_COMMAND = 'tar xvzf "%I" -C "%O" > %L'
-  end # class TarGz
-
-  class TarBz2 < Generic
-    include ExtractableDir
-    include Concrete
-    EXTENSION = /\.(tar\.bz2|tbz2|tbz)$/
-    EXTRACT_COMMAND = 'bzip2 -c -d %I | tar xvf - -C "%O" > "%L"'
-  end # class TarBz2
-
-  class Directory < Generic
-    include Concrete
-
-    EXTENSION = /()$/
-
-    def self.match_type ( path, max, best )
-      if File.directory? path
-        return [path.to_s.size, self]
-      end
-      return [max, best]
-    end
-    
-  end # class Directory
-
-  def self.guess_class ( path )
-    lazy_init
-    max = -1
-    best = Unknown
-    @@subclasses.each do |klass|
-      max, best = klass.match_type(path, max, best)
-    end
-    return best
-  end
-
-  def self.guess ( path )
-    guess_class(path).new(path)
-  end
-
-  def self.lazy_init
-    return if defined? @@init
-    @@init = true
-    @@subclasses.delete_if do |klass|
-      klass.abstract? or not (klass.is_a? Class) # and constants.include? klass)
-    end
-    @@subclasses.each do |klass|
-      ext = klass.extension
-      raise ArgumentError, "Bad extension #{ext}" unless ext.is_a? Regexp
-    end
-  end
-
-end # module FileType