vcs 0.1 → 0.2.148

data/ruby_ex/drb/session_server.rb

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

@@ -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: 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

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

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

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