dotanuki 0.0.1 → 0.0.2

data/.autotest

@@ -0,0 +1,2 @@
+require 'autotest/bundler'
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+

data/Rakefile

@@ -1,4 +1,14 @@
 require 'bundler'
-Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
 require 'metric_fu'
 
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--color"
+end
+
+desc "run autotest"
+task :autotest do
+  system "autotest"
+end

data/lib/dotanuki.rb

@@ -12,51 +12,80 @@ module Dotanuki
   # class for the result of an execution of one or more commands
   class ExecResult
     attr_reader :stdout, :stderr, :status, :failed_index
-    def initialize(out, err, status, failed_index=nil)
-      @stdout = out
-      @stderr = err
-      @status = status
-      @failed_index = failed_index
+    def initialize
+      @stdout = []
+      @stderr = []
+      @status = 0
+      @failed_index = nil
     end
 
+    # Returns true if the command has failed
     def failed?
       status != 0
     end
 
+    # Returns stderr for the command that failed
     def fail_message
       stderr[@failed_index]
     end
+
+    def add(stdout, stderr, status)
+      @stdout << stdout
+      @stderr << stderr
+      @status = status
+      if status.nil? || status != 0
+        @failed_index = @stdout.size - 1
+      end
+    end
+
+    def <<(result)
+      raise ArgumentError unless result.is_a?(ExecResult)
+      add(result.stdout, result.stderr, result.status)
+    end
+  end
+
+  # Execute commands in a block and return an array of ExecResult
+  #
+  # @example
+  #   guard do
+  #     execute "uname -a"
+  #     execute "ls /does/not/exist"
+  #   end
+  #
+  # TODO this is not thread safe
+  def guard(options={}, &block)
+    @guard = ExecResult.new
+    yield
+    clear_guard
+  rescue ExecError => e
+    puts "guard on duty"
+    clear_guard
   end
 
   # commands can be a string or an array of strings
   def execute(commands, options={})
     validate_options(options)
 
-    stdout = []
-    stderr = []
-    exit_status = 0
-    failed = nil
-    index = 0
+    result = ExecResult.new
 
     [commands].flatten.each do |command|
-      out, err, ex = _execute(command, options)
-      stdout << out
-      stderr << err
-      exit_status = ex
-      if options[:on_error] == :exception
+      stdout, stderr, exit_status = _execute(command, options)
+      result.add(stdout, stderr, exit_status)
+      if options[:on_error] == :exception || @guard
         if exit_status.nil?
+          @guard << result if @guard
           raise ExecError, "#{command}: command not found"
         elsif exit_status != 0
-          raise ExecError, stderr[index]
+          @guard << result if @guard
+          raise ExecError, stderr
         end
       elsif exit_status.nil? || exit_status != 0
-        failed = index
         break
       end
-      index += 1
     end
+    @guard << result if @guard
 
-    return ExecResult.new(stdout, stderr, exit_status, failed)
+    return result
   end
 
   def _execute(command, options={})
@@ -74,9 +103,17 @@ module Dotanuki
   def validate_options(options)
     options.each do |option, value|
       if option == :on_error && value != :exception
-        raise ArgumentError, "illegal value for option #{option}: #{value}" 
+        raise ArgumentError, "illegal value for option #{option}: #{value}"
       end
       raise ArgumentError, "illegal option: #{option}" if option != :on_error
     end
   end
+
+  private
+
+  def clear_guard
+    result = @guard
+    @guard = nil
+    result
+  end
 end

data/lib/dotanuki/version.rb

@@ -1,3 +1,3 @@
 module Dotanuki
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/dotanuki_spec.rb

@@ -1,14 +1,7 @@
 require 'spec_helper'
 
 describe Dotanuki do
-
-  class C
-    include Dotanuki
-  end
-  
-  before :all do
-    @c = C.new
-  end
+  include Dotanuki
 
   NON_EXISTING_PATH = "/not/an/existing/program"
   COMMAND_NOT_FOUND = NON_EXISTING_PATH
@@ -17,101 +10,118 @@ describe Dotanuki do
   EXISTING_PATH = "/"
   EXISTING_COMMAND = "ls -d #{EXISTING_PATH}"
 
+  describe "guard" do
+    it "should collect all output" do
+      guard do
+        execute("id")
+        execute("ls")
+      end.stdout.size.should == 2
+    end
+
+    it "should stop when one item fails" do
+      guard do
+        execute("id")
+        execute("ls /asd")
+        execute("uname -n")
+      end.failed_index.should == 1
+    end
+  end
+
   describe "execute" do
-    
+
     describe "missing command" do
       it "should stop on first" do
-        r = @c.execute([COMMAND_NOT_FOUND, EXISTING_COMMAND])
+        r = execute([COMMAND_NOT_FOUND, EXISTING_COMMAND])
         r.failed_index.should == 0
       end
 
       it "should stop on last" do
-        r = @c.execute([EXISTING_COMMAND, COMMAND_NOT_FOUND])
+        r = execute([EXISTING_COMMAND, COMMAND_NOT_FOUND])
         r.failed_index.should == 1
       end
 
       it "should return nil when not found" do
-        @c.execute([EXISTING_COMMAND, COMMAND_NOT_FOUND]).status.should be_nil
+        execute([EXISTING_COMMAND, COMMAND_NOT_FOUND]).status.should be_nil
       end
 
       it "should return nil when not found" do
-        @c.execute([COMMAND_NOT_FOUND, EXISTING_COMMAND]).status.should be_nil
+        execute([COMMAND_NOT_FOUND, EXISTING_COMMAND]).status.should be_nil
       end
     end
 
     describe "failing command" do
 
       it "should stop when the first fails" do
-        r = @c.execute([COMMAND_FAILED, "id", "id"])
+        r = execute([COMMAND_FAILED, "id", "id"])
         r.failed_index.should == 0
         r.status.should_not == 0
       end
 
       it "should stop on failure" do
-        r = @c.execute(["id", COMMAND_FAILED, "id"])
+        r = execute(["id", COMMAND_FAILED, "id"])
         r.failed_index.should == 1
         r.status.should_not == 0
       end
 
       it "should stop when the last fails" do
-        r = @c.execute(["id", "id", COMMAND_FAILED])
+        r = execute(["id", "id", COMMAND_FAILED])
         r.failed_index.should == 2
         r.status.should_not == 0
       end
 
       it "should not return 0" do
-        @c.execute(COMMAND_FAILED).status.should_not == 0
+        execute(COMMAND_FAILED).status.should_not == 0
       end
 
       it "should capture stderr" do
-        r = @c.execute(COMMAND_FAILED)
+        r = execute(COMMAND_FAILED)
         r.stderr[0].should == "ls: #{NON_EXISTING_PATH}: No such file or directory"
       end
 
     end
 
     it "should return 0 when the command succeeds" do
-      @c.execute("ls -d /").status.should == 0
+      execute("ls -d /").status.should == 0
     end
-  
+
     it "should execute all commands in an array" do
-      r = @c.execute(["id", "ls -d /", "id"])
+      r = execute(["id", "ls -d /", "id"])
       r.status.should == 0
       r.stdout.size.should == 3
       r.stderr.size.should == 3
     end
-  
+
     it "should execute a single command" do
-      r = @c.execute("echo 'bar'")
+      r = execute("echo 'bar'")
       r.status.should == 0
       r.stdout.should == ["bar"]
       r.stderr.should == [""]
     end
-  
+
     it "should execute a single command" do
-      @c._execute("echo 'foo'").should == ["foo", "", 0]
+      _execute("echo 'foo'").should == ["foo", "", 0]
     end
 
     describe "with exception option should throw an exception" do
       it "on missing command" do
-        lambda { @c.execute(COMMAND_NOT_FOUND, {:on_error => :exception}) }.should raise_error Dotanuki::ExecError, "#{NON_EXISTING_PATH}: command not found"
+        lambda { execute(COMMAND_NOT_FOUND, {:on_error => :exception}) }.should raise_error Dotanuki::ExecError, "#{NON_EXISTING_PATH}: command not found"
       end
 
       it "exception failing" do
-        lambda { @c.execute(COMMAND_FAILED, {:on_error => :exception}) }.should raise_error Dotanuki::ExecError, "ls: #{NON_EXISTING_PATH}: No such file or directory"
+        lambda { execute(COMMAND_FAILED, {:on_error => :exception}) }.should raise_error Dotanuki::ExecError, "ls: #{NON_EXISTING_PATH}: No such file or directory"
       end
     end
 
     it "should raise an error on invalid options" do
-      lambda { @c.execute(COMMAND_NOT_FOUND, {:on_error => :asd}) }.should raise_error ArgumentError
+      lambda { execute(COMMAND_NOT_FOUND, {:on_error => :asd}) }.should raise_error ArgumentError
     end
 
     it "should raise an error on invalid option argument" do
-      lambda { @c.execute(COMMAND_NOT_FOUND, {:asd => :asd}) }.should raise_error ArgumentError
+      lambda { execute(COMMAND_NOT_FOUND, {:asd => :asd}) }.should raise_error ArgumentError
     end
 
     it "should supply correct info on a failing command" do
-      r = @c.execute("ls /asd")
+      r = execute("ls /asd")
       r.failed?.should be_true
       r.fail_message.should_not be_empty
     end

metadata

@@ -2,7 +2,7 @@
 name: dotanuki
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Martin Englund
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-16 00:00:00 -07:00
+date: 2011-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,7 +34,9 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .autotest
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE
 - README.md