vcs 0.1 → 0.2.148

data/ruby_ex/checkout.rb

@@ -0,0 +1,12 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: checkout.rb 159 2005-02-18 12:07:23Z polrop $
+
+require 'uri_ex' 
+require 'uri/http_ex'
+require 'uri/ftp_ex'
+require 'uri/file'
+require 'uri/svn'

data/ruby_ex/choose.rb

@@ -0,0 +1,271 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: choose.rb 219 2005-05-09 12:26:29Z ertai $
+
+
+require 'random_generators'
+
+
+class Integer
+
+  def self.choose ( limit=nil, generator=nil )
+    limit.to_i.choose(generator)
+  end
+
+  def choose ( generator=nil )
+    (generator || RandomGenerators.default).choose_integer(self)
+  end
+
+end # class Integer
+
+
+
+class Float
+
+  def self.choose ( limit=nil, generator=nil )
+    (limit || 1.0).to_f.choose(generator)
+  end
+
+  def choose ( generator=nil )
+    (generator || RandomGenerators.default).choose_float(self)
+  end
+
+end # class Float
+
+
+
+class Hash
+
+  def choose ( limit=nil, generator=nil )
+    self[keys.choose(limit, generator)]
+  end
+
+end # class Hash
+
+
+
+class Array
+
+  def choose ( limit=nil, generator=nil )
+    n = size
+
+    # Out of limits: limit > size (FIXME warn)
+    limit = n if limit.nil? or limit > n
+
+    self[limit.choose(generator)]
+  end
+
+end # class Array
+
+
+
+module Enumerable
+
+  def choose ( limit=nil, generator=nil )
+    to_a.choose(limit, generator)
+  end
+
+end # module Enumerable
+
+
+
+class Range
+
+  def choose ( generator=nil )
+    case first
+    when Integer
+      first + (last + 1 - first).choose(generator)
+    else
+      super(nil, generator)
+    end
+  end
+
+end # class Array
+
+
+
+if $0 == __FILE__
+
+  class MockRandomGenerator < RandomGenerators::RandomGenerator
+    concrete
+    attr_reader :ref
+    def initialize ( tab_i, tab_f )
+      raise unless tab_i.is_a? Array
+      raise unless tab_f.is_a? Array
+      @ref, @ref_f, @pos = tab_i, tab_f, -1
+    end
+    def get ( tab )
+      tab[@pos = (@pos + 1) % tab.size]
+    end
+    def choose_integer ( n )
+      check_choose_integer(n)
+      get(@ref) % n
+    end
+    def choose_float ( f=1.0 )
+      check_choose_float(f)
+      get(@ref_f) * f
+    end
+  end # class MockRandomGenerator
+
+  class RandomMockRandomGenerator < MockRandomGenerator
+    def initialize ( n )
+      tab_i = (0 .. n - 1).to_a.shuffle
+      tab_f = []
+      n.times { tab_f << Float.choose() }
+      super(tab_i, tab_f)
+    end
+  end # class RandomMockRandomGenerator
+
+
+  require 'test/unit'
+  require 'set'
+
+  class ChooseTest < Test::Unit::TestCase
+
+    REF_5 = [1, 2, 4, 0, 3]
+    REF_F_5 = [0.187528345035389, 0.368857819121331, 0.06954449811019,
+                0.188887464581057, 0.213757352204993]
+    REF_50 = [
+      28,  12,  17,  10, 1, 37, 46, 25, 47, 2, 45, 36, 20, 5, 30, 14, 18, 39,
+      8,  15,  16, 43, 27, 33, 22, 7, 32, 3, 35, 9, 19, 13, 21, 6, 23, 26, 4,
+      40, 44, 11, 49, 29, 42, 24, 31, 48, 34, 0, 38, 41
+    ]
+    REF_F_50 = [
+      0.643785412423313, 0.765736325876787, 0.604515956481919,
+      0.133839202811942, 0.350400971015915, 0.966710213804618,
+      0.904755113180727, 0.88459848286584, 0.163951952941716,
+      0.808023529592901, 0.387806572020054, 0.659689131658524,
+      0.289974238490686, 0.813535830006003, 0.565311754588038,
+      0.889200099511072, 0.0668127918615937, 0.992091996129602,
+      0.604403987759724, 0.89254002738744, 0.601499371463433,
+      0.754795648856089, 0.751190354581922, 0.434389552799985,
+      0.761369747575372, 0.174903159961104, 0.940325234550983,
+      0.536097376374528, 0.957906004507095, 0.693120914744213,
+      0.23448576242663, 0.638284107437357, 0.423910334473476,
+      0.251349127152935, 0.457931924844161, 0.20579389645718,
+      0.256057573715225, 0.584466924890876, 0.609375598141924,
+      0.0856487881392241, 0.437958877766505, 0.432312048738822,
+      0.81560374982655, 0.142059376928955, 0.118824432371184,
+      0.958816710859537, 0.69899930502288, 0.118259542621672,
+      0.52218786906451, 0.339233995880932
+    ]
+
+    def checker_n ( n, ref_i, ref_f, inp, ref, lim=nil )
+      mrg = MockRandomGenerator.new(ref_i, ref_f)
+      my = []
+      if lim == :no
+        n.times { my << inp.choose(mrg) }
+      else
+        n.times { my << inp.choose(lim, mrg) }
+      end
+      assert_equal(ref, my)
+    end
+
+    def checker_5 ( inp, ref, lim=nil )
+      checker_n(5, REF_5, REF_F_5, inp, ref, lim)
+    end
+
+    def checker_50 ( inp, ref, lim=nil )
+      checker_n(50, REF_50, REF_F_50, inp, ref, lim)
+    end
+
+
+
+
+    def test_integer
+      checker_5 Integer, REF_5, 5
+      checker_50 Integer, REF_50, 50
+      assert(Integer.choose(1000) < 1000)
+    end
+
+    def test_float
+      checker_5 Float, REF_F_5, 1.0
+      checker_50 Float, REF_F_50, 1.0
+      assert(Float.choose(2.0) < 2)
+      assert(Float.choose < 1)
+    end
+
+    def test_array_5
+      checker_5 [4], [4] * 5, 5
+      checker_5 [4, 5], [5, 4, 4, 4, 5], 5
+      checker_5 [4, 5, 6], [5, 6, 5, 4, 4], 5
+      checker_5 [2, 1, 0, 5, 4, 3], [1, 0, 4, 2, 5], 5
+      10.times { assert(REF_50.include?(REF_50.choose)) }
+    end
+
+    def test_set_5
+      checker_5 Set[4], [4] * 5, 5
+      checker_5 Set[4, 5], [4, 5, 5, 5, 4], 5
+      checker_5 Set[4, 5, 6], [6, 4, 6, 5, 5], 5
+      checker_5 Set[2, 1, 0, 5, 4, 3], [0, 1, 3, 5, 2], 5
+      set = REF_50.to_set
+      10.times { assert(set.include?(set.choose)) }
+    end
+
+    def test_hash
+      checker_5({ 1 => 2 }, [2] * 5, 5)
+      checker_5({ 1 => 2, 3 => 4 }, [4, 2, 2, 2, 4], 5)
+    end
+
+    def test_array_50
+      checker_50 [4], [4] * 50, 50
+      checker_50 [
+        36,  16,  15, 6, 27, 33, 17, 10, 18, 39, 8, 43, 19, 23, 49, 40, 46, 37,
+        9,  41, 35, 0, 38, 26, 22, 4, 7, 25, 21, 12, 42, 45, 28, 5, 31, 24, 34,
+        48, 32, 30, 13, 29, 11, 2, 1, 20, 3, 44, 47, 14
+      ], [
+        21,  19,  37,  8,  16, 48, 3, 4, 44, 15, 20, 34, 35, 33, 42, 49, 9, 30,
+        18,  40, 46, 2, 25, 5, 38, 10, 28, 6, 24, 39, 41, 23, 0, 17, 26, 7, 27,
+        13, 1, 43, 14, 12, 11, 22, 45, 47, 31, 36, 32, 29
+      ], 50
+    end
+
+    def test_integer_instances
+      assert_raise(ArgumentError) { checker_5 0, [], :no }
+      checker_5 1, [0] * 5, :no
+      checker_5 4, [1, 2, 0, 0, 3], :no
+      checker_5 10, REF_5, :no
+      assert(1000.choose < 1000)
+    end
+
+    def test_float_instances
+      assert_raise(ArgumentError) { checker_5 0.0, [], :no }
+      checker_5  1.0, [ 0.187528345035389, 0.368857819121331, 0.06954449811019,
+                        0.188887464581057, 0.213757352204993 ], :no
+      assert(2.0.choose < 2)
+    end
+
+    def test_integer_range_instances
+      checker_5 1..1, [1] * 5, :no
+      checker_5 1..2, [2, 1, 1, 1, 2], :no
+      checker_5 0..1, [1, 0, 0, 0, 1], :no
+      checker_5 0..4, [1, 2, 4, 0, 3], :no
+    end
+
+    class Xs
+      include Comparable
+      attr_reader :length
+      def initialize ( n )
+        @length = n
+      end
+      def succ
+        Xs.new(@length.succ)
+      end
+      def <=> ( rhs )
+        @length <=> rhs.length
+      end
+      def inspect
+        'x' * @length
+      end
+    end
+
+    def test_range_instances
+      checker_5 'a'..'a', ['a'] * 5, :no
+      checker_5 'a'..'b', ['b', 'a', 'a', 'a', 'b'], :no
+      checker_5 Xs.new(1)..Xs.new(4), [2, 3, 1, 1, 4].map { |x| Xs.new(x) }, :no
+    end
+
+  end # class ChooseTest
+
+end

data/ruby_ex/commands.rb

@@ -0,0 +1,18 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: commands.rb 221 2005-05-09 12:40:57Z ertai $
+
+require 'module/autoload_tree'
+require 'pathname_ex'
+require 'abstract'
+require 'commands/helpers'
+require 'mktemp'
+require 'commands/runners'
+
+
+module Commands
+
+  autoloaded_module(__FILE__)
+
+end # module Commands

data/ruby_ex/commands/command.rb

@@ -0,0 +1,401 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: command.rb 221 2005-05-09 12:40:57Z ertai $
+
+module Commands
+
+  class Command
+
+    attr_accessor :command
+    attr_accessor :dir
+    attr_accessor :input
+    attr_accessor :output
+    attr_accessor :error
+    attr_accessor :arg_list
+
+    #
+    # Construction methods.
+    #
+
+    def initialize ( command_name, *args )
+      @command = command_name
+      @arg_list = args.dup
+    end
+
+    #
+    # Command['wc -l'].sh
+    #
+    def self.[] ( *args )
+      new(*args)
+    end
+
+
+
+    #
+    # Running methods.
+    #
+
+    # Simulate Kernel#system() to run the command (No shell expansion).
+    def system
+      unless defined? @@fork_runner
+        @@fork_runner = Runners::Fork.new
+      end
+      run(@@fork_runner)
+    end
+
+
+    # Use the ExecRunner.
+    def exec
+      unless defined? @@exec_runner
+        @@exec_runner = Runners::Exec.new
+      end
+      run(@@exec_runner)
+    end
+
+
+    # Use Kernel#system() but with a string to have the shell expansion.
+    def sh
+      Kernel.system(to_sh)
+    end
+
+
+    # Use Kernel#exec() but with a string to have the shell expansion.
+    def sh!
+      Kernel.exec(to_sh)
+    end
+
+
+    # Use Kernel#` and return the resulting string.
+    def expand
+      `#{to_sh}`
+    end
+
+
+    # FIXME design me!
+    def ruby
+    end
+
+
+    # Use a Commands::Runners::Runner and return a Commands::Datas::Data.
+    def run ( runner=@runner )
+      runner.run(self)
+    end
+
+
+
+    #
+    # Operators.
+    #
+
+
+    # Pipe two commands.
+    def | ( rhs )
+      Pipe.new(self, rhs)
+    end
+
+
+    # Chain two commands (like a `;' in shell), and return a new one.
+    def + ( rhs )
+      Seq.new(self, rhs)
+    end
+
+
+    # Return a new command with the given command input.
+    def < ( arg )
+      cmd = dup
+      cmd.input = arg
+      cmd
+    end
+
+
+    # Return a new command with the given command output.
+    def > ( arg )
+      cmd = dup
+      cmd.output = arg.dup
+      cmd.output.open_mode = 'w' if cmd.output.is_a? Pathname
+      cmd
+    end
+
+
+    # Like > but open the output in append mode.
+    def >> ( arg )
+      cmd = dup
+      cmd.output = arg.dup
+      cmd.output.open_mode = 'a' if cmd.output.is_a? Pathname
+      cmd
+    end
+
+
+    # Add an argument to a command.
+    # cmd = Command.new('ls')
+    # cmd << '-la'
+    # cmd.sh
+    def << ( arg )
+      @arg_list << arg
+    end
+
+
+
+    #
+    # Misc
+    #
+
+    def arg_list
+      @arg_list.dup
+    end
+
+
+    def arg_string
+      @arg_list.map { |arg| arg.dump }.join(' ').freeze
+    end
+
+
+    #
+    # Conversion methods
+    #
+
+    def to_s
+      str = @command.dump
+      arg_str = arg_string
+      str += ' ' + arg_str unless arg_str.empty?
+      str
+    end
+
+
+    def to_sh
+      "#{to_s}#{sh_args}"
+    end
+
+
+    def sh_args
+      args = ''
+      args += " < #{@input.to_s.dump}" if @input
+      args += " > #{@output.to_s.dump}" if @output
+      args += " 2> #{@error.to_s.dump}" if @error
+      args
+    end
+
+
+    def to_a
+      [@command, *@arg_list].freeze
+    end
+
+  end # class Command
+
+  if $0 == __FILE__
+    require 'test/unit'
+
+    class CommandTest < Test::Unit::TestCase
+
+      def setup
+        @file = TempPath.new
+        @file.open('w') { |f| f.puts "bla bla\n foo bar"}
+        ENV['TEST_FILE'] = @file.to_s
+        @touch = Command.new('touch')
+        @cp = Command.new('cp')
+        @cat = Command.new('cat')
+        @wc = Command.new('wc')
+        @dne = Command.new('ThisCommandDoesNotExist')
+        @dev_null = Pathname.new('/dev/null')
+      end
+
+      def test_0_initialize
+      end
+
+      def test_self_hook # test_self.[]
+        @cat << 'foo' << 'bar'
+        assert_equal(@cat.to_a, Command[*%w[cat foo bar]].to_a)
+      end
+
+      def test_system
+        TempPath.new do |tmp|
+          @touch << tmp.to_s
+          @touch.system
+          assert_equal(0, $?)
+          assert(tmp.exist?)
+        end
+      end
+
+      def test_sh_and_pipe
+        TempPath.new do |tmp|
+          ((@cat | @wc) < @file > tmp).sh
+          assert_equal(0, $?)
+          assert(tmp.exist?)
+          assert_match(/\s*2\s*4\s*17\n/, tmp.read)
+        end
+      end
+
+      def test_system_and_pipe
+        TempPath.new do |tmp|
+          ((@cat | @wc) < @file.open('r+') > tmp).system
+          assert_equal(0, $?)
+          assert(tmp.exist?)
+          assert_match(/\s*2\s*4\s*17\n/, tmp.read)
+        end
+      end
+
+      def test_system_is_not_sh
+        TempPath.new do |tmp|
+          @cat << '$TEST_FILE'
+          @cat.error = @dev_null
+          (@cat > tmp).system
+          assert_not_equal(0, $?)
+          assert(!tmp.exist? || tmp.zero?)
+        end
+      end
+
+      def test_exec
+        TempPath.new do |tmp|
+          @cp << @file << tmp
+          pid = fork do
+            @cp.exec
+          end
+          Process.waitpid pid
+          assert_equal(0, $?)
+          assert(tmp.exist?)
+          assert_equal(@file.read, tmp.read)
+        end
+      end
+
+      def test_exec_not_sh!
+        TempPath.new do |tmp|
+          @cat << '$TEST_FILE'
+          @cat.error = @dev_null
+          pid = fork do
+            (@cat > tmp).exec
+          end
+          Process.waitpid pid
+          assert_not_equal(0, $?)
+          assert(!tmp.exist? || tmp.size.zero?)
+        end
+      end
+
+      def test_sh
+        TempPath.new do |tmp|
+          @cat << '$TEST_FILE'
+          (@cat > tmp).sh
+          assert_equal(0, $?)
+          assert(tmp.exist?)
+          assert_equal(@file.read, tmp.read)
+        end
+
+        TempPath.new do |tmp|
+          ((@cat | @wc) < @file > tmp).sh
+          assert_equal(0, $?)
+          assert(tmp.exist?)
+          assert_match(/\s*2\s*4\s*17\n/, tmp.read)
+        end
+      end
+
+      def test_sh!
+        TempPath.new do |tmp|
+          @cat << '$TEST_FILE'
+          pid = fork do
+            (@cat > tmp).sh!
+          end
+          Process.waitpid pid
+          assert_equal(0, $?)
+          assert(tmp.exist?)
+          assert_equal(@file.read, tmp.read)
+        end
+      end
+
+      def test_expand
+        @cat << '$TEST_FILE'
+        str = (@cat).expand
+        assert_equal(0, $?)
+        assert_equal(@file.read, str)
+
+        str = ((@cat | @wc) < @file).expand
+        assert_equal(0, $?)
+        assert_match(/\s*2\s*4\s*17\n/, str)
+      end
+
+      def test_ruby
+        # FIXME
+      end
+
+      def test_pipe # test_|
+        assert_kind_of(Pipe, (@cat | @wc) < @file)
+      end
+
+      def test_chain # test_+
+        assert_kind_of(Seq, (@cat + @wc) < @file)
+        TempPath.new do |tmp|
+          TempPath.new do |tmp2|
+            ((@cat < @file > tmp) + (@wc < tmp > tmp2)).sh
+            assert_equal(0, $?)
+            assert(tmp.exist?)
+            assert(tmp2.exist?)
+            assert_equal(@file.read, tmp.read)
+            assert_match(/\s*2\s*4\s*17\n/, tmp2.read)
+          end
+        end
+      end
+
+      def test_add_input # test_<
+        @cat.input = 'foo'
+        assert_equal('foo', @cat.input)
+        cmd = @cat < 'bar'
+        assert_equal('bar', cmd.input)
+        assert_not_equal(cmd.object_id, @bar.object_id)
+      end
+
+      def test_add_output # test_>
+        @cat.output = 'foo'
+        assert_equal('foo', @cat.output)
+        cmd = @cat > 'bar'
+        assert_equal('bar', cmd.output)
+        assert_not_equal(cmd.object_id, @bar.object_id)
+      end
+
+      def test_append_output # test_>>
+        @cat.output = 'foo'
+        assert_equal('foo', @cat.output)
+        cmd = @cat >> 'bar'
+        assert_equal('bar', cmd.output)
+        assert_not_equal(cmd.object_id, @bar.object_id)
+      end
+
+      def test_arg_list
+        assert_equal([], @cp.arg_list)
+        @cat << 'foo bar' << 'baz'
+        assert_equal(['foo bar', 'baz'], @cat.arg_list)
+      end
+
+      def test_arg_string
+        assert_equal('', @cp.arg_string)
+        @cat << 'foo bar' << 'baz'
+        assert_equal('"foo bar" "baz"', @cat.arg_string)
+      end
+
+      def test_to_s
+        assert_equal('"cp"', @cp.to_s)
+        @cat << 'foo bar' << 'baz'
+        assert_equal('"cat" "foo bar" "baz"', @cat.to_s)
+      end
+
+      def test_to_sh
+        assert_equal('"cp" > "ya"', (@cp > 'ya').to_sh)
+        @cat << 'foo > bar' << '< baz'
+        assert_equal(
+          '(("cat" "foo > bar" "< baz" < "yay") | ("cp" > "yoy"))',
+          ((@cat | @cp) < 'yay' > 'yoy').to_sh)
+        @wc.error = 'foo'
+        assert_equal('"wc" 2> "foo"', @wc.to_sh)
+      end
+
+      def test_complex
+        TempPath.new do |tmp|
+          ls = 'ls'.to_cmd
+          wc = 'wc'.to_cmd
+          (ls | wc) < @file > tmp
+        end
+      end
+
+    end # class CommandTest
+
+  end
+
+end # module Commands