objective_command 0.1.5.0

data/lib/objective_command/runners/mockable.rb

@@ -0,0 +1,62 @@
+# 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/runners/mockable.rb 23187 2006-03-31T21:59:37.612710Z ertai  $
+
+module ObjectiveCommand
+
+  module Runners
+
+    module Mockable
+
+      def make_mock log=[], &block
+        @log   = log
+        @block = block
+
+        class << self
+          attr_accessor :log
+          attr_accessor :block
+
+          def exec ( aCommand, aData )
+            @block[aCommand, aData]
+          end
+
+          def display_command ( m )
+            @log << m
+          end
+        end # class << self
+
+        self
+      end
+
+    end # module Mockable
+
+    Runner.include Mockable
+
+    test_section __FILE__ do
+
+      class MockTest < Test::Unit::TestCase
+
+        def setup
+          assert_nothing_raised { @runner = System.new.make_mock }
+        end
+
+        def test_0_initialize
+        end
+
+        def test_simple
+          assert_nothing_raised do
+            @cmd = 'foo bar baz'.to_ocmd
+            @data = @runner.run(@cmd)
+          end
+          assert_kind_of(Datas::Data, @data)
+          assert_equal([@cmd], @runner.log)
+        end
+
+      end # class SystemTest
+
+    end
+
+  end # module Runners
+
+end # module ObjectiveCommand

data/lib/objective_command/runners/no_run.rb

@@ -0,0 +1,44 @@
+# 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/runners/no_run.rb 23187 2006-03-31T21:59:37.612710Z ertai  $
+
+module ObjectiveCommand
+
+  module Runners
+
+    # This very particular runner returns it's command instead of running it.
+    class NoRun < Runner
+      make Concrete
+
+      def run ( aCommand )
+        aCommand
+      end
+
+    end # class NoRun
+
+
+
+    test_section __FILE__ do
+
+      class NoRunTest < Test::Unit::TestCase
+
+        def setup
+          assert_nothing_raised { @runner = NoRun.new }
+        end
+
+        def test_0_initialize
+        end
+
+        def test_simple
+          cmd = 'sleep'.to_ocmd[10]
+          assert_kind_of Commands::Command, cmd.run(@runner)
+        end
+
+      end # class NoRunTest
+
+    end
+
+  end # module Runners
+
+end # module ObjectiveCommand

data/lib/objective_command/runners/popen.rb

@@ -0,0 +1,49 @@
+# 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/runners/popen.rb 23187 2006-03-31T21:59:37.612710Z ertai  $
+
+module ObjectiveCommand
+
+  module Runners
+
+    class Popen < Fork
+      make Concrete
+
+      def initialize ( *a, &b )
+        super
+        @command_data_factory.command_data_class = Datas::Pipe
+      end
+
+    end # class Popen
+
+
+
+    test_section __FILE__ do
+
+      class PopenTest < Test::Unit::TestCase
+
+        def setup
+          assert_nothing_raised { @runner = Popen.new }
+        end
+
+        def test_0_initialize
+        end
+
+        # FIXME
+        def test_simple
+          # TempPath.new do |tmp|
+            # cmd = %Q[ruby -e "sleep 0.5
+                              # File.open('#{tmp}', 'w') { |f| f.puts :foo }"]
+            # @runner.run(cmd.to_ocmd)
+            # assert(tmp.exist?)
+          # end
+        end
+
+      end # class PopenTest
+
+    end
+
+  end # module Runners
+
+end # module ObjectiveCommand

data/lib/objective_command/runners/runner.rb

@@ -0,0 +1,227 @@
+# 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/runners/runner.rb 29674 2006-09-12T21:05:16.387536Z ertai  $
+
+module ObjectiveCommand
+
+  module Runners
+
+    class Runner
+
+      include Abstract
+      include Hookable
+      include Hooker
+
+
+      #
+      # Accessors
+      #
+
+      attr_accessor :command_data_factory
+
+
+      #
+      # Hooks declaration
+      #
+
+      hook_declare :display_command
+      hook_declare :data
+      hook_declare :fork
+      hook_declare :son
+      hook_declare :before_open
+      hook_declare :before_chdir
+      hook_declare :before_exec
+      hook_declare :exec
+      hook_declare :exception_raised_during_exec
+      hook_declare :waitpid
+      hook_declare :failure
+      hook_declare :abort
+      hook_declare :already_killed
+      hook_declare :kill
+      hook_declare :before_return
+
+
+      #
+      # Construction methods.
+      #
+
+      def initialize *opts
+        @command_data_factory = Datas::Factory.new
+        @open_mode = :w
+        hooker_subscribe self
+        apply_options(*opts)
+      end
+
+
+      def initialize_copy ( copy )
+        super
+        if defined? @hookers
+          @hookers = @hookers.dup
+        else
+          @hookers = []
+        end
+      end
+
+
+      #
+      # Methods.
+      #
+
+      def run ( aCommand )
+        unless aCommand.is_a? Commands::Command
+          raise ArgumentError, "Need a OCmd::Commands::Command not #{aCommand}"
+        end
+
+        hook_trigger :display_command, aCommand
+
+        data = @command_data_factory.create
+        begin
+          data.open_mode = @open_mode
+          data.input = aCommand.input unless aCommand.input.nil?
+          data.output = aCommand.output unless aCommand.output.nil?
+          data.error = aCommand.error unless aCommand.error.nil?
+          hook_trigger :data, aCommand, data
+
+          hook_trigger :fork, data do
+            begin
+              hook_trigger :son, aCommand, data
+              hook_trigger :before_open, data
+              aCommand = aCommand.instanciate_args
+              STDIN.reopen(data.input.to_io_for_ocmd) unless data.input.nil?
+              STDOUT.reopen(data.output.to_io_for_ocmd) unless data.output.nil?
+              STDERR.reopen(data.error.to_io_for_ocmd) unless data.error.nil?
+              STDOUT.flush
+              STDERR.flush
+
+              hook_trigger :before_chdir, data
+              Dir.chdir(aCommand.dir) unless aCommand.dir.nil?
+
+              hook_trigger :before_exec, aCommand, data
+              hook_trigger :exec, aCommand, data
+            rescue Exception => ex
+              hook_trigger :exception_raised_during_exec, ex
+            end
+          end
+
+          hook_trigger :waitpid, data
+          if data.status.nil? or not data.status.success?
+            hook_trigger :failure, aCommand, data
+          end
+
+          hook_trigger :before_return, aCommand, data
+        rescue Exception => ex
+          hook_trigger :abort, data
+          raise ex
+        end
+        data
+      end
+
+
+      def make_verbose
+        hooker_subscribe VerboseHooker.new
+        self
+      end
+
+
+      def make_debug
+        hooker_subscribe DebugHooker.new
+        self
+      end
+
+
+      def raise_on_failures
+        hooker_subscribe FailureHooker.new
+        self
+      end
+
+
+      @@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 apply_options ( *options )
+        options.flatten.each do |k|
+          option = @@running_options[k]
+          if option.nil?
+            raise ArgumentError, "Bad runner option: #{k}"
+          else
+            send option
+          end
+        end
+        self
+      end
+
+      def fork data, &block
+        block.call
+      end
+
+      #
+      # Hookers
+      #
+
+      class DebugHooker
+        include Hooker
+
+        def log ( m, *a )
+          STDERR.puts
+          STDERR.puts "#{m}: #{a.inspect}"
+        end
+
+        hook_default_method :log
+
+      end # class DebugHooker
+
+
+      class VerboseHooker
+        include Hooker
+
+        def display_command ( m )
+          STDERR.puts "Running: #{m.to_a.join(' ')}"
+        end
+
+      end # class VerboseHooker
+
+
+      class FailureHooker
+        include Hooker
+
+        class Error < Exception
+        end
+
+        def failure ( aCommand, data )
+          raise Error, { 'reason'  => 'Command failed',
+                         'command' => aCommand.to_s,
+                         'data'    => data }.to_yaml
+        end
+
+      end # class FailureHooker
+
+
+    end # class Runner
+
+
+    test_section __FILE__ do
+
+      class RunnerTest < Test::Unit::TestCase
+
+        def test_abstract
+          if defined? RubyEx
+            assert_raise(TypeError) { Runner.new }
+          end
+        end
+
+      end # class RunnerTest
+    end
+
+  end # module Runners
+
+end # module ObjectiveCommand

data/lib/objective_command/runners/system.rb

@@ -0,0 +1,54 @@
+# 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/runners/system.rb 23187 2006-03-31T21:59:37.612710Z ertai  $
+
+module ObjectiveCommand
+
+  module Runners
+
+    class WaitpidHooker
+      include Hooker
+
+      def waitpid ( data )
+        data.waitpid
+      end
+    end
+
+
+    # This version wait to reach the end of the command before returns.
+    class System < Fork
+      make Concrete
+
+      hooker_subscribe WaitpidHooker.new
+
+    end # class System
+
+
+    test_section __FILE__ do
+
+      class SystemTest < Test::Unit::TestCase
+
+        def setup
+          assert_nothing_raised { @runner = System.new }
+        end
+
+        def test_0_initialize
+        end
+
+        def test_simple
+          TempPath.new do |tmp|
+            cmd = %Q[ruby -e "sleep 0.5
+                              File.open('#{tmp}', 'w') { |f| f.puts :foo }"]
+            @runner.run(cmd.to_ocmd)
+            assert(tmp.exist?)
+          end
+        end
+
+      end # class SystemTest
+
+    end
+
+  end # module Runners
+
+end # module ObjectiveCommand

data/lib/objective_command/runners.rb

@@ -0,0 +1,11 @@
+# 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/runners.rb 22684 2006-03-12T16:36:11.301558Z pouillar  $
+
+module ObjectiveCommand
+
+  module Runners
+  end # module Runners
+
+end # module ObjectiveCommand

data/lib/objective_command/shell.rb

@@ -0,0 +1,173 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2006 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id$
+
+module ObjectiveCommand
+
+  module Shell
+
+    module MethodMissing
+
+      setup do
+        cattr_accessor :runner unless respond_to? :runner
+        cattr_accessor :shell_options unless respond_to? :shell_options
+      end
+
+      def method_missing meth, *args, &block
+        super if block
+        meth = meth.to_s
+        if meth =~ /^(.*)!$/
+          raise 'No runner' unless respond_to? :runner or runner.nil?
+          Object.send(:remove_const, :Commands) if defined? ::Commands
+          Commands::Command.new($1, *args).run(runner)
+        else
+          cmd = Commands::Command.new(meth, *args)
+          cmd.freeze if shell_options and shell_options[:frozen]
+          cmd
+        end
+      end
+
+    end # module MethodMissing
+
+    class Simple
+
+      include Shell::MethodMissing
+      attr_accessor :runner, :shell_options
+
+      def initialize runner=nil, options=nil, &block
+        @runner = runner || OCmd::Runners::System.new
+        @shell_options = options || {}
+        other_opts = @shell_options.keys - [:frozen]
+        @runner.apply_options other_opts
+        block.bind(self).call if block
+      end
+
+    end # class Simple
+
+    module Attribute
+
+      setup do |*args|
+        runner, options = args
+        mattr_accessor :ocmd_shell
+        self.ocmd_shell = Shell::Simple.new runner, options
+      end
+
+      def shell *args, &block
+        local_shell = ocmd_shell
+        unless args.empty?
+          runner = ocmd_shell.runner
+          options = {}
+          for arg in args.flatten do
+            case arg
+              when OCmd::Runners::Runner then runner = arg
+              when Hash then options.merge! arg
+              when Symbol then options[arg] = true
+              else raise ArgumentError, "Bad argument: #{arg}"
+            end
+          end
+          local_shell = Shell::Simple.new runner, options
+        end
+        if block
+          block.bind(local_shell).call
+        else
+          local_shell
+        end
+      end
+
+      def shell! *args, &block
+        raise ArgumentError, 'Block needed' if block.nil?
+        local_shell = shell(*args)
+        block.bind(local_shell).call.run local_shell.runner 
+      end
+
+    end # module Attribute
+
+  end # module Shell
+
+
+  have Shell::Attribute
+  module_function :shell, :shell!
+
+
+  test_section __FILE__ do
+      OCmd::Runners::Mockable.import!
+
+      class ShellTest < Test::Unit::TestCase
+
+        class Foo
+          include OCmd::Shell::MethodMissing
+          def bar
+            cat
+          end
+        end
+        class Bar < Foo
+          attr_accessor :runner
+          def initialize runner
+            @runner = runner
+          end
+          def bar!
+            cat!
+          end
+        end
+        attr_reader :file1, :file2
+
+        def setup
+          @file1 = TempPath.new('file1').overwrite('contents1')
+          @file2 = TempPath.new('file2').overwrite('contents2')
+          @runner = OCmd::Runners::System.new.make_mock()
+        end
+
+        def assert_shell_cmd! ref, &block
+          my = block[]
+          assert_kind_of Datas::Data, my
+          assert_equal 1, @runner.log.size, 'bad runner log size'
+          assert_equal ref, @runner.log.first.to_a
+          @runner.log.shift
+        end
+
+        def test_simple_shell
+          ref = ['cat', file1.to_s, file2.to_s]
+          my = OCmd.shell.cat file1, file2
+          assert_equal ref, my.to_a
+        end
+
+        def test_simple_shell_env
+          ref = ['cat', file1.to_s, file2.to_s]
+          OCmd.shell do
+            my = cat file1, file2
+            assert_equal ref, my.to_a
+          end
+        end
+
+        def test_simple_shell_included
+          assert_equal ['cat'], Foo.new.bar.to_a
+        end
+
+        def test_with_run
+          ref = ['cat', file1.to_s, file2.to_s]
+          assert_shell_cmd!(ref) { OCmd.shell(@runner).cat! file1, file2 }
+          t = self
+          assert_shell_cmd!(ref) {OCmd.shell(@runner) { cat! t.file1, t.file2 }}
+          assert_shell_cmd!(['cat']) { Bar.new(@runner).bar! }
+        end
+
+        def test_with_run2
+          ref = ['cat', file1.to_s, file2.to_s]
+          t = self
+          assert_shell_cmd!(ref) {OCmd.shell!(@runner) { cat t.file1, t.file2 }}
+        end
+
+        def test_frozen_shell
+          ref = ['cat', file1.to_s, file2.to_s]
+          t = self
+          opts = [@runner, { :frozen => true }]
+          assert_shell_cmd!(ref) { OCmd.shell!(opts) { cat t.file1, t.file2 } }
+          assert_raise(TypeError) { OCmd.shell!(opts) { cat << 'foo' } }
+        end
+
+      end # class ShellTest
+
+  end
+
+end # module ObjectiveCommand

data/lib/objective_command/version_id.rb

@@ -0,0 +1,10 @@
+# Copyright:: Copyright (c) 2006  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <nicolas.pouillard@gmail.com>.
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/cmd/trunk/lib/objective_command/version_id.rb 53907 2007-01-13T18:40:33.521685Z ertai  $
+
+module ObjectiveCommand
+
+  VersionId = Version.parse("dev-ruby/objective_command-0.1")
+
+end # module ObjectiveCommand

data/lib/objective_command.rb

@@ -0,0 +1,54 @@
+# 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.rb 53907 2007-01-13T18:40:33.521685Z ertai  $
+
+require 'pathname'
+
+lib = Pathname.new(__FILE__).dirname
+vendor = lib.parent + 'vendor'
+unless defined? CoreEx
+  $CORE_EX_VENDORS ||= []
+  $CORE_EX_VENDORS << vendor
+  file = vendor + 'core_ex' + 'lib' + 'core_ex'
+  if file.exist?
+    require file.to_s
+  else
+    require 'rubygems' unless ENV['NO_GEM']
+    require_gem 'core_ex'
+    require 'core_ex'
+  end
+end
+lib.load_path!
+
+unless defined? RubyEx
+  module Abstract
+  end
+  module Concrete
+  end
+end
+
+# Provides an object oriented way to manage, combine and run your commands.
+#
+# Example:
+#   require 'rubygems' ; require_gem 'objective_command' ; require 'objective_command'
+#   ls, wc, out = 'ls'.to_ocmd, 'wc'.to_ocmd, '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 ObjectiveCommand
+end # module ObjectiveCommand
+
+OCmd = ObjectiveCommand unless defined? OCmd and OCmd == ObjectiveCommand
+Hooker.import!
+OCmd::Helpers.import!
+

data/test/check-objective_command.yml

@@ -0,0 +1,10 @@
+---
+
+ObjectiveCommand Main Test Suite: !S::Iterate
+
+  over: !pathlist <<pwd>>/(*-suite.yml)
+  iter: [it_file, it_name]
+
+  test:
+    <<it_name>>: !S::Import
+      import: <<it_file>>