aruba-win-fix 0.14.2

data/lib/aruba/platforms/aruba_fixed_size_file_creator.rb

@@ -0,0 +1,35 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Create files with fixed size
+    #
+    # This class is not meant to be used directly by users.
+    #
+    # It uses a single null byte as content and really creates so called sparse
+    # files.
+    #
+    # @private
+    class ArubaFixedSizeFileCreator
+      # Write File
+      #
+      # @param [String] path
+      #   The path to write content to
+      #
+      # @param [Numeric] size
+      #   The size of the file
+      #
+      # @param [TrueClass, FalseClass] check_presence (false)
+      #   Check if file exist
+      def call(path, size, check_presence)
+        fail "Expected #{path} to be present" if check_presence && !Aruba.platform.file?(path)
+
+        Aruba.platform.mkdir(File.dirname(path))
+
+        File.open(path, "wb"){ |f| f.seek(size - 1); f.write("\0") }
+
+        self
+      end
+    end
+  end
+end

data/lib/aruba/platforms/aruba_logger.rb

@@ -0,0 +1,81 @@
+require 'logger'
+
+# Aruba
+module Aruba
+  # Logger
+  #
+  # @private
+  class ArubaLogger
+    attr_reader :mode
+
+    # Create logger
+    #
+    # @param [Logger] logger (::Logger.new( $stderr ))
+    #   The logger with should be used to output data
+    def initialize(opts = {})
+      @mode = opts.fetch(:default_mode, :info)
+    end
+
+    [:fatal, :warn, :debug, :info, :error, :unknown].each do |m|
+      define_method m do |msg|
+        if RUBY_VERSION < '1.9'
+          logger.send m, msg
+        else
+          logger.public_send m, msg
+        end
+      end
+    end
+
+    # Create new logger on every invocation to make
+    # capturing $stderr possible
+    def logger
+      l = ::Logger.new($stderr)
+
+      case mode
+      when :debug
+        l.level = ::Logger::DEBUG
+        format_debug(l)
+      when :silent
+        l.level = 9_999
+      when :info
+        l.level = ::Logger::INFO
+        format_standard(l)
+      else
+        l.level = ::Logger::INFO
+        format_standard(l)
+      end
+
+      l
+    end
+
+    # Is mode?
+    #
+    # @param [String, Symbol] m
+    #   Mode to compare with
+    def mode?(m)
+      mode == m.to_sym
+    end
+
+    # Change mode of logger: :debug, ... + Change the output format
+    #
+    # @param [Symbol] m
+    #   the mode: :debug, ...
+    def mode=(m)
+      @mode = m.to_sym
+    end
+
+    private
+
+    def format_debug(l)
+      l.formatter = proc { |severity, datetime, progname, msg|
+        format("%s %s %s: %s\n", datetime, severity, progname, msg)
+      }
+    end
+
+    def format_standard(l)
+      l.formatter = proc { |severity, datetime, _, msg|
+        format("%s %s: %s\n", datetime, severity, msg)
+      }
+    end
+  end
+end

data/lib/aruba/platforms/command_monitor.rb

@@ -0,0 +1,229 @@
+require 'aruba/errors'
+
+# Aruba
+module Aruba
+  # The command monitor is part of the private API of Aruba.
+  #
+  # @private
+  class CommandMonitor
+    private
+
+    attr_reader :announcer
+
+    public
+
+    attr_reader :registered_commands, :last_command_started
+
+    class DefaultLastCommandStopped
+      def nil?
+        true
+      end
+
+      def method_missing(*)
+        fail NoCommandHasBeenStoppedError, 'No last command stopped available'
+      end
+    end
+
+    class DefaultLastCommandStarted
+      def nil?
+        true
+      end
+
+      def method_missing(*)
+        fail NoCommandHasBeenStartedError, 'No last command started available'
+      end
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def initialize(opts = {})
+      @registered_commands = []
+      @announcer = opts.fetch(:announcer)
+
+      @last_command_stopped = DefaultLastCommandStopped.new
+      @last_command_started = DefaultLastCommandStarted.new
+
+    rescue KeyError => e
+      raise ArgumentError, e.message
+    end
+
+    if Aruba::VERSION < '1'
+      # Return the last command stopped
+      def last_command_stopped
+        return @last_command_stopped unless @last_command_stopped.nil?
+
+        registered_commands.each(&:stop)
+
+        @last_command_stopped
+      end
+    else
+      attr_reader :last_command_stopped
+    end
+
+    # Set last command started
+    #
+    # @param [String] cmd
+    #   The commandline of the command
+    def last_command_started=(cmd)
+      @last_command_started = find(cmd)
+    end
+
+    # Set last command started
+    #
+    # @param [String] cmd
+    #   The commandline of the command
+    def last_command_stopped=(cmd)
+      @last_command_stopped = find(cmd)
+    end
+
+    # Find command
+    #
+    # @yield [Command]
+    #   This yields the found command
+    def find(cmd)
+      cmd = cmd.commandline if cmd.respond_to? :commandline
+      command = registered_commands.reverse.find { |c| c.commandline == cmd }
+
+      fail CommandNotFoundError, "No command named '#{cmd}' has been started" if command.nil?
+
+      command
+    end
+
+    # Clear list of known commands
+    def clear
+      registered_commands.each(&:terminate)
+      registered_commands.clear
+
+      self
+    end
+
+    # @deprecated
+    # Fetch output (stdout, stderr) from command
+    #
+    # @param [String] cmd
+    #   The command
+    def output_from(cmd)
+      cmd = Utils.detect_ruby(cmd)
+      find(cmd).output
+    end
+
+    # @deprecated
+    # Fetch stdout from command
+    #
+    # @param [String] cmd
+    #   The command
+    def stdout_from(cmd)
+      cmd = Utils.detect_ruby(cmd)
+      find(cmd).stdout
+    end
+
+    # @deprecated
+    # Fetch stderr from command
+    #
+    # @param [String] cmd
+    #   The command
+    def stderr_from(cmd)
+      cmd = Utils.detect_ruby(cmd)
+      find(cmd).stderr
+    end
+
+    # @deprecated
+    # Get stdout of all commands
+    #
+    # @return [String]
+    #   The stdout of all command which have run before
+    def all_stdout
+      registered_commands.each(&:stop)
+
+      if RUBY_VERSION < '1.9.3'
+        # rubocop:disable Style/EachWithObject
+        registered_commands.inject("") { |a, e| a << e.stdout; a }
+        # rubocop:enable Style/EachWithObject
+      else
+        registered_commands.each_with_object("") { |e, a| a << e.stdout }
+      end
+    end
+
+    # @deprecated
+    # Get stderr of all commands
+    #
+    # @return [String]
+    #   The stderr of all command which have run before
+    def all_stderr
+      registered_commands.each(&:stop)
+
+      if RUBY_VERSION < '1.9.3'
+        # rubocop:disable Style/EachWithObject
+        registered_commands.inject("") { |a, e| a << e.stderr; a }
+        # rubocop:enable Style/EachWithObject
+      else
+        registered_commands.each_with_object("") { |e, a| a << e.stderr }
+      end
+    end
+
+    # @deprecated
+    # Get stderr and stdout of all commands
+    #
+    # @return [String]
+    #   The stderr and stdout of all command which have run before
+    def all_output
+      all_stdout << all_stderr
+    end
+
+    # @deprecated
+    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
+      registered_commands.each(&:stop)
+      @last_exit_status
+    end
+
+    # @deprecated
+    def stop_process(process)
+      @last_command_stopped = process
+      @last_exit_status     = process.stop(announcer)
+    end
+
+    # @deprecated
+    def terminate_process!(process)
+      process.terminate
+    end
+
+    # @deprecated
+    def stop_processes!
+      Aruba.platform.deprecated('The use of "#stop_processes!" is deprecated.')
+
+      registered_commands.each(&:stop)
+    end
+
+    # @deprecated
+    # Terminate all running processes
+    def terminate_processes
+      Aruba.platform.deprecated('The use of "#terminate_processes" is deprecated.')
+
+      registered_commands.each(&:terminate)
+    end
+
+    # @deprecated
+    def only_processes
+      Aruba.platform.deprecated('The use of "#only_processes" is deprecated.')
+
+      registered_commands
+    end
+
+    # @deprecated
+    def get_process(wanted)
+      command = find(wanted)
+      raise ArgumentError.new("No process named '#{wanted}' has been started") unless command
+
+      command
+    end
+
+    # Register command to monitor
+    def register_command(cmd)
+      registered_commands << cmd
+
+      self
+    end
+  end
+end

data/lib/aruba/platforms/determine_disk_usage.rb

@@ -0,0 +1,28 @@
+require 'aruba/platforms/disk_usage_calculator'
+
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Determinate disk usage
+    #
+    # @private
+    class DetermineDiskUsage
+      def call(*args)
+        args = args.flatten
+
+        physical_block_size = args.pop
+        paths = args
+
+        size = paths.flatten.map do |p|
+          DiskUsageCalculator.new.call(
+            p.blocks,
+            physical_block_size
+          )
+        end.inject(0, &:+)
+
+        FileSize.new(size)
+      end
+    end
+  end
+end

data/lib/aruba/platforms/determine_file_size.rb

@@ -0,0 +1,22 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Determine size of a file
+    #
+    # @param [String] path
+    #   The path to file
+    #
+    # @return [Integer]
+    #   Returns size if exists. Returns -1 if path does not exist
+    class DetermineFileSize
+      def call(path)
+        return -1 unless File.file? path
+
+        FileSize.new(
+          File.size(path)
+        )
+      end
+    end
+  end
+end

data/lib/aruba/platforms/disk_usage_calculator.rb

@@ -0,0 +1,20 @@
+require 'aruba/file_size'
+
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Calculate disk usage
+    class DiskUsageCalculator
+      # Calc
+      #
+      # @param [Integer] blocks
+      #   Count of blocks
+      # @param [Integer] block_size
+      #   The size of a single block
+      def call(blocks, block_size)
+        Aruba::FileSize.new(blocks * block_size)
+      end
+    end
+  end
+end

data/lib/aruba/platforms/filesystem_status.rb

@@ -0,0 +1,68 @@
+require 'forwardable'
+
+module Aruba
+  module Platforms
+    # File System Status object
+    #
+    # This is a wrapper for File::Stat returning only a subset of information.
+    class FilesystemStatus
+      METHODS = [
+        :executable?,
+        :ctime,
+        :atime,
+        :mtime,
+        :size
+      ].freeze
+
+      extend Forwardable
+
+      private
+
+      attr_reader :status
+
+      public
+
+      if RUBY_VERSION >= '1.9.3'
+        def_delegators :@status, *METHODS
+      else
+        def_delegators :@status, :executable?, :ctime, :atime, :mtime, :size
+      end
+
+      def initialize(path)
+        @status = File::Stat.new(path)
+      end
+
+      # Return permissions
+      def mode
+        format("%o", status.mode)[-4,4].gsub(/^0*/, '')
+      end
+
+      # Return owner
+      def owner
+        status.uid
+      end
+
+      # Return owning group
+      def group
+        status.gid
+      end
+
+      # Convert status to hash
+      #
+      # @return [Hash]
+      #   A hash of values
+      def to_h
+        {
+          :owner      => owner,
+          :group      => group,
+          :mode       => mode,
+          :executable => executable?,
+          :ctime      => ctime,
+          :atime      => atime,
+          :mtime      => mtime,
+          :size       => size
+        }
+      end
+    end
+  end
+end