aruba 0.8.1 → 0.9.0.pre

data/lib/aruba/{creators → platforms}/aruba_file_creator.rb

@@ -15,11 +15,11 @@ module Aruba
       # @param [TrueClass, FalseClass] check_presence (false)
       #   Check if file exist
       def write(path, content, check_presence = false)
-        fail "Expected #{path} to be present" if check_presence && !Aruba::Platform.file?(path)
+        fail "Expected #{path} to be present" if check_presence && !Aruba.platform.file?(path)
 
-        Aruba::Platform.mkdir(File.dirname(path))
+        Aruba.platform.mkdir(File.dirname(path))
 
-        if RUBY_VERSION < '1.9'
+        if RUBY_VERSION < '1.9.3'
           File.open(path, 'w') { |f| f << content }
         else
           File.write(path, content)

data/lib/aruba/{creators → platforms}/aruba_fixed_size_file_creator.rb

@@ -19,9 +19,9 @@ module Aruba
       # @param [TrueClass, FalseClass] check_presence (false)
       #   Check if file exist
       def write(path, size, check_presence)
-        fail "Expected #{path} to be present" if check_presence && !Aruba::Platform.file?(path)
+        fail "Expected #{path} to be present" if check_presence && !Aruba.platform.file?(path)
 
-        Aruba::Platform.mkdir(File.dirname(path))
+        Aruba.platform.mkdir(File.dirname(path))
 
         File.open(path, "wb"){ |f| f.seek(size - 1); f.write("\0") }
 

data/lib/aruba/platforms/simple_table.rb

@@ -0,0 +1,36 @@
+module Aruba
+  module Platforms
+    class SimpleTable
+      private
+
+      attr_reader :hash
+
+      public
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      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
+
+          rows.sort
+        else
+          hash.each_with_object([]) do |(k,v), a|
+            a << format("# %-#{name_size}s => %s", k, v)
+          end.sort
+        end
+      end
+    end
+  end
+end

data/lib/aruba/platforms/unix_command_string.rb

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

data/lib/aruba/platforms/unix_environment_variables.rb

@@ -0,0 +1,130 @@
+module Aruba
+  module Platforms
+    class UnixEnvironmentVariables
+      # We need to use this, because `nil` is a valid value as default
+      UNDEFINED = Object.new
+
+      private
+
+      attr_reader :env
+
+      public
+
+      def initialize(env = ENV.to_hash)
+        @env = Marshal.load(Marshal.dump(env))
+      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, &block)
+        if RUBY_VERSION <= '1.9.3'
+          # rubocop:disable Style/EachWithObject
+          other_env = other_env.to_hash.inject({}) { |a, (k, v)| a[k] = v.to_s; a }
+          # rubocop:enable Style/EachWithObject
+        else
+          other_env = other_env.to_h.each_with_object({}) { |(k, v), a| a[k] = v.to_s }
+        end
+
+        env.update(other_env, &block)
+
+        self
+      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
+          env.fetch name.to_s
+        else
+          env.fetch name.to_s, default
+        end
+      end
+
+      # Check if variable exist
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      def key?(name)
+        env.key? name.to_s
+      end
+
+      # Get value of variable
+      #
+      # @param [#to_s] name
+      #   The name of the variable
+      def [](name)
+        env[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)
+        env[name.to_s] = value.to_s
+
+        self
+      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
+        env[name] = env[name].to_s + value.to_s
+
+        self
+      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
+        env[name] = value.to_s + env[name].to_s
+
+        self
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash]
+      #   A new hash from environment
+      def to_h
+        if RUBY_VERSION < '2.0'
+          Marshal.load(Marshal.dump(env.to_hash))
+        else
+          Marshal.load(Marshal.dump(env.to_h))
+        end
+      end
+
+      # Reset environment
+      def clear
+        env.clear
+
+        self
+      end
+    end
+  end
+end

data/lib/aruba/platforms/unix_platform.rb

@@ -0,0 +1,226 @@
+require 'rbconfig'
+require 'pathname'
+
+require 'aruba/platforms/simple_table'
+require 'aruba/platforms/unix_command_string'
+require 'aruba/platforms/unix_which'
+
+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
+    class UnixPlatform
+      def self.match?
+        !FFI::Platform.windows?
+      end
+
+      def environment_variables
+        UnixEnvironmentVariables.new
+      end
+
+      def command_string
+        UnixCommandString
+      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)
+
+        begin
+          if RUBY_VERSION <= '1.9.3'
+            old_env = ENV.to_hash.dup
+          else
+            old_env = ENV.to_h.dup
+          end
+
+          ENV['OLDPWD'] = getwd
+          ENV['PWD'] = dir_name
+          ::Dir.chdir(dir_name, &block)
+        ensure
+          ENV.clear
+          ENV.update old_env
+        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
+
+      # 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_file?(f)
+        File.file?(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 = Pathname.new(path)
+        p.relative? && p.basename != p
+      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)
+        deprecated('The use of "Aruba.platform.unescape" is deprecated. Please use "#unescape_text" and "#extract_text" instead')
+
+        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)
+        SimpleTable.new(hash).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

data/lib/aruba/platforms/unix_which.rb

@@ -0,0 +1,83 @@
+require 'aruba/platform'
+
+module Aruba
+  module Platforms
+    # Implement `which(command)` for UNIX/Linux
+    class UnixWhich
+      # Bail out because this should never be reached
+      class DefaultWhich
+        def self.match?(*)
+          true
+        end
+
+        def call(program, path)
+          fail %(Invalid input program "#{program}" and/or path "#{path}".)
+        end
+      end
+
+      # Find path for absolute or relative command
+      class AbsoluteOrRelativePathWhich
+        def self.match?(program)
+          Aruba.platform.absolute_path?(program) || Aruba.platform.relative_command?(program)
+        end
+
+        def call(program, path)
+          return File.expand_path(program) if Aruba.platform.executable_file?(program)
+
+          nil
+        end
+      end
+
+      # Find path for command
+      class ProgramWhich
+        def self.match?(program)
+          Aruba.platform.command?(program)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        def call(program, path)
+          # Iterate over each path glob the dir + program.
+          path.split(File::PATH_SEPARATOR).each do |dir|
+            dir = Aruba.platform.expand_path(dir, Dir.getwd)
+            next unless Aruba.platform.exist?(dir) # In case of bogus second argument
+
+            found = Dir[File.join(dir, program)].first
+            return found if found && Aruba.platform.executable_file?(found)
+          end
+
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      private
+
+      attr_reader :whiches
+
+      public
+
+      def initialize
+        @whiches = []
+        @whiches << AbsoluteOrRelativePathWhich
+        @whiches << ProgramWhich
+        @whiches << DefaultWhich
+      end
+
+      # Find fully quallified path for program
+      #
+      # @param [String] program
+      #   Name of program
+      #
+      # @param [String] path
+      #   ENV['PATH']
+      def call(program, path = ENV['PATH'])
+        raise ArgumentError, "ENV['PATH'] cannot be empty" if path.nil? || path.empty?
+        program = program.to_s
+
+        whiches.find { |w| w.match? program }.new.call(program, path)
+      end
+    end
+  end
+end