objective_command 0.1.5.0

data/lib/objective_command/commands/command.rb

@@ -0,0 +1,535 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005, 2006 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: /w/fey/cmd/trunk/lib/objective_command/commands/command.rb 29674 2006-09-12T21:05:16.387536Z ertai  $
+
+module ObjectiveCommand
+
+  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.flatten
+        @open_mode = :w
+        @dir = nil
+        @input, @output, @error = nil, nil, nil
+      end
+
+      #
+      # Running methods.
+      #
+
+      @@default_runners = {}
+      def run_with_options ( runner_class, options )
+        if options.empty?
+          runner = @@default_runners[runner_class] ||= runner_class.new
+        else
+          runner = runner_class.new.apply_options options
+        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 ObjectiveCommand::Runners::Runner and return a ObjectiveCommand::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.to_sh }.join(' ')
+      end
+
+      def whereis ( path=ENV['PATH'] )
+        # FIXME
+      end
+
+
+      #
+      # Conversion methods
+      #
+
+      def to_s
+        str = @command.to_s.to_sh
+        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 inspect_for_unified_matchers
+        "#{to_s.inspect}.to_ocmd"
+      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.to_sh}" 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_ocmd
+        self
+      end
+
+      def freeze
+        super
+        for i in [@command, @dir, @input, @output, @error, @args] do
+          i.freeze
+        end
+      end
+
+    end # class Command
+
+    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 teardown
+          [@file, @tmp, @tmp2].each { |t| t.clean }
+        end
+
+        def test_0_initialize
+        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_ocmd.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' << 'b"o' << '\o/' << '>' << 'b3o'
+          assert_equal('"foo bar" baz "b\\"o" "\\\\o/" ">" b3o', @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_ocmd
+          wc = 'wc'.to_ocmd
+          (ls | wc) < @file > @tmp
+        end
+
+        def test_where
+          # FIXME
+        end
+
+      end # class CommandTest
+
+    end
+
+  end # module Commands
+
+end # module ObjectiveCommand

data/lib/objective_command/commands/factory.rb

@@ -0,0 +1,69 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005, 2006 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: /w/fey/cmd/trunk/lib/objective_command/commands/factory.rb 22684 2006-03-12T16:36:11.301558Z pouillar  $
+
+module ObjectiveCommand
+
+  module Commands
+
+    class Factory < Command
+
+      def initialize
+        super(nil)
+        @command_class = Command
+      end
+
+      def new_command ( *a, &b )
+        cmd = @command_class.new(*a, &b)
+        instance_variables.each do |var|
+          next if var =~ /^@command(_class)?$/
+          cmd.send(var[1..-1] + '=', instance_variable_get(var))
+        end
+        cmd
+      end
+
+      alias :create :new_command
+
+    end # class Factory
+
+
+
+    test_section __FILE__ do
+
+      class FactoryTest < Test::Unit::TestCase
+
+        def setup
+          assert_nothing_raised { @fa = Factory.new }
+        end
+
+        def test_0_initialize
+        end
+
+        def test_new_command
+          assert_nothing_raised do
+            assert_kind_of(Command, @fa.create('wc'))
+            assert_kind_of(Command, @fa.new_command('ls'))
+          end
+        end
+
+        def test_simple
+          assert_nothing_raised do
+            @fa << 42
+            @fa.input = 'inp'
+            @fa = @fa > 'out'
+            @cmd = @fa.create('foo')
+          end
+          assert_equal('foo', @cmd.command)
+          assert_equal(42, @cmd.args.first)
+          assert_equal('inp', @cmd.input)
+          assert_equal('out', @cmd.output)
+        end
+
+      end # class FactoryTest
+
+    end
+
+  end # module Commands
+
+end # module ObjectiveCommand

data/lib/objective_command/commands/pipe.rb

@@ -0,0 +1,121 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005, 2006 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: /w/fey/cmd/trunk/lib/objective_command/commands/pipe.rb 22779 2006-03-19T18:30:55.288309Z ertai  $
+
+class IO
+
+  def pipe?
+    false
+  end
+
+  class << self
+
+    alias_method :pipe_without_pipe?, :pipe unless method_defined? :pipe_without_pipe?
+
+    def pipe
+      ios = pipe_without_pipe?
+      ios.each do |io|
+        io.send(:define_singleton_method, :pipe?) { true }
+      end
+      ios
+    end
+
+  end # class << self
+
+end # class IO
+
+module ObjectiveCommand
+
+  module Commands
+
+    class Pipe < Command
+
+      def initialize ( *cmds )
+        @cmds = cmds.flatten.map { |x| x.dup }
+      end
+
+      def run ( runner=@runner, *a )
+        if runner.nil?
+          raise ArgumentError, "need a runner not: #{runner.inspect}"
+        end
+        datas = Datas::Composite.new
+        runner = runner.dup
+        runner.hook_trigger :display_command, self
+        runner.disable_hook :display_command
+        runner.disable_hook :waitpid
+        ([nil] + @cmds).zip(@cmds + [nil]).each do |cmd1, cmd2|
+          next if cmd1.nil? or cmd2.nil?
+          rd, wr = IO.pipe
+          cmd1_runner = runner.dup
+          cmd1_runner.disable_hook :waitpid
+          cmd1_runner.subscribe_hook(:son) { rd.close }
+          cmd1.output = wr
+          cmd2.input = rd
+          datas << cmd1.run(cmd1_runner)
+          wr.close
+        end
+        runner = runner.dup
+        datas << @cmds.last.run(runner, *a)
+        datas.waitpid if runner.is_a? Runners::System
+        datas
+      end
+
+      def input= ( arg )
+        @cmds.first.input = arg
+      end
+
+      def input
+        @cmds.first.input
+      end
+
+      def output= ( arg )
+        @cmds.last.output = arg
+      end
+
+      def output
+        @cmds.last.output
+      end
+
+      def error= ( arg )
+        @cmds.last.error = arg
+      end
+
+      def error
+        @cmds.last.error
+      end
+
+      %w[ args command ].each do |meth|
+        class_eval %Q{
+          def #{meth} ( *a, &b )
+            raise ArgumentError, "no method `#{meth}' on a pipe"
+          end
+        }
+      end
+
+      def [] ( *args )
+        new_cmds = @cmds.dup
+        new_cmds[-1] = new_cmds.last[*args]
+        Pipe.new(*new_cmds)
+      end
+
+      #
+      # Conversion methods
+      #
+
+      def to_sh
+        strs = @cmds.map { |cmd| "(#{cmd.to_sh})" }
+        "#{strs.join(' | ')}"
+      end
+
+      def to_s
+        to_sh
+      end
+
+
+
+    end # class Pipe
+
+  end # module Commands
+
+end # module ObjectiveCommand