ruby_ex 0.1.1

data/src/commands.rb

@@ -0,0 +1,20 @@
+# 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 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+require 'module/autoload_tree'
+require 'abstract'
+require 'hookable'
+require 'hooker'
+require 'commands/helpers'
+require 'commands/datas'
+require 'commands/runners'
+
+
+module Commands
+
+  autoloaded_module(__FILE__, false)
+
+end # module Commands

data/src/commands/command.rb

@@ -0,0 +1,492 @@
+# 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 255 2005-06-01 00:08:46Z ertai $
+
+require 'commands'
+
+module Commands
+
+  class Command
+
+    attr_accessor :command
+    attr_accessor :dir
+    attr_accessor :input
+    attr_accessor :output
+    attr_accessor :error
+    attr_accessor :args
+
+    #
+    # Construction methods.
+    #
+
+    def initialize ( command_name, *args )
+      @command = command_name
+      @args = 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? @@system_runner
+        @@system_runner = Runners::System.new
+      end
+      run(@@system_runner)
+    end
+
+
+    # Use the ExecRunner.
+    def exec
+      unless defined? @@exec_runner
+        @@exec_runner = Runners::Exec.new
+      end
+      run(@@exec_runner)
+    end
+
+
+    # FIXME test me
+    def sys
+      unless defined? @@sys_runner
+        @@sys_runner = Runners::System.new.make_verbose.raise_on_failures
+      end
+      run(@@sys_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
+
+
+    def popen
+      unless defined? @@fork_runner
+        @@fork_runner = Runners::Fork.new
+      end
+      run(@@fork_runner)
+    end
+    alias :fork :popen
+
+
+    # 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
+
+
+    # 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, mode )
+      cmd = dup
+      cmd.output = out.dup
+      cmd.output.open_mode = mode if cmd.output.is_a? Pathname
+      if err
+        cmd.error = err.dup
+        cmd.error.open_mode = mode if cmd.error.is_a? Pathname
+      end
+      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, 'w')
+    end
+
+
+    # Like > but open the output in append mode.
+    def >> ( arg )
+      out, err = (arg.is_a?(Array))? arg : [arg, nil]
+      add_outputs(out, err, 'a')
+    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
+      "#{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.dup, *@args.map { |arg| arg.to_s }]
+    end
+
+    def to_cmd
+      self
+    end
+
+  end # class Command
+
+  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
+      end
+
+      def test_system
+        @touch << @tmp.to_s
+        @touch.system
+        assert_equal(0, $?)
+        assert(@tmp.exist?)
+      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
+
+      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
+        cmd = (@touch + @tmp) + (@sleep + 1)
+        diff = DTime.diff { @data = cmd.fork }
+        assert(@tmp.exist?)
+        @data.waitpid
+        assert(@tmp.exist?)
+        assert(diff.to_f < 1)
+      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, @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)
+        cmd = @cat > @file
+        assert_equal(@file, cmd.output)
+        assert_equal('w', cmd.output.open_mode)
+        assert_not_equal(cmd.object_id, @bar.object_id)
+        cmd = @cat > [ 'outbar', 'errbar' ]
+        assert_equal('outbar', cmd.output)
+        assert_equal('errbar', cmd.error)
+        cmd = @cat > [ @file, @file ]
+        assert_equal('w', cmd.output.open_mode)
+        assert_equal('w', cmd.error.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, @bar.object_id)
+        cmd = @cat >> @file
+        assert_equal(@file, cmd.output)
+        assert_equal('a', cmd.output.open_mode)
+        cmd = @cat >> [ 'outbar', 'errbar' ]
+        assert_equal('outbar', cmd.output)
+        assert_equal('errbar', cmd.error)
+        cmd = @cat >> [ @file, @file ]
+        assert_equal('a', cmd.output.open_mode)
+        assert_equal('a', cmd.error.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