aruba-win-fix 0.14.2

data/lib/aruba/platforms/local_environment.rb

@@ -0,0 +1,29 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Local environemnt
+    #
+    # Wraps logic to make enviroment local and restorable
+    class LocalEnvironment
+      # Run in environment
+      #
+      # @param [Hash] env
+      #   The environment
+      #
+      # @yield
+      #   The block of code which should with local ENV
+      def call(env, &block)
+        old_env = ENV.to_hash.dup
+
+        ENV.clear
+        ENV.update env
+
+        yield if block_given?
+      ensure
+        ENV.clear
+        ENV.update old_env
+      end
+    end
+  end
+end

data/lib/aruba/platforms/simple_table.rb

@@ -0,0 +1,54 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Generate simple table
+    class SimpleTable
+      private
+
+      attr_reader :hash, :opts
+
+      public
+
+      # Create
+      #
+      # @param [Hash] hash
+      #   Input
+      def initialize(hash, opts)
+        @hash = hash
+        @opts = {
+          :sort => true
+        }.merge opts
+      end
+
+      # Generate table
+      #
+      # @return [String]
+      #   The table
+      def to_s
+        longest_key = hash.keys.map(&:to_s).max_by(&:length)
+        return '' if longest_key.nil?
+
+        name_size = longest_key.length
+
+        if RUBY_VERSION < '2'
+          rows = []
+
+          hash.each do |k,v|
+            rows << format("# %-#{name_size}s => %s", k, v)
+          end
+        else
+          rows = hash.each_with_object([]) do |(k,v), a|
+            a << format("# %-#{name_size}s => %s", k, v)
+          end
+        end
+
+        if opts[:sort] == true
+          rows.sort.join("\n")
+        else
+          rows.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/aruba/platforms/unix_command_string.rb

@@ -0,0 +1,27 @@
+require 'delegate'
+require 'shellwords'
+
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # This is a command which should be run
+    class UnixCommandString < SimpleDelegator
+      def initialize(cmd)
+        __setobj__ cmd
+      end
+
+      # Convert to array
+      def to_a
+        Shellwords.split __getobj__
+      end
+
+      if RUBY_VERSION < '1.9'
+        def to_s
+          __getobj__.to_s
+        end
+        alias inspect to_s
+      end
+    end
+  end
+end

data/lib/aruba/platforms/unix_environment_variables.rb

@@ -0,0 +1,220 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Abstract environment variables
+    class UnixEnvironmentVariables
+      # Update environment
+      class UpdateAction
+        attr_reader :other_env, :block
+
+        def initialize(other_env, &block)
+          @other_env = other_env
+
+          @other_env = if RUBY_VERSION <= '1.9.3'
+                         # rubocop:disable Style/EachWithObject
+                         @other_env.to_hash.inject({}) { |a, (k, v)| a[k] = v.to_s; a }
+                       # rubocop:enable Style/EachWithObject
+                       else
+                         @other_env.to_h.each_with_object({}) { |(k, v), a| a[k] = v.to_s }
+                       end
+
+          @block = if block_given?
+                     block
+                   end
+        end
+
+        def call(env)
+          if block
+            env.update(other_env, &block)
+          else
+            env.update(other_env)
+          end
+        end
+      end
+
+      # Remove variables from environment
+      class RemoveAction
+        attr_reader :variables
+
+        def initialize(variables)
+          @variables = Array(variables)
+        end
+
+        def call(env)
+          variables.each { |v| env.delete v }
+
+          env
+        end
+      end
+
+      # We need to use this, because `nil` is a valid value as default
+      UNDEFINED = Object.new.freeze
+
+      private
+
+      attr_reader :actions, :env
+
+      public
+
+      def initialize(env = ENV)
+        @actions = []
+
+        @env = if RUBY_VERSION < '2.0'
+                 env.to_hash
+               else
+                 env.to_h
+               end
+      end
+
+      # Update environment with other en
+      #
+      # @param [#to_hash, #to_h] other_env
+      #   Another environment object or hash
+      #
+      # @yield
+      #   Pass block to env
+      def update(other_env)
+        actions << UpdateAction.new(other_env)
+
+        UnixEnvironmentVariables.new(to_h)
+      end
+
+      # Fetch variable from environment
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      #
+      # @param [Object] default
+      #   The default value used, if the variable is not defined
+      def fetch(name, default = UNDEFINED)
+        if default == UNDEFINED
+          to_h.fetch name.to_s
+        else
+          to_h.fetch name.to_s, default
+        end
+      end
+
+      # Check if variable exist
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      def key?(name)
+        to_h.key? name.to_s
+      end
+
+      # Get value of variable
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      def [](name)
+        to_h[name.to_s]
+      end
+
+      # Set value of variable
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      #
+      # @param [#to_s] value
+      #   The value of the variable
+      def []=(name, value)
+        value = value.to_s
+
+        actions << UpdateAction.new(name.to_s => value)
+
+        value
+      end
+
+      # Append value to variable
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      #
+      # @param [#to_s] value
+      #   The value of the variable
+      def append(name, value)
+        name  = name.to_s
+        value = self[name].to_s + value.to_s
+
+        actions << UpdateAction.new(name => value )
+
+        value
+      end
+
+      # Prepend value to variable
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      #
+      # @param [#to_s] value
+      #   The value of the variable
+      def prepend(name, value)
+        name  = name.to_s
+        value = value.to_s + self[name].to_s
+
+        actions << UpdateAction.new(name => value)
+
+        value
+      end
+
+      # Delete variable
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      def delete(name)
+        # Rescue value, before it is deleted
+        value = to_h[name.to_s]
+
+        actions << RemoveAction.new(name.to_s)
+
+        value
+      end
+
+      # Pass on checks
+      def method_missing(name, *args, &block)
+        super unless to_h.respond_to? name
+
+        to_h.send name, *args, &block
+      end
+
+      # Check for respond_to
+      def respond_to_missing?(name, _private)
+        to_h.respond_to? name
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash]
+      #   A new hash from environment
+      def to_h
+        if RUBY_VERSION < '2.0'
+          Marshal.load(Marshal.dump(prepared_environment.to_hash))
+        else
+          Marshal.load(Marshal.dump(prepared_environment.to_h))
+        end
+      end
+
+      # Reset environment
+      def clear
+        value = to_h
+
+        actions.clear
+
+        value
+      end
+
+      private
+
+      def prepared_environment
+        if RUBY_VERSION <= '1.9.3'
+          # rubocop:disable Style/EachWithObject
+          actions.inject(ENV.to_hash.merge(env)) { |a, e| e.call(a) }
+          # rubocop:enable Style/EachWithObject
+        else
+          actions.each_with_object(ENV.to_hash.merge(env)) { |e, a| a = e.call(a) }
+        end
+      end
+    end
+  end
+end

data/lib/aruba/platforms/unix_platform.rb

@@ -0,0 +1,276 @@
+require 'rbconfig'
+require 'pathname'
+
+require 'aruba/aruba_path'
+
+require 'aruba/platforms/simple_table'
+require 'aruba/platforms/unix_command_string'
+require 'aruba/platforms/unix_which'
+require 'aruba/platforms/determine_file_size'
+require 'aruba/platforms/determine_disk_usage'
+require 'aruba/platforms/aruba_file_creator'
+require 'aruba/platforms/aruba_fixed_size_file_creator'
+require 'aruba/platforms/local_environment'
+require 'aruba/platforms/aruba_logger'
+require 'aruba/platforms/announcer'
+require 'aruba/platforms/command_monitor'
+require 'aruba/platforms/filesystem_status'
+
+# Aruba
+module Aruba
+  # This abstracts OS-specific things
+  module Platforms
+    # WARNING:
+    # All methods found here are not considered part of the public API of aruba.
+    #
+    # Those methods can be changed at any time in the feature or removed without
+    # any further notice.
+    #
+    # This includes all methods for the UNIX platform
+    #
+    # @private
+    class UnixPlatform
+      def self.match?
+        !FFI::Platform.windows?
+      end
+
+      def environment_variables
+        UnixEnvironmentVariables
+      end
+
+      def command_string
+        UnixCommandString
+      end
+
+      def filesystem_status
+        FilesystemStatus
+      end
+
+      def announcer
+        Announcer
+      end
+
+      def command_monitor
+        CommandMonitor
+      end
+
+      def logger
+        ArubaLogger
+      end
+
+      def determine_file_size(*args)
+        DetermineFileSize.new.call(*args)
+      end
+
+      def determine_disk_usage(*args)
+        DetermineDiskUsage.new.call(*args)
+      end
+
+      def create_file(*args)
+        ArubaFileCreator.new.call(*args)
+      end
+
+      def create_fixed_size_file(*args)
+        ArubaFixedSizeFileCreator.new.call(*args)
+      end
+
+      def with_environment(env = {}, &block)
+        LocalEnvironment.new.call(env, &block)
+      end
+
+      def default_shell
+        'bash'
+      end
+
+      def detect_ruby(cmd)
+        if cmd =~ /^ruby\s/
+          cmd.gsub(/^ruby\s/, "#{current_ruby} ")
+        else
+          cmd
+        end
+      end
+
+      def deprecated(msg)
+        warn(format('%s. Called by %s', msg, caller[1]))
+      end
+
+      def current_ruby
+        ::File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+      end
+
+      # @deprecated
+      # Add newline at the end
+      def ensure_newline(str)
+        deprecated('The use of "#ensure_newline" is deprecated. It will be removed soon')
+
+        str.chomp << "\n"
+      end
+
+      def require_matching_files(pattern, base)
+        if RUBY_VERSION < '1.9.3'
+          ::Dir.glob(::File.expand_path(pattern, base)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
+        else
+          ::Dir.glob(::File.expand_path(pattern, base)).each { |f| require_relative f }
+        end
+      end
+
+      # Create directory and subdirectories
+      def mkdir(dir_name)
+        dir_name = ::File.expand_path(dir_name)
+
+        ::FileUtils.mkdir_p(dir_name) unless ::File.directory?(dir_name)
+      end
+
+      # Remove file, directory + sub-directories
+      def rm(paths, options = {})
+        paths = Array(paths).map { |p| ::File.expand_path(p) }
+
+        FileUtils.rm_r(paths, options)
+      end
+
+      # Get current working directory
+      def getwd
+        Dir.getwd
+      end
+
+      # Change to directory
+      def chdir(dir_name, &block)
+        dir_name = ::File.expand_path(dir_name.to_s)
+
+        with_environment 'OLDPWD' => getwd, 'PWD' => dir_name do
+          ::Dir.chdir(dir_name, &block)
+        end
+      end
+
+      # Touch file, directory
+      def touch(args, options)
+        FileUtils.touch(args, options)
+      end
+
+      # Copy file/directory
+      def cp(args, options)
+        FileUtils.cp_r(args, options)
+      end
+
+      # Move file/directory
+      def mv(args, options)
+        FileUtils.mv(args, options)
+      end
+
+      # Change mode of file/directory
+      def chmod(mode, args, options)
+        FileUtils.chmod_R(mode, args, options)
+      end
+
+      # Exists and is file
+      def file?(f)
+        File.file? f
+      end
+
+      # Exists and is directory
+      def directory?(f)
+        File.directory? f
+      end
+
+      # Path Exists
+      def exist?(f)
+        File.exist? f
+      end
+
+      # Path is executable
+      def executable?(f)
+        File.executable?(f)
+      end
+
+      # Expand path
+      def expand_path(path, base)
+        File.expand_path(path, base)
+      end
+
+      # Is absolute path
+      def absolute_path?(path)
+        Pathname.new(path).absolute?
+      end
+
+      # Is relative path
+      def relative_path?(path)
+        Pathname.new(path).relative?
+      end
+
+      # Check if command is relative
+      #
+      # @return [TrueClass, FalseClass]
+      #   true
+      #     * bin/command.sh
+      #
+      #   false
+      #     * /bin/command.sh
+      #     * command.sh
+      def relative_command?(path)
+        p = ArubaPath.new(path)
+        p.relative? && p.depth > 1
+      end
+
+      # Check if command is relative
+      #
+      # @return [TrueClass, FalseClass]
+      #   true
+      #     * command.sh
+      #
+      #   false
+      #     * /bin/command.sh
+      #     * bin/command.sh
+      def command?(path)
+        p = Pathname.new(path)
+        p.relative? && p.basename == p
+      end
+
+      # Write to file
+      def write_file(path, content)
+        if RUBY_VERSION < '1.9.3'
+          File.open(path, 'wb') do |f|
+            f.print content
+          end
+        else
+          File.write(path, content)
+        end
+      end
+
+      # Unescape string
+      #
+      # @param [String] string
+      #   The string which should be unescaped, e.g. the output of a command
+      #
+      # @return
+      #   The string stripped from escape sequences
+      def unescape(string, keep_ansi = true)
+        # rubocop:disable Metrics/LineLength
+        deprecated('The use of "Aruba.platform.unescape" is deprecated. Please use "#unescape_text" and "#sanitize_text" instead. But be aware it uses a different implementation')
+        # rubocop:enable Metrics/LineLength
+
+        string = string.gsub('\n', "\n").gsub('\"', '"').gsub('\e', "\e")
+        string = string.gsub(/\e\[\d+(?>(;\d+)*)m/, '') unless keep_ansi
+        string
+      end
+
+      # Transform hash to a string table which can be output on stderr/stdout
+      def simple_table(hash, opts = {})
+        SimpleTable.new(hash, opts).to_s
+      end
+
+      # Resolve path for command using the PATH-environment variable
+      #
+      # Mostly taken from here: https://github.com/djberg96/ptools
+      #
+      # @param [#to_s] program
+      #   The name of the program which should be resolved
+      #
+      # @param [String] path
+      #   The PATH, a string concatenated with ":", e.g. /usr/bin/:/bin on a
+      #   UNIX-system
+      def which(program, path = ENV['PATH'])
+        UnixWhich.new.call(program, path)
+      end
+    end
+  end
+end