ruby_ex 0.1.1

data/src/drb_ex.rb

@@ -0,0 +1,12 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: drb_ex.rb 258 2005-06-01 00:22:51Z ertai $
+
+require 'module/autoload_tree'
+
+module DRb
+
+  autoloaded_module(__FILE__.sub(/drb_ex\.rb/, 'drb.rb'))
+
+end # module Drb

data/src/dumpable_proc.rb

@@ -0,0 +1,57 @@
+# 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 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+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
+
+test_section __FILE__ do
+
+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/src/filetype.rb

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

data/src/generate_id.rb

@@ -0,0 +1,44 @@
+# Copyright:: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: generate_id.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+require 'md5'
+
+module Kernel
+
+  def generate_id(&already_exist)
+    md5 = Digest::MD5::new
+    id = ''
+    begin
+      md5.update(id)
+      md5.update(Time.now.to_s)
+      md5.update(rand.to_s)
+      md5.update($$.to_s)
+      md5.update($0)
+      id = md5.hexdigest[0,16]
+    end while block_given? and already_exist[id]
+    id
+  end
+
+end # module Kernel
+
+
+
+test_section __FILE__ do
+  class GenerateIdTest < Test::Unit::TestCase
+    def test_simple
+      tab = []
+      100.times { tab << generate_id }
+      assert_equal(tab.size, tab.uniq.size)
+    end
+    def test_simple
+      tab = []
+      bool = true
+      100.times { tab << generate_id { bool = !bool ; bool } }
+      assert_equal(tab.size, tab.uniq.size)
+    end
+  end
+end

data/src/histogram.rb

@@ -0,0 +1,222 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: histogram.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+class Histogram
+
+  class EquivalenceClass
+
+    attr_reader :values, :id
+
+    def initialize ( id, *values )
+      @id = id
+      @values = values.flatten
+    end
+
+
+    def include? ( anObject )
+      if @values.empty?
+        raise "You cannot call #{self.class}#include? with an empty class"
+      end
+      anObject == @values.first
+    end
+
+
+    def each ( &block )
+      @values.each(&block)
+    end
+
+
+    def << ( anObject )
+      @values << anObject
+    end
+
+
+    def size
+      @values.size
+    end
+
+
+    alias :count :size
+
+  end # class EquivalenceClass
+
+
+
+  # Here the enumearation is something which respond to each.
+  def initialize ( enum=nil )
+    @hist = []
+    enum.each { |x| self << x } unless enum.nil?
+  end
+
+
+  # Returns an array with size of each equivalence class.
+  def support
+    @hist.map { |equivalence_class| equivalence_class.size }
+  end
+
+
+  # Returns apparation frequences as an array which is the @support@
+  # divided by the amount of samples.
+  def frequences
+    sup = support
+    total = sup.sum
+    sup.map { |x| x.to_f / total }
+  end
+
+
+  def total
+    support.sum
+  end
+
+
+  def equivalence_class_of ( anObject )
+    @hist.each do |anEquivalenceClass|
+      return anEquivalenceClass if anEquivalenceClass.include? anObject
+    end
+    return nil
+  end
+
+
+  def equivalence_class_by_index ( anInteger )
+    @hist[anInteger]
+  end
+
+
+  def << ( anObject )
+    anEquivalenceClass = equivalence_class_of anObject
+    if anEquivalenceClass.nil?
+      @hist << EquivalenceClass.new(@hist.size, anObject)
+    else
+      anEquivalenceClass << anObject
+    end
+    self
+  end
+
+
+  def [] ( anObject )
+    anEquivalenceClass = equivalence_class_of(anObject)
+    (anEquivalenceClass)? anEquivalenceClass.size : 0
+  end
+
+
+  def each ( &block )
+    @hist.each(&block)
+  end
+
+
+  def size
+    @hist.size
+  end
+
+
+  def to_a
+    @hist.dup
+  end
+
+end # class Histogram
+
+
+
+test_section __FILE__ do
+  require 'delegate'
+  require 'generator'
+
+  class HistogramTest < Test::Unit::TestCase
+
+    class Z_10Z_Integer < DelegateClass(Integer)
+      def == ( rhs )
+        to_i % 10 == rhs % 10
+      end
+      def succ
+        self.class.new(super)
+      end
+    end
+
+    def setup
+      @_1, @_42 = Z_10Z_Integer.new(1), Z_10Z_Integer.new(42)
+      @r = @_1 .. @_42
+      mk_hist(@r)
+      @support = [5, 5, 4, 4, 4, 4, 4, 4, 4, 4]
+    end
+
+    def mk_hist ( enum=nil, &block )
+      assert_nothing_raised { @h = Histogram.new(enum, &block) }
+      @h
+    end
+
+    def test_init_via_enum
+      assert_equal(1, mk_hist([0] * 10).size)
+      assert_equal(10, @h[0])
+      assert_equal(0, @h[1])
+    end
+
+    def test_uniform_range
+      assert_equal(11, mk_hist(0 .. 10).size)
+      (0 .. 10).each { |i| assert_equal(1, @h[i]) }
+      assert_equal(0, @h[11])
+    end
+
+    def test_a_large_uniform_range
+      enum = (0 .. 10).to_a * 10
+      mk_hist(enum)
+      assert_equal(0, @h[11])
+      enum.each { |i| assert_equal(10, @h[i]) }
+      assert_equal(0, @h[11])
+    end
+
+    def test_push # <<
+      assert_nothing_raised { @h << 12 }
+      assert_equal(5, @h[11])
+      assert_equal(6, @h[12])
+      @h << 11 << 12 << 22
+      assert_equal(4, @h[10])
+      assert_equal(6, @h[11])
+      assert_equal(8, @h[12])
+    end
+
+    def test_hooks # []
+      @h << 42
+      assert_kind_of(Integer, @h[42])
+      assert_equal(6, @h[42])
+    end
+
+    def test_each
+      g1 = Generator.new([5, 5, 4, 4, 4, 4, 4, 4, 4, 4])
+      g2 = Generator.new(@r)
+      @h.each do |equivalence_class|
+        assert_equal(x = g1.next, equivalence_class.size)
+        assert_equal(x, equivalence_class.values.size)
+        assert_equal(g2.next, equivalence_class.values.first)
+      end
+    end
+
+    def test_equivalence_class_of
+      assert_kind_of(Histogram::EquivalenceClass, @h.equivalence_class_of(42))
+      assert_equal([10, 20, 30, 40], @h.equivalence_class_of(0).values)
+      assert_equal([2, 12, 22, 32, 42], @h.equivalence_class_of(12).values)
+      assert_equal(5, @h[42])
+    end
+
+    def test_size
+      assert_equal(10, @h.size)
+    end
+    
+    def test_support
+      assert_equal(@support, @h.support)
+    end
+
+    def test_total
+      assert_equal(42, @h.total)
+    end
+
+    def test_frequences
+      assert_equal(@support, @h.frequences.map { |x| x * 42 })
+    end
+
+  end # class HistogramTest
+
+end