ruby_ex 0.4.6.2 → 0.5.5.0

data/lib/commands.rb

@@ -1,27 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
-# License::   GNU General Public License (GPL).
-# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/commands.rb 8049 2005-12-31T16:01:12.162089Z ertai  $
-
-# Provides an object oriented way to manage, combine and run your commands.
-#
-# Example:
-#   require 'rubygems' ; require_gem 'ruby_ex' ; require 'ruby_ex'
-#   Commands.import!
-#   ls, wc, out = 'ls'.to_cmd, 'wc'.to_cmd, 'out'.to_path
-#
-#   data = ls.system # other runners exist (exec, fork, sh...)
-#
-#   p data.status
-#   puts data.output.read
-#
-#   (ls > STDOUT).system
-#
-#   cmd = ls['*.rb'] | wc['-l'] > out
-#   cmd.system
-# 
-#   puts out.read
-module Commands
-end # module Commands
-
-Commands::Helpers.import!

data/lib/commands/command.rb

@@ -1,545 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
-# License::   GNU General Public License (GPL).
-# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/commands/command.rb 8052 2006-01-01T16:29:27.129829Z ertai  $
-
-module Commands
-
-  class Command
-
-    attr_accessor :command
-    attr_accessor :dir
-    attr_accessor :input
-    attr_accessor :output
-    attr_accessor :error
-    attr_accessor :args
-    attr_accessor :open_mode
-
-    #
-    # Construction methods.
-    #
-
-    def initialize ( command_name, *args )
-      @command = command_name
-      @args = args.dup
-      @open_mode = :w
-      @input, @output, @error = nil, nil, nil
-    end
-
-    #
-    # Command['wc -l'].sh
-    #
-    def self.[] ( *args )
-      new(*args)
-    end
-
-
-
-    #
-    # Running methods.
-    #
-
-    @@default_runners = {}
-    @@running_options =
-    {
-      :verbose => :make_verbose,
-      :v       => :make_verbose,
-      :raise   => :raise_on_failures,
-      :r       => :raise_on_failures,
-      :debug   => :make_debug,
-      :d       => :make_debug,
-      :mock    => :make_mock,
-      :m       => :make_mock,
-    }
-    def run_with_options ( runner_class, options )
-      if options.empty?
-        runner = @@default_runners[runner_class] ||= runner_class.new
-      else
-        runner = runner_class.new
-        options.each do |k|
-          runner.send(@@running_options[k])
-        end
-      end
-      run(runner)
-    end
-
-
-    # Simulate Kernel#system() to run the command (No shell expansion).
-    def system ( *options )
-      run_with_options(Runners::System, options.flatten)
-    end
-
-
-    # Use the ExecRunner.
-    def exec ( *options )
-      run_with_options(Runners::Exec, options.flatten)
-    end
-
-
-    # FIXME test me
-    def sys ( *options )
-      run_with_options(Runners::System, [:v, :r] + options.flatten)
-    end
-
-
-    # Use Kernel#system() but with a string to have the shell expansion.
-    # FIXME make me a runner
-    def sh
-      Kernel.system(to_sh)
-    end
-
-
-    # Use Kernel#exec() but with a string to have the shell expansion.
-    # FIXME make me a runner
-    def sh!
-      Kernel.exec(to_sh)
-    end
-
-
-    # Use Kernel#` and return the resulting string.
-    # FIXME make me a runner
-    def expand
-      `#{to_sh}`
-    end
-
-
-    def popen ( *options )
-      run_with_options(Runners::Popen, options.flatten)
-    end
-
-
-    def fork ( *options )
-      run_with_options(Runners::Fork, options.flatten)
-    end
-
-
-    # FIXME design me!
-    # FIXME make me a runner
-    def ruby
-    end
-
-
-    # Use a Commands::Runners::Runner and return a Commands::Datas::Data.
-    def run ( runner=@runner )
-      unless runner.respond_to? :run
-        raise ArgumentError, "need a runner not: #{runner.inspect}"
-      end
-      runner.run(self)
-    end
-
-
-
-    #
-    # Operators.
-    #
-
-
-    # Pipe two commands.
-    def | ( rhs )
-      Commands::Pipe.new(self, rhs)
-    end
-
-
-    # Supply return a new commands with these arguments added.
-    def [] ( *args )
-      cmd = dup
-      cmd.args += args.flatten
-      cmd
-    end
-
-
-    # Chain two commands (like a `;' in shell), and return a new one.
-    def + ( rhs )
-      case rhs
-      when Command
-        Seq.new(self, rhs)
-      else
-        self[rhs]
-      end
-    end
-
-
-    # Return a new command with the given command input.
-    def < ( arg )
-      cmd = dup
-      cmd.input = arg
-      cmd
-    end
-
-
-    def add_outputs ( out, err )
-      cmd = dup
-      cmd.output = out.dup if out
-      cmd.error = err.dup if err
-      cmd
-    end
-    protected :add_outputs
-
-
-    # Return a new command with the given command output.
-    def > ( arg )
-      out, err = (arg.is_a?(Array))? arg : [arg, nil]
-      add_outputs(out, err)
-    end
-
-
-    # Like > but open the output in append mode.
-    def >> ( arg )
-      out, err = (arg.is_a?(Array))? arg : [arg, nil]
-      @open_mode = :a
-      add_outputs(out, err)
-    end
-
-
-    # Add an argument to a command.
-    # cmd = Command.new('ls')
-    # cmd << '-la'
-    # cmd.sh
-    def << ( arg )
-      @args << arg
-      self
-    end
-
-
-
-    #
-    # Misc
-    #
-
-    def arg_string
-      @args.map { |arg| arg.to_s.dump }.join(' ')
-    end
-
-    def whereis ( path=ENV['PATH'] )
-      # FIXME
-    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
-      cmd = instanciate_args
-      "#{cmd.to_s}#{cmd.sh_args}"
-    end
-
-    def instanciate_args!
-      if defined? @input and @input and @args.include? '%i'
-        @args.map! { |a| (a == '%i')? @input : a }
-        @input = nil
-      end
-      if defined? @output and @output and @args.include? '%o'
-        @args.map! { |a| (a == '%o')? @output : a }
-        @output = nil
-      end
-      if defined? @error and @error and @args.include? '%e'
-        @args.map! { |a| (a == '%e')? @error : a }
-        @error = nil
-      end
-    end
-
-    def instanciate_args
-      copy = dup
-      copy.instanciate_args!
-      copy
-    end
-
-    def sh_args
-      args = ''
-      [ ['<', input], ['>', output], ['2>', error] ].each do |str, io|
-        args += " #{str} #{io.to_s.dump}" if io and not (io.respond_to? :pipe? and io.pipe?)
-      end
-      args
-    end
-
-
-    def to_a
-      [@command.dup, *@args.map { |arg| arg.to_s }]
-    end
-
-    def to_cmd
-      self
-    end
-
-  end # class Command
-
-  Commands::Helpers.import!
-
-  test_section __FILE__ do
-
-    class CommandTest < Test::Unit::TestCase
-
-      def setup
-        @file = TempPath.new
-        @tmp = TempPath.new
-        @tmp2 = 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')
-        @sleep = Command.new('sleep')
-        @dne = Command.new('ThisCommandDoesNotExist')
-        @dev_null = Pathname.new('/dev/null')
-      end
-
-      def tear_down
-        [@file, @tmp, @tmp2].each { |t| t.clean }
-      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_dne
-        @dne.system
-        assert_equal(127, $?.exitstatus)
-      end
-
-      def test_system
-        @touch << @tmp.to_s
-        @touch.system
-        assert_equal(0, $?)
-        assert(@tmp.exist?)
-      end
-
-      def test_system_raise_on_failures
-        assert_raise(Runners::Runner::FailureHooker::Error) do
-          'false'.to_cmd.system(:r)
-        end
-        assert_not_equal(0, $?)
-      end
-
-      def test_sh_and_pipe
-        ((@cat | @wc) < @file > @tmp).sh
-        assert_equal(0, $?)
-        assert(@tmp.exist?)
-        assert_match(/\s*2\s*4\s*17\s+/, @tmp.read)
-      end
-
-      def test_system_and_pipe
-        ((@cat | @wc) < @file.open('r+') > @tmp).system
-        assert_equal(0, $?)
-        assert(@tmp.exist?)
-        assert_match(/\s*2\s*4\s*17\s+/, @tmp.read)
-      end
-
-      def test_system_is_not_sh
-        @cat << '$TEST_FILE'
-        @cat.error = @dev_null
-        (@cat > @tmp).system
-        assert_not_equal(0, $?)
-        assert(!@tmp.exist? || @tmp.zero?)
-      end
-
-      def test_exec
-        @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
-
-      def test_exec_not_sh!
-        @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
-
-      def test_sh
-        @cat << '$TEST_FILE'
-        (@cat > @tmp).sh
-        assert_equal(0, $?)
-        assert(@tmp.exist?)
-        assert_equal(@file.read, @tmp.read)
-      end
-
-      def test_sh2
-        ((@cat | @wc) < @file > @tmp).sh
-        assert_equal(0, $?)
-        assert(@tmp.exist?)
-        assert_match(/\s*2\s*4\s*17\s+/, @tmp.read)
-      end
-
-      def test_sh!
-        @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
-
-      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\s+/, str)
-      end
-
-      # FIXME
-      def test_popen
-        cmd = (@touch + @tmp) + (@sleep + 1)
-        diff = DTime.diff { @data = cmd.popen }
-        assert(@tmp.exist?)
-        @data.waitpid
-        assert(@tmp.exist?)
-        assert(diff.to_f < 1)
-      end
-
-      def test_fork
-        sleep_arg = 2
-        cmd = (@touch + @tmp) + (@sleep + sleep_arg)
-        diff = DTime.diff { @data = cmd.fork }
-        assert(@tmp.exist?)
-        @data.waitpid
-        assert(@tmp.exist?)
-        assert(diff.to_f < sleep_arg, "#{diff} should be < #{sleep_arg}")
-      end
-
-      def test_ruby
-        # FIXME
-      end
-
-      def test_pipe # test_|
-        assert_kind_of(Pipe, (@cat | @wc) < @file)
-      end
-
-      def test_subscript # test_[]
-        assert_equal(['a', 'b'], @cat['a', 'b'].args)
-        assert_equal(['a'], @cat['a'].args)
-        assert_equal([], @cat[].args)
-        assert_equal(['a', 'b', 'c'], @cat[[['a'], 'b', ['c']]].args)
-      end
-
-      def test_chain # test_+
-        assert_kind_of(Seq, (@cat + @wc) < @file)
-        cmd = @cat + @file.to_s
-        assert_kind_of(Command, cmd)
-        assert_equal([@file.to_s], cmd.args)
-        cmd += ['a', 'b']
-        assert_equal([@file.to_s, 'a', 'b'], cmd.args)
-        cmd += @file.to_s
-        assert_equal([@file.to_s, 'a', 'b', @file.to_s], cmd.args)
-      end
-
-      def test_chain_complex
-        ((@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\s*#{@tmp}\s+/, @tmp2.read)
-      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, @cat.object_id)
-      end
-
-      def test_add_output # test_>
-        @cat.output = 'foo'
-        assert_equal('foo', @cat.output)
-        cmd = @cat > 'bar'
-        assert_equal('bar', cmd.output)
-        cmd = @cat > @file
-        assert_equal(@file, cmd.output)
-        assert_equal(:w, cmd.open_mode)
-        assert_not_equal(cmd.object_id, @cat.object_id)
-        cmd = @cat > [ 'outbar', 'errbar' ]
-        assert_equal('outbar', cmd.output)
-        assert_equal('errbar', cmd.error)
-        cmd = @cat > [ @file, @file ]
-        assert_equal(:w, cmd.open_mode)
-      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, @cat.object_id)
-        cmd = @cat >> @file
-        assert_equal(@file, cmd.output)
-        assert_equal(:a, cmd.open_mode)
-        cmd = @cat >> [ 'outbar', 'errbar' ]
-        assert_equal('outbar', cmd.output)
-        assert_equal('errbar', cmd.error)
-        cmd = @cat >> [ @file, @file ]
-        assert_equal(:a, cmd.open_mode)
-      end
-
-      def test_args
-        assert_equal([], @cp.args)
-        @cat << 'foo bar' << 'baz'
-        assert_equal(['foo bar', 'baz'], @cat.args)
-      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
-        ls = 'ls'.to_cmd
-        wc = 'wc'.to_cmd
-        (ls | wc) < @file > @tmp
-      end
-
-      def test_where
-        # FIXME
-      end
-
-    end # class CommandTest
-
-  end
-
-end # module Commands