aruba 0.9.0.pre → 0.9.0.pre2

data/features/usage/install.feature

@@ -0,0 +1,8 @@
+Feature: Install aruba
+
+  Background:
+    Given the default aruba exit timeout is 60 seconds
+
+  Scenario: Using rubygems
+    Given I successfully run `gem install aruba`
+    Then aruba should be installed on the local system

data/fixtures/cli-app/lib/cli/app/suppress_simple_cov_output.rb

@@ -0,0 +1,15 @@
+module SimpleCov
+  module Formatter
+    class HTMLFormatter
+      def format(result)
+        Dir[File.join(File.dirname(__FILE__), "../public/*")].each do |path|
+          FileUtils.cp_r(path, asset_output_path)
+        end
+
+        File.open(File.join(output_path, "index.html"), "wb") do |file|
+          file.puts template("layout").result(binding)
+        end
+      end
+    end
+  end
+end

data/{features/fixtures/empty-app → fixtures/cli-app}/script/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "cli/app"
+require 'bundler/setup'
+require 'cli/app'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "cli/app"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/{features/fixtures/cli-app → fixtures/empty-app}/script/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "cli/app"
+require 'bundler/setup'
+require 'cli/app'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "cli/app"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/fixtures/getting-started-app/.gitignore

@@ -0,0 +1,4 @@
+/coverage/
+/doc/
+/pkg/
+/tmp/

data/fixtures/getting-started-app/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'cucumber'
+gem 'aruba'

data/fixtures/getting-started-app/README.md

@@ -0,0 +1,3 @@
+# Simple Cli App
+
+This is a simple app to get started with `aruba`.

data/fixtures/getting-started-app/features/support/env.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/lib/aruba/announcer.rb

@@ -1,3 +1,5 @@
+require 'shellwords'
+
 module Aruba
   # Announcer
   #
@@ -78,10 +80,12 @@ module Aruba
     def after_init
       output_format :directory, '$ cd %s'
       output_format :command, '$ %s'
-      output_format :environment, '$ export %s=%s"'
-      output_format :modified_environment, '$ export %s=%s"'
+      output_format :environment, proc { |n, v| format('$ export %s=%s', n, Shellwords.escape(v)) }
+      output_format :modified_environment, proc { |n, v| format('$ export %s=%s', n, Shellwords.escape(v)) }
       output_format :full_environment, proc { |h| Aruba.platform.simple_table(h) }
       output_format :timeout, '# %s-timeout: %s seconds'
+      output_format :stderr, "<<-STDERR\n%s\nSTDERR"
+      output_format :stdout, "<<-STDOUT\n%s\nSTDOUT"
 
       # rubocop:disable Metrics/LineLength
       if @options[:stdout]

data/lib/aruba/api.rb

@@ -26,21 +26,5 @@ module Aruba
     include Aruba::Api::Filesystem
     include Aruba::Api::Rvm
     include Aruba::Api::Deprecated
-
-    # Access to announcer
-    def announcer
-      @announcer ||= Announcer.new(
-        self,
-        :stdout => defined?(@announce_stdout),
-        :stderr => defined?(@announce_stderr),
-        :dir    => defined?(@announce_dir),
-        :cmd    => defined?(@announce_cmd),
-        :env    => defined?(@announce_env)
-      )
-
-      @announcer
-    end
-
-    module_function :announcer
   end
 end

data/lib/aruba/api/command.rb

@@ -63,205 +63,19 @@ module Aruba
         file_name = expand_path(file_name)
 
         File.open(file_name, 'r').each_line do |line|
-          last_command.write(line)
+          last_command_started.write(line)
         end
       end
 
-      # Fetch output (stdout, stderr) from command
+      # Return all commands
       #
-      # @param [String] cmd
-      #   The command
-      def output_from(cmd)
-        process_monitor.output_from(cmd)
-      end
-
-      # Fetch stdout from command
-      #
-      # @param [String] cmd
-      #   The command
-      def stdout_from(cmd)
-        process_monitor.stdout_from(cmd)
-      end
-
-      # Fetch stderr from command
-      #
-      # @param [String] cmd
-      #   The command
-      def stderr_from(cmd)
-        process_monitor.stderr_from(cmd)
-      end
-
-      # Get stdout of all processes
-      #
-      # @return [String]
-      #   The stdout of all process which have run before
-      def all_stdout
-        process_monitor.all_stdout
-      end
-
-      # Get stderr of all processes
-      #
-      # @return [String]
-      #   The stderr of all process which have run before
-      def all_stderr
-        process_monitor.all_stderr
-      end
-
-      # Get stderr and stdout of all processes
-      #
-      # @return [String]
-      #   The stderr and stdout of all process which have run before
-      def all_output
-        process_monitor.all_output
-      end
-
-      # Full compare arg1 and arg2
-      #
-      # @return [TrueClass, FalseClass]
-      #   If arg1 is exactly the same as arg2 return true, otherwise false
-      def assert_exact_output(expected, actual)
-        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
-
-        actual = unescape_text(actual)
-        actual = extract_text(actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expected = unescape_text(expected)
-        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expect(actual).to eq expected
-      end
-
-      # Partial compare arg1 and arg2
-      #
-      # @return [TrueClass, FalseClass]
-      #   If arg2 contains arg1 return true, otherwise false
-      def assert_partial_output(expected, actual)
-        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
-
-        actual = unescape_text(actual)
-        actual = extract_text(actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expected = unescape_text(expected)
-        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expect(actual).to include expected
-      end
-
-      # Regex Compare arg1 and arg2
-      #
-      # @return [TrueClass, FalseClass]
-      #   If arg2 matches arg1 return true, otherwise false
-      def assert_matching_output(expected, actual)
-        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
-
-        actual = unescape_text(actual)
-        actual = extract_text(actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expected = unescape_text(expected)
-        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expect(actual).to match Regexp.new(expected, Regexp::MULTILINE)
-      end
-
-      # Negative regex compare arg1 and arg2
-      #
-      # @return [TrueClass, FalseClass]
-      #   If arg2 does not match arg1 return true, otherwise false
-      def assert_not_matching_output(expected, actual)
-        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
-
-        actual = unescape_text(actual)
-        actual = extract_text(actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expected = unescape_text(expected)
-        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expect(actual).not_to match Regexp.new(expected, Regexp::MULTILINE)
-      end
-
-      # Negative partial compare arg1 and arg2
-      #
-      # @return [TrueClass, FalseClass]
-      #   If arg2 does not match/include arg1 return true, otherwise false
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def assert_no_partial_output(unexpected, actual)
-        actual.force_encoding(unexpected.encoding) if RUBY_VERSION >= "1.9"
-
-        actual = unescape_text(actual)
-        actual = extract_text(actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        if Regexp === unexpected
-          expect(actual).not_to match unexpected
-        else
-          unexpected = unescape_text(unexpected)
-          unexpected = extract_text(unexpected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-          expect(actual).not_to include(unexpected)
-        end
-      end
-      # rubocop:enable Metrics/CyclomaticComplexity
-
-      # Partial compare output of interactive command and arg1
-      #
-      # @return [TrueClass, FalseClass]
-      #   If output of interactive command includes arg1 return true, otherwise false
-      def assert_partial_output_interactive(expected)
-        actual = unescape_text(last_command.stdout)
-        actual = extract_text(actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        expected = unescape_text(expected)
-        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
-
-        actual.include?(expected) ? true : false
-      end
-
-      # Check if command succeeded and if arg1 is included in output
-      #
-      # @return [TrueClass, FalseClass]
-      #   If exit status is 0 and arg1 is included in output return true, otherwise false
-      def assert_passing_with(expected)
-        assert_success(true)
-        assert_partial_output(expected, all_output)
-      end
-
-      # Check if command failed and if arg1 is included in output
-      #
-      # @return [TrueClass, FalseClass]
-      #   If exit status is not equal 0 and arg1 is included in output return true, otherwise false
-      def assert_failing_with(expected)
-        assert_success(false)
-        assert_partial_output(expected, all_output)
-      end
-
-      # Check exit status of process
-      #
-      # @return [TrueClass, FalseClass]
-      #   If arg1 is true, return true if command was successful
-      #   If arg1 is false, return true if command failed
-      def assert_success(success)
-        if success
-          expect(last_command).to be_successfully_executed
-        else
-          expect(last_command).not_to be_successfully_executed
-        end
-      end
-
-      # @private
-      def assert_exit_status(status)
-        expect(last_command).to have_exit_status(status)
-      end
-
-      # @private
-      def assert_not_exit_status(status)
-        expect(last_exit_status).not_to eq(status),
-          append_output_to("Exit status was #{last_exit_status} which was not expected.")
+      # @return [Array]
+      #   List of commands
+      def all_commands
+        process_monitor.all_commands
       end
 
       # @private
-      def append_output_to(message)
-        "#{message} Output:\n\n#{all_output}\n"
-      end
-
       def process_monitor
         return @process_monitor if defined? @process_monitor
 
@@ -275,29 +89,48 @@ module Aruba
         process_monitor.send(:processes)
       end
 
-      # @private
-      def stop_processes!
-        process_monitor.stop_processes!
+      # Last command started
+      def last_command_started
+        process_monitor.last_command_started
       end
 
-      # Terminate all running processes
-      def terminate_processes!
-        process_monitor.terminate_processes!
+      # Last command stopped
+      def last_command_stopped
+        process_monitor.last_command_stopped
       end
 
-      # @private
-      def last_command
-        processes.last[1]
-      end
+      # Stop all commands
+      #
+      # @yield [Command]
+      #   If block is given use it to filter the commands which should be
+      #   stoppend.
+      def stop_all_commands(&block)
+        cmds = if block_given?
+                 all_commands.select(&block)
+               else
+                 all_commands
+               end
 
-      # @private
-      def register_process(*args)
-        process_monitor.register_process(*args)
+        cmds.each { |c| c.stop(announcer) }
+
+        self
       end
 
-      # @private
-      def get_process(wanted)
-        process_monitor.get_process(wanted)
+      # Terminate all commands
+      #
+      # @yield [Command]
+      #   If block is given use it to filter the commands which should be
+      #   terminated.
+      def terminate_all_commands(&block)
+        cmds = if block_given?
+                 all_commands.select(&block)
+               else
+                 all_commands
+               end
+
+        cmds.each(&:terminate)
+
+        self
       end
 
       # Run given command and stop it if timeout is reached
@@ -312,17 +145,18 @@ module Aruba
       #   Run block with process
       #
       # rubocop:disable Metrics/MethodLength
-      def run(cmd, timeout = nil)
-        timeout ||= exit_timeout
+      def run(cmd, exit_timeout = nil, io_wait_timeout = nil)
+        exit_timeout ||= aruba.config.exit_timeout
+        io_wait_timeout ||= aruba.config.io_wait_timeout
+
         @commands ||= []
         @commands << cmd
 
-        cmd = Aruba.platform.detect_ruby(cmd)
-
-        announcer.announce(:directory, Dir.pwd)
         announcer.announce(:command, cmd)
-        announcer.announce(:timeout, 'exit', aruba.config.exit_timeout)
-        announcer.announce(:full_environment, aruba.environment.to_h)
+
+        cmd               = Aruba.platform.detect_ruby(cmd)
+        environment       = aruba.environment.to_h
+        working_directory = expand_path('.')
 
         mode = if Aruba.process
                  # rubocop:disable Metrics/LineLength
@@ -341,13 +175,19 @@ module Aruba
                      else
                        aruba.config.main_class
                      end
+
+        announcer.announce(:directory, working_directory)
+        announcer.announce(:timeout, 'exit', exit_timeout)
+        announcer.announce(:timeout, 'io wait', io_wait_timeout)
+        announcer.announce(:full_environment, environment)
+
         command = Command.new(
           cmd,
           :mode              => mode,
-          :exit_timeout      => timeout,
-          :io_wait_timeout   => io_wait,
-          :working_directory => expand_path('.'),
-          :environment       => aruba.environment.to_h,
+          :exit_timeout      => exit_timeout,
+          :io_wait_timeout   => io_wait_timeout,
+          :working_directory => working_directory,
+          :environment       => environment,
           :main_class        => main_class
         )
 
@@ -361,7 +201,7 @@ module Aruba
         aruba.config.before(:command, self, command)
 
         process_monitor.register_process(cmd, command)
-        command.run!
+        command.start
 
         aruba.config.after(:command, self, command)
 
@@ -369,27 +209,6 @@ module Aruba
       end
       # rubocop:enable Metrics/MethodLength
 
-      # Default exit timeout for running commands with aruba
-      #
-      # Overwrite this method if you want a different timeout or set
-      # `@aruba_timeout_seconds`.
-      def exit_timeout
-        aruba.config.exit_timeout
-      end
-
-      # Default io wait timeout
-      #
-      # Overwrite this method if you want a different timeout or set
-      # `@aruba_io_wait_seconds
-      def io_wait
-        aruba.config.io_wait_timeout
-      end
-
-      # The root directory of aruba
-      def root_directory
-        aruba.config.root_directory
-      end
-
       # Run a command with aruba
       #
       # Checks for error during command execution and checks the output to detect
@@ -403,8 +222,8 @@ module Aruba
       #
       # @param [Integer] timeout
       #   Timeout for execution
-      def run_simple(cmd, fail_on_error = true, timeout = nil)
-        command = run(cmd, timeout)
+      def run_simple(cmd, fail_on_error = true, exit_timeout = nil, io_wait_timeout = nil)
+        command = run(cmd, exit_timeout, io_wait_timeout)
         @last_exit_status = process_monitor.stop_process(command)
 
         @timed_out = command.timed_out?
@@ -421,33 +240,12 @@ module Aruba
       #   The input for the command
       def type(input)
         return close_input if "" == input
-        last_command.write(input << "\n")
+        last_command_started.write(input << "\n")
       end
 
       # Close stdin
       def close_input
-        last_command.close_io(:stdin)
-      end
-
-      # Only processes
-      def only_processes
-        process_monitor.only_processes
-      end
-
-      # TODO: move some more methods under here!
-
-      private
-
-      def last_exit_status
-        process_monitor.last_exit_status
-      end
-
-      def stop_process(process)
-        @last_exit_status = process_monitor.stop_process(process)
-      end
-
-      def terminate_process(process)
-        process_monitor.terminate_process(process)
+        last_command_started.close_io(:stdin)
       end
     end
   end