aruba 0.11.0.pre → 0.11.0.pre2

data/features/getting_started/supported_programming_languages.feature

@@ -1,89 +0,0 @@
-Feature: Supported programming languages
-
-  As long as you've got the neccessary programs, libraries, runtime
-  environments, interpreters installed, it doesn't matter in which programming
-  language your commandline application is implemented. 
-
-  Below you find some examples of the "Hello, Aruba!"-application implemented
-  with different programming languages. This is NOT an exclusive list. Every
-  commandline application should run with `aruba`.
-
-  Background:
-    Given I use a fixture named "getting-started-app"
-    And a file named "features/hello_aruba.feature" with:
-    """
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given I successfully run `cli`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-
-  Scenario: Bash Program
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo "Hello, Aruba!"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  Scenario: Ruby Program
-    Given an executable named "bin/cli" with:
-    """ruby
-    #!/usr/bin/env ruby
-
-    puts "Hello, Aruba!"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  Scenario: Python Program
-    Given an executable named "bin/cli" with:
-    """python
-    #!/usr/bin/env python
-
-    print("Hello, Aruba!")
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  Scenario: Perl Program
-    Given an executable named "bin/cli" with:
-    """perl
-    #!/usr/bin/env perl
-
-    print "Hello, Aruba!\n";
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass
-
-  Scenario: Java Program
-
-    It's even possible to compile and run Java programs with Aruba.
-
-    Given a file named "features/hello_aruba.feature" with:
-    """cucumber
-    Feature: Getting Started With Aruba
-      Scenario: First Run of Command
-        Given a file named "tmp/HelloArubaApp.java" with:
-        \"\"\"
-        class HelloArubaApp {
-          public static void main(String[] args) {
-            System.out.println("Hello, Aruba!");
-          }
-        }
-        \"\"\"
-        And I successfully run `javac tmp/HelloArubaApp.java`
-        And I cd to "tmp/"
-        And I successfully run `java HelloArubaApp`
-        Then the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I successfully run `cucumber`
-    Then the features should all pass

data/lib/aruba/announcer.rb

@@ -1,219 +0,0 @@
-require 'shellwords'
-
-module Aruba
-  # Announcer
-  #
-  # @example Activate your you own channel in cucumber
-  #
-  #   Before('@announce-my-channel') do
-  #     announcer.activate :my_channel
-  #   end
-  #
-  # @example Activate your you own channel in rspec > 3
-  #
-  #   before do
-  #     current_example = context.example
-  #     announcer.activate :my_channel if current_example.metadata[:announce_my_channel]
-  #   end
-  #
-  #   Aruba.announcer.announce(:my_channel, 'my message')
-  #
-  class Announcer
-    # Dev null
-    class NullAnnouncer
-      def announce(*)
-        nil
-      end
-
-      def mode?(*)
-        true
-      end
-    end
-
-    # Announcer using Kernel.puts
-    class KernelPutsAnnouncer
-      def announce(message)
-        Kernel.puts message
-      end
-
-      def mode?(m)
-        :kernel_puts == m
-      end
-    end
-
-    # Announcer using Main#puts
-    class PutsAnnouncer
-      def announce(message)
-        Kernel.puts message
-      end
-
-      def mode?(m)
-        :puts == m
-      end
-    end
-
-    private
-
-    attr_reader :announcers, :default_announcer, :announcer, :channels, :output_formats
-
-    public
-
-    def initialize(_, options)
-      @announcers = []
-      @announcers << PutsAnnouncer.new
-      @announcers << KernelPutsAnnouncer.new
-      @announcers << NullAnnouncer.new
-
-      @default_announcer = @announcers.last
-      @announcer         = @announcers.first
-      @channels          = {}
-      @output_formats    = {}
-
-      @options           = options
-
-      after_init
-    end
-
-    private
-
-    # rubocop:disable Metrics/MethodLength
-    def after_init
-      output_format :directory, '$ cd %s'
-      output_format :command, '$ %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 :wait_time, '# %s: %s seconds'
-      output_format :stop_signal, proc { |p, s| format('Command will be stopped with `kill -%s %s`', s, p) }
-      output_format :stderr, "<<-STDERR\n%s\nSTDERR"
-      output_format :stdout, "<<-STDOUT\n%s\nSTDOUT"
-
-      # rubocop:disable Metrics/LineLength
-      if @options[:stdout]
-        warn('The use of "@announce_stdout-instance" variable and "options[:stdout] = true" for Announcer.new is deprecated. Please use "announcer.activate(:stdout)" instead.')
-        activate :stdout
-      end
-      if @options[:stderr]
-        warn('The use of "@announce_stderr-instance" variable and "options[:stderr] = true" for Announcer.new is deprecated. Please use "announcer.activate(:stderr)" instead.')
-        activate :stderr
-      end
-      if @options[:dir]
-        warn('The use of "@announce_dir-instance" variable and "options[:dir] = true" for Announcer.new is deprecated. Please use "announcer.activate(:directory)" instead.')
-        activate :directory
-      end
-      if @options[:cmd]
-        warn('The use of "@announce_cmd-instance" variable and "options[:cmd] = true" for Announcer.new is deprecated. Please use "announcer.activate(:command)" instead.')
-        activate :command
-      end
-      if @options[:env]
-        warn('The use of "@announce_env-instance" variable and "options[:env] = true" for Announcer.new is deprecated. Please use "announcer.activate(:modified_environment)" instead.')
-        activate :modified_enviroment
-      end
-      # rubocop:enable Metrics/LineLength
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def output_format(channel, string = '%s', &block)
-      if block_given?
-        output_formats[channel.to_sym] = block
-      elsif  string.is_a?(Proc)
-        output_formats[channel.to_sym] = string
-      else
-        output_formats[channel.to_sym] = proc { |*args| format(string, *args) }
-      end
-
-      self
-    end
-
-    public
-
-    # Reset announcer
-    def reset
-      @default_announcer = @announcers.last
-      @announcer         = @announcers.first
-    end
-
-    # Change mode of announcer
-    #
-    # @param [Symbol] m
-    #   The mode to set
-    def mode=(m)
-      @announcer = @announcers.find { |a| f.mode? m.to_sym }
-
-      self
-    end
-
-    # Check if channel is activated
-    #
-    # @param [Symbol] channel
-    #   The name of the channel to check
-    def activated?(channel)
-      channels[channel.to_sym] == true
-    end
-
-    # Activate a channel
-    #
-    # @param [Symbol] channel
-    #   The name of the channel to activate
-    def activate(channel)
-      channels[channel.to_sym] = true
-
-      self
-    end
-
-    # Announce information to channel
-    #
-    # @param [Symbol] channel
-    #   The name of the channel to check
-    #
-    # @param [Array] args
-    #   Arguments
-    def announce(channel, *args)
-      channel = channel.to_sym
-
-      the_output_format = if output_formats.key? channel
-                            output_formats[channel]
-                          else
-                            proc { |v| format('%s', v) }
-                          end
-
-      message = the_output_format.call(*args)
-
-      announcer.announce(message) if channels[channel]
-
-      default_announcer.announce message
-    end
-
-    # @deprecated
-    def stdout(content)
-      warn('The announcer now has a new api to activate channels. Please use this one: announce(:stdout, message)')
-      announce :stdout, content
-    end
-
-    # @deprecated
-    def stderr(content)
-      warn('The announcer now has a new api to activate channels. Please use this one: announce(:stderr, message)')
-      announce :stderr, content
-    end
-
-    # @deprecated
-    def dir(dir)
-      warn('The announcer now has a new api to activate channels. Please use this one announce(:directory, message)')
-      announce :directory, dir
-    end
-
-    # @deprecated
-    def cmd(cmd)
-      warn('The announcer now has a new api to activate channels. Please use this one announce(:command, message)')
-      announce :command, cmd
-    end
-
-    # @deprecated
-    def env(key, value)
-      warn('The announcer now has a new api to activate channels. Please use this one: announce(:modified_environment, key, value)')
-
-      announce :modified_environment, key, value
-    end
-  end
-end

data/lib/aruba/process_monitor.rb

@@ -1,201 +0,0 @@
-require 'aruba/processes/null_process'
-
-module Aruba
-  class ProcessMonitor
-    private
-
-    attr_reader :processes, :announcer
-
-    public
-
-    def initialize(announcer)
-      @processes = []
-      @announcer = announcer
-    end
-
-    def last_exit_status
-      Aruba.platform.deprecated('The use of "#last_exit_status" is deprecated. Use "last_command_(started|stopped).exit_status" instead')
-
-      return @last_exit_status if @last_exit_status
-      all_commands.each { |c| stop_process(c) }
-      @last_exit_status
-    end
-
-    def last_command_stopped
-      return @last_command_stopped if @last_command_stopped
-      return Command.new('false',
-                         :mode              => :null,
-                         :exit_timeout      => 0,
-                         :io_wait_timeout   => 0,
-                         :working_directory => '/tmp',
-                         :environment       => {},
-                         :main_class        => nil,
-                         :stop_signal       => nil,
-                         :startup_wait_time => nil
-                        ) if all_commands.empty?
-
-      all_commands.each { |c| stop_process(c) }
-
-      @last_command_stopped
-    end
-
-    def last_command_started
-      return Command.new('false',
-                         :mode              => :null,
-                         :exit_timeout      => 0,
-                         :io_wait_timeout   => 0,
-                         :working_directory => '/tmp',
-                         :environment       => {},
-                         :main_class        => nil,
-                         :stop_signal       => nil,
-                         :startup_wait_time => nil
-                        ) unless processes.last.is_a? Array
-
-      processes.last[1]
-    end
-
-    def stop_process(process)
-      @last_command_stopped = process
-      @last_exit_status     = process.stop(announcer)
-    end
-
-    def terminate_process!(process)
-      @last_command_stopped = process
-      @last_exit_status     = process.terminate
-    end
-
-    def stop_processes!
-      Aruba.platform.deprecated('The use of "#stop_processes!" is deprecated. Use "#stop_all_commands" instead')
-
-      stop_all_commands
-    end
-
-    def stop_all_commands
-      all_commands.each { |c| c.stop(announcer) }
-    end
-
-    # Terminate all running processes
-    def terminate_processes
-      Aruba.platform.deprecated('The use of "#terminate_processes" is deprecated. Use "#all_commands.each(&:terminate)" instead')
-
-      processes.each do |_, process|
-        terminate_process(process)
-        stop_process(process)
-      end
-    end
-
-    def register_process(name, process)
-      processes << [name, process]
-
-      [name, process]
-    end
-
-    def get_process(wanted)
-      matching_processes = processes.reverse.find{ |name, _| name == wanted }
-      raise ArgumentError.new("No process named '#{wanted}' has been started") unless matching_processes
-      matching_processes.last
-    end
-
-    def only_processes
-      Aruba.platform.deprecated('The use of "#only_processes" is deprecated. Use "#all_commands" instead')
-
-      processes.collect{ |_, process| process }
-    end
-
-    # Fetch output (stdout, stderr) from command
-    #
-    # @param [String] cmd
-    #   The command
-    def output_from(cmd)
-      cmd = Aruba.platform.detect_ruby(cmd)
-      get_process(cmd).output
-    end
-
-    # Fetch stdout from command
-    #
-    # @param [String] cmd
-    #   The command
-    def stdout_from(cmd)
-      cmd = Aruba.platform.detect_ruby(cmd)
-      get_process(cmd).stdout
-    end
-
-    # Fetch stderr from command
-    #
-    # @param [String] cmd
-    #   The command
-    def stderr_from(cmd)
-      cmd = Aruba.platform.detect_ruby(cmd)
-      get_process(cmd).stderr
-    end
-
-    # Get stdout of all processes
-    #
-    # @return [String]
-    #   The stdout of all process which have run before
-    def all_stdout
-      # rubocop:disable Metrics/LineLength
-      Aruba.platform.deprecated('The use of "#all_stdout" is deprecated. Use `all_commands.map { |c| c.stdout }.join("\n") instead. If you need to check for some output use "expect(all_commands).to have_output_on_stdout /output/" instead')
-      # rubocop:enable Metrics/LineLength
-
-      stop_all_commands
-
-      if RUBY_VERSION < '1.9'
-        out = ''
-        only_processes.each { |ps| out << ps.stdout }
-
-        out
-      else
-        only_processes.each_with_object("") { |ps, o| o << ps.stdout }
-      end
-    end
-
-    # Get stderr of all processes
-    #
-    # @return [String]
-    #   The stderr of all process which have run before
-    def all_stderr
-      # rubocop:disable Metrics/LineLength
-      Aruba.platform.deprecated('The use of "#all_stderr" is deprecated. Use `all_commands.map { |c| c.stderr }.join("\n") instead. If you need to check for some output use "expect(all_commands).to have_output_on_stderr /output/" instead')
-      # rubocop:enable Metrics/LineLength
-
-      stop_all_commands
-
-      if RUBY_VERSION < '1.9'
-        out = ''
-        only_processes.each { |ps| out << ps.stderr }
-
-        out
-      else
-        only_processes.each_with_object("") { |ps, o| o << ps.stderr }
-      end
-    end
-
-    # Get stderr and stdout of all processes
-    #
-    # @return [String]
-    #   The stderr and stdout of all process which have run before
-    def all_output
-      # rubocop:disable Metrics/LineLength
-      Aruba.platform.deprecated('The use of "#all_output" is deprecated. Use `all_commands.map { |c| c.output }.join("\n") instead. If you need to check for some output use "expect(all_commands).to have_output /output/" instead')
-      # rubocop:enable Metrics/LineLength
-
-      all_stdout << all_stderr
-    end
-
-    # Return all commands
-    #
-    # @return [Array]
-    #   A list of all commands
-    def all_commands
-      processes.collect { |_, process| process }
-    end
-
-    # Clear list of processes
-    def clear
-      processes.clear
-
-      self
-    end
-  end
-end