aruba-win-fix 0.14.2

data/lib/aruba/matchers/path/match_path_pattern.rb

@@ -0,0 +1,41 @@
+# @!method match_path_pattern(pattern)
+#   This matchers checks if <files>/directories match <pattern>
+#
+#   @param [String, Regexp] pattern
+#     The pattern to use.
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if there are no files/directories which match the pattern
+#     true:
+#     * if there are files/directories which match the pattern
+#
+#   @example Use matcher with regex
+#
+#     RSpec.describe do
+#       it { expect(Dir.glob(**/*)).to match_file_pattern(/.txt$/) }
+#     end
+#
+#   @example Use matcher with string
+#
+#     RSpec.describe do
+#       it { expect(Dir.glob(**/*)).to match_file_pattern('.txt$') }
+#     end
+RSpec::Matchers.define :match_path_pattern do |_|
+  match do |actual|
+    Aruba.platform.deprecated('The use of `expect().to match_path_pattern` is deprecated. Please use `expect().to include pattern /regex/` instead.')
+
+    next !actual.select { |a| a == expected }.empty? if expected.is_a? String
+
+    !actual.grep(expected).empty?
+  end
+
+  failure_message do |actual|
+    format("expected that path \"%s\" matches pattern \"%s\".", actual.join(", "), expected)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that path \"%s\" does not match pattern \"%s\".", actual.join(", "), expected)
+  end
+end

data/lib/aruba/matchers/rspec_matcher_include_regexp.rb

@@ -0,0 +1,25 @@
+# @!method include_regexp(regexp)
+#   This matchers checks if items of an <array> matches regexp
+#
+#   @param [Regexp] regexp
+#     The regular expression to use
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if regexp does not match
+#     true:
+#     * if regexp matches
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(%w(asdf qwert)).to include_regexp(/asdf/) }
+#     end
+RSpec::Matchers.define :include_regexp do |expected|
+  match do |actual|
+    Aruba.platform.deprecated('The use of "include_regexp"-matchers is deprecated. It will be removed soon.')
+
+    !actual.grep(expected).empty?
+  end
+end

data/lib/aruba/matchers/string.rb

@@ -0,0 +1 @@
+Aruba.platform.require_matching_files('../string/**/*.rb', __FILE__)

data/lib/aruba/matchers/string/include_output_string.rb

@@ -0,0 +1,36 @@
+# @!method include_output_string(string)
+#   This matchers checks if the output string of a command includes string.
+#
+#   @param [Integer] status
+#     The value of the exit status
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if the output string does not include string
+#     true:
+#     * if the output string includes string
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output an_output_string_including string) }
+#       it { expect(last_command_started).to have_output include_output_string string) }
+#     end
+RSpec::Matchers.define :include_output_string do |expected|
+  match do |actual|
+    @expected = Regexp.new(Regexp.escape(sanitize_text(expected.to_s)), Regexp::MULTILINE)
+    @actual   = sanitize_text(actual)
+
+    values_match? @expected, @actual
+  end
+
+  diffable
+
+  description { "string includes: #{description_of expected}" }
+end
+
+if RSpec::Expectations::Version::STRING >= '3.0'
+  RSpec::Matchers.alias_matcher :an_output_string_including, :include_output_string
+  RSpec::Matchers.alias_matcher :file_content_including, :include_output_string
+end

data/lib/aruba/matchers/string/match_output_string.rb

@@ -0,0 +1,37 @@
+# @!method match_output_string(string)
+#   This matchers checks if the output string of a command matches regular expression.
+#
+#   @param [Integer] status
+#     The value of the exit status
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if the output string does not match regex
+#     true:
+#     * if the output string matches regex
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output an_output_string_matching regex) }
+#       it { expect(last_command_started).to have_output match_output_string regex) }
+#     end
+RSpec::Matchers.define :match_output_string do |expected|
+  match do |actual|
+    @expected = Regexp.new(unescape_text(expected), Regexp::MULTILINE)
+    @actual   = sanitize_text(actual)
+
+    values_match? @expected, @actual
+  end
+
+  diffable
+
+  description { "output string matches: #{description_of expected}" }
+end
+
+if RSpec::Expectations::Version::STRING >= '3.0'
+  RSpec::Matchers.alias_matcher :an_output_string_matching, :match_output_string
+  RSpec::Matchers.alias_matcher :a_file_name_matching, :match_output_string
+  RSpec::Matchers.alias_matcher :file_content_matching, :match_output_string
+end

data/lib/aruba/matchers/string/output_string_eq.rb

@@ -0,0 +1,35 @@
+# @!method output_string_eq(string)
+#   This matchers checks if the output string of a command includes string.
+#
+#   @param [Integer] status
+#     The value of the exit status
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if the output string does not include string
+#     true:
+#     * if the output string includes string
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output output_string_eq string) }
+#       it { expect(last_command_started).to have_output an_output_string_begin_eq string) }
+#     end
+RSpec::Matchers.define :output_string_eq do |expected|
+  match do |actual|
+    @expected = sanitize_text(expected.to_s)
+    @actual   = sanitize_text(actual.to_s)
+
+    values_match? @expected, @actual
+  end
+
+  diffable
+
+  description { "output string is eq: #{description_of expected}" }
+end
+
+if RSpec::Expectations::Version::STRING >= '3.0'
+  RSpec::Matchers.alias_matcher :an_output_string_being_eq, :output_string_eq
+end

data/lib/aruba/platform.rb

@@ -0,0 +1,25 @@
+require 'thread'
+require 'aruba/platforms/unix_platform'
+require 'aruba/platforms/windows_platform'
+
+# Aruba
+module Aruba
+  PLATFORM_MUTEX = Mutex.new
+end
+
+# Aruba
+module Aruba
+  # Platform
+  Platform = [Platforms::WindowsPlatform, Platforms::UnixPlatform].find(&:match?)
+end
+
+# Aruba
+module Aruba
+  PLATFORM_MUTEX.synchronize do
+    @platform = Platform.new
+  end
+
+  class << self
+    attr_reader :platform
+  end
+end

data/lib/aruba/platforms/announcer.rb

@@ -0,0 +1,232 @@
+require 'shellwords'
+require 'aruba/colorizer'
+
+Aruba::AnsiColor.coloring = false if !STDOUT.tty? && !ENV.key?("AUTOTEST")
+
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Announcer
+    #
+    # @private
+    #
+    # @example Activate your you own channel in cucumber
+    #
+    #   Before('@announce-my-channel') do
+    #     aruba.announcer.activate :my_channel
+    #   end
+    #
+    # @example Activate your you own channel in rspec > 3
+    #
+    #   before do
+    #     current_example = context.example
+    #     aruba.announcer.activate :my_channel if current_example.metadata[:announce_my_channel]
+    #   end
+    #
+    #   Aruba.announcer.announce(:my_channel, 'my message')
+    #
+    class Announcer
+      # 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)
+          puts message
+        end
+
+        def mode?(m)
+          :puts == m
+        end
+      end
+
+      private
+
+      attr_reader :announcers, :announcer, :channels, :output_formats, :colorizer
+
+      public
+
+      def initialize(*args)
+        @announcers = []
+        @announcers << PutsAnnouncer.new
+        @announcers << KernelPutsAnnouncer.new
+
+        @colorizer = Aruba::Colorizer.new
+
+        @announcer         = @announcers.first
+        @channels          = {}
+        @output_formats    = {}
+
+        @options           = args[1] || {}
+
+        after_init
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def after_init
+        output_format :changed_configuration, proc { |n, v| format('# %s = %s', n, v) }
+        output_format :changed_environment, proc { |n, v| format('$ export %s=%s', n, Shellwords.escape(v)) }
+        output_format :command, '$ %s'
+        output_format :directory, '$ cd %s'
+        output_format :environment, proc { |n, v| format('$ export %s=%s', n, Shellwords.escape(v)) }
+        output_format :full_environment, proc { |h| format("<<-ENVIRONMENT\n%s\nENVIRONMENT", Aruba.platform.simple_table(h)) }
+        output_format :modified_environment, proc { |n, v| format('$ export %s=%s', n, Shellwords.escape(v)) }
+        output_format :stderr, "<<-STDERR\n%s\nSTDERR"
+        output_format :stdout, "<<-STDOUT\n%s\nSTDOUT"
+        output_format :command_content, "<<-COMMAND\n%s\nCOMMAND"
+        output_format :stop_signal, proc { |p, s| format('Command will be stopped with `kill -%s %s`', s, p) }
+        output_format :timeout, '# %s-timeout: %s seconds'
+        output_format :wait_time, '# %s: %s seconds'
+        # rubocop:disable Metrics/LineLength
+        output_format :command_filesystem_status, proc { |status| format("<<-COMMAND FILESYSTEM STATUS\n%s\nCOMMAND FILESYSTEM STATUS", Aruba.platform.simple_table(status.to_h, :sort => false)) }
+        # rubocop:enable Metrics/LineLength
+
+        # 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)
+        output_formats[channel.to_sym] = if block_given?
+                                           block
+                                         elsif string.is_a?(Proc)
+                                           string
+                                         else
+                                           proc { |*args| format(string, *args) }
+                                         end
+      end
+
+      public
+
+      # Reset announcer
+      def reset
+        @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(*chns)
+        chns.flatten.each { |c| channels[c.to_sym] = true }
+
+        self
+      end
+
+      # Announce information to channel
+      #
+      # @param [Symbol] channel
+      #   The name of the channel to check
+      #
+      # @param [Array] args
+      #   Arguments
+      #
+      # @yield
+      #   If block is given, that one is called and the return value is used as
+      #   message to be announced.
+      def announce(channel, *args, &block)
+        channel = channel.to_sym
+
+        the_output_format = if output_formats.key? channel
+                              output_formats[channel]
+                            else
+                              proc { |v| format('%s', v) }
+                            end
+
+        return unless activated?(channel)
+
+        message = if block_given?
+                    the_output_format.call(yield)
+                  else
+                    the_output_format.call(*args)
+                  end
+        message += "\n"
+        message = colorizer.cyan(message)
+
+        announcer.announce(message)
+
+        nil
+      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(name, value)
+        warn('The announcer now has a new api to activate channels. Please use this one: announce(:changed_environment, key, value)')
+
+        announce :changed_environment, name, value
+      end
+    end
+  end
+end

data/lib/aruba/platforms/aruba_file_creator.rb

@@ -0,0 +1,35 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Normal File Creator
+    # This class is not meant to be used directly by users.
+    #
+    # @private
+    class ArubaFileCreator
+      # Write File
+      #
+      # @param [String] path
+      #   The path to write content to
+      #
+      # @param [Object] content
+      #   The content of the file
+      #
+      # @param [TrueClass, FalseClass] check_presence (false)
+      #   Check if file exist
+      def call(path, content, check_presence = false)
+        fail "Expected #{path} to be present" if check_presence && !Aruba.platform.file?(path)
+
+        Aruba.platform.mkdir(File.dirname(path))
+
+        if RUBY_VERSION < '1.9.3'
+          File.open(path, 'w') { |f| f << content }
+        else
+          File.write(path, content)
+        end
+
+        self
+      end
+    end
+  end
+end