ruby_ex 0.4.6.2 → 0.5.5.0

data/lib/commands/runners/popen.rb

@@ -1,49 +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/runners/popen.rb 21865 2006-02-18T17:13:28.680350Z pouillar  $
-
-module Commands
-
-  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_cmd)
-            # assert(tmp.exist?)
-          # end
-        end
-
-      end # class PopenTest
-
-    end
-
-  end # module Runners
-
-end # module Commands

data/lib/commands/runners/runner.rb

@@ -1,177 +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/runners/runner.rb 21865 2006-02-18T17:13:28.680350Z pouillar  $
-
-module Commands
-
-  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 :before_open
-      hook_declare :before_chdir
-      hook_declare :before_exec
-      hook_declare :exec
-      hook_declare :failure
-
-
-      #
-      # Construction methods.
-      #
-
-      def initialize
-        @command_data_factory = Datas.const_get(:Factory).new # FIXME LazyLoading
-        @open_mode = :w
-        hooker_subscribe self
-      end
-
-
-      def initialize_copy ( copy )
-        super
-        if defined? @hookers
-          @hookers = @hookers.dup
-        else
-          @hookers = []
-        end
-      end
-
-
-      #
-      # Methods.
-      #
-
-      def run ( aCommand )
-        unless aCommand.is_a? Command
-          raise ArgumentError, "Need a #{Command}"
-        end
-
-        hook_trigger :display_command, aCommand
-
-        data = @command_data_factory.create
-        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
-
-        run_impl(aCommand, data)
-
-        data
-      end
-
-      def run_impl ( aCommand, data )
-        hook_trigger :before_open, data
-        aCommand = aCommand.instanciate_args
-        STDIN.reopen(data.input.to_io_for_commands) unless data.input.nil?
-        STDOUT.reopen(data.output.to_io_for_commands) unless data.output.nil?
-        STDERR.reopen(data.error.to_io_for_commands) 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
-      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
-
-
-      #
-      # 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
-
-
-    Commands::Helpers.import!
-
-
-    test_section __FILE__ do
-
-      class RunnerTest < Test::Unit::TestCase
-
-        def test_abstract
-          assert_raise(TypeError) { Runner.new }
-        end
-
-      end # class RunnerTest
-    end
-
-  end # module Runners
-
-end # module Commands

data/lib/commands/runners/system.rb

@@ -1,54 +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/runners/system.rb 8049 2005-12-31T16:01:12.162089Z ertai  $
-
-module Commands
-
-  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
-      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_cmd)
-            assert(tmp.exist?)
-          end
-        end
-
-      end # class SystemTest
-
-    end
-
-  end # module Runners
-
-end # module Commands

data/lib/commands/seq.rb

@@ -1,31 +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/seq.rb 21865 2006-02-18T17:13:28.680350Z pouillar  $
-
-module Commands
-
-  class Seq < Command
-
-    def initialize ( *cmds )
-      @cmds = cmds
-      @input, @output, @error = nil, nil, nil
-    end
-
-    def run ( *a )
-      datas = []
-      @cmds.each do |cmd|
-        datas.last.waitpid unless datas.empty?
-        datas << cmd.run(*a)
-      end
-      Datas::Composite.new(datas)
-    end
-
-    def to_sh
-      strs = @cmds.map { |cmd| "(#{cmd.to_sh})" }
-      "(#{strs.join(' ; ')})#{sh_args}"
-    end
-
-  end # class Seq
-
-end # module Commands

data/lib/hookable.rb

@@ -1,294 +0,0 @@
-# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# License::   Gnu General Public License.
-# Revision::  $Id: /w/fey/ruby_ex/trunk/lib/hookable.rb 8047 2005-12-31T15:56:23.983963Z ertai  $
-
-module Hookable
-
-  def self.included ( aClass )
-    super
-
-    aClass.module_eval do
-
-      def self.inheritable_attributes
-        if @inheritable_attributes.nil? or @inheritable_attributes.empty?
-          @inheritable_attributes = HashWithRecursiveCloneDup.new
-        end
-        @inheritable_attributes
-      end
-
-
-      class_inheritable_array :hooks
-      class_inheritable_array :hookers
-      inheritable_attributes[:hookers] = []
-      inheritable_attributes[:hooks] = []
-
-
-      def hook_trigger ( name, *args )
-        return if defined? @disabled_hooks and @disabled_hooks.include? name
-        return if defined? @@disabled_hooks and @@disabled_hooks.include? name
-        self.class.hook_trigger(name, *args)
-        return unless defined? @hookers
-        @hookers.each do |hooker|
-          @@hook_trigger_internal[hooker, name, *args]
-        end
-      end
-
-
-      def self.hook_trigger ( name, *args )
-        raise ArgumentError, "Unknown hook #{name}" unless hooks.include? name
-        return if defined? @@disabled_hooks and @@disabled_hooks.include? name
-        hookers.each do |hooker|
-          @@hook_trigger_internal[hooker, name, *args]
-        end
-      end
-
-
-      def self.hooker_subscribe ( hooker )
-        hookers << hooker
-      end
-
-
-      def hooker_subscribe ( hooker )
-        @hookers ||= []
-        @hookers << hooker
-      end
-
-
-      def self.subscribe_hook ( *hook_names, &block )
-        hooker_subscribe ProcHooker.new(*hook_names, &block)
-      end
-
-
-      def subscribe_hook ( *hook_names, &block )
-        hooker_subscribe ProcHooker.new(*hook_names, &block)
-      end
-
-
-      def disable_hook ( *hook_names )
-        @disabled_hooks ||= []
-        @disabled_hooks = @disabled_hooks + hook_names
-      end
-
-
-      def self.disable_hook ( *hook_names )
-        @@disabled_hooks ||= []
-        @@disabled_hooks = @@disabled_hooks + hook_names
-      end
-
-
-      def self.hook_declare ( name, *groups )
-        hooks << name
-      end
-
-
-      @@hook_trigger_internal = lambda do |hooker, name, *args|
-        if hooker.respond_to?(name)
-          hooker.send(name, *args)
-        else
-          if hooker.respond_to? :default_hook and not hooker.default_hook.nil?
-            hooker.send(hooker.default_hook, name, *args)
-          elsif hooker.respond_to?(:method_missing)
-            hooker.send(name, *args)
-          end
-        end
-      end
-
-    end
-
-  end
-
-
-  class ProcHooker < Proc
-    include Hooker
-    def initialize ( *hook_names, &block )
-      hook_method :call, *hook_names
-      super(&block)
-    end
-  end
-
-
-  class HashWithRecursiveCloneDup < Hash
-
-    def initialize_copy ( aHash )
-      aHash.each { |k, v| self[k] = v.dup }
-    end
-
-  end # class HashWithRecursiveCloneDup
-
-end # module Hookable
-
-
-
-test_section __FILE__ do
-
-  class HookableHookerTest < Test::Unit::TestCase
-
-    class HookerTest
-      include Hooker
-
-      attr_reader :stack
-
-      def log ( *args )
-        @stack ||= []
-        @stack << args
-      end
-
-      def method_missing ( *a )
-        log(:method_missing, *a)
-      end
-
-      def hook1 ( *a )
-        log(:hook1, *a)
-      end
-
-      def reset
-        @stack.clear if defined? @stack and @stack
-      end
-    end
-
-
-    STATIC_HOOKER_TEST = HookerTest.new
-
-
-    class HookableTest
-      include Hookable
-
-      hook_declare :hook1
-
-      hook_declare :hook2, :group1
-
-      def run
-        run1
-        run2
-      end
-
-      def run1
-        hook_trigger :hook1
-      end
-
-      def run2
-        hook_trigger :hook2, 42
-        suppress(ArgumentError) { hook_trigger :hook3 }
-      end
-
-      def << ( hooker )
-        hooker_subscribe hooker
-      end
-
-      hooker_subscribe STATIC_HOOKER_TEST
-
-      def self.ref
-        [
-          [[:hook1], [:method_missing, :hook2, 42]],
-          [[:hook1], [:default, :hook2, 42]],
-          [[:hook_1_and_2], [:hook_1_and_2, 42]],
-          [[:hook1], [:method_missing, :default_by_method_missing, :hook2, 42]],
-          [[:hook1], [:hook2, 42]],
-          [[:hook1], [:method_missing, :hook2_by_dynamic_hook_method, 42]]
-        ]
-      end
-
-    end
-
-
-
-    class SubHookableTest < HookableTest
-      hook_declare :hook3
-
-      def self.ref
-        [
-          [[:hook1], [:method_missing, :hook2, 42], [:method_missing, :hook3]],
-          [[:hook1], [:default, :hook2, 42], [:default, :hook3]],
-          [[:hook_1_and_2], [:hook_1_and_2, 42], [:method_missing, :hook3]],
-          [[:hook1], [:method_missing, :default_by_method_missing, :hook2, 42],
-                     [:method_missing, :default_by_method_missing, :hook3]],
-          [[:hook1], [:hook2, 42], [:default, :hook3]],
-          [[:hook1], [:method_missing, :hook2_by_dynamic_hook_method, 42],
-                     [:method_missing, :hook3]]
-        ]
-      end
-
-    end
-
-
-
-    class HookerTest1 < HookerTest
-      def default ( *a )
-        log(:default, *a)
-      end
-      hook_default_method :default
-    end
-
-
-
-    class HookerTest2 < HookerTest
-      def hook_1_and_2 ( *a )
-        log(:hook_1_and_2, *a)
-      end
-      hook_method :hook_1_and_2, :hook1, :hook2
-    end
-
-
-
-    class HookerTest3 < HookerTest
-      hook_default_method :default_by_method_missing
-    end
-
-
-
-    class HookerTest4 < HookerTest
-    end
-
-
-
-    class HookerTest21 < HookerTest1
-      def hook2 ( *a )
-        log(:hook2, *a)
-      end
-    end
-
-
-
-    def test_hookable
-      hookable_checker HookableTest.new
-    end
-
-
-
-    def test_sub_hookable
-      hookable_checker SubHookableTest.new
-    end
-
-
-
-    def hookable_checker ( support )
-      hookers = []
-      hookers << HookerTest1.new
-      hookers << HookerTest2.new
-      hookers << HookerTest3.new
-      hookers << HookerTest21.new
-      hooker4 = HookerTest4.new
-      hookers << hooker4
-      hookers.each do |hooker|
-        support << hooker
-      end
-      STATIC_HOOKER_TEST.reset
-      hookers.unshift STATIC_HOOKER_TEST
-      hooker4.hook_method(:hook2_by_dynamic_hook_method, :hook2)
-      @a = []
-      support.subscribe_hook(:hook2) do |*a|
-        assert_nothing_raised do
-          @a << [:proc_hooker_call, :hook2, *a]
-        end
-      end
-      support.run
-      hookers.zip(support.class.ref).each do |hooker, ref|
-        assert_equal(ref, hooker.stack)
-      end
-      assert_equal([[:proc_hooker_call, :hook2, 42]], @a)
-    end
-
-  end
-
-end