Module: Kitchen::Util

Defined in:
lib/kitchen/util.rb

Overview

Stateless utility methods used in different contexts. Essentially a mini PassiveSupport library.

Author:

Class Method Summary collapse

Class Method Details

.duration(total) ⇒ String

Returns a formatted string representing a duration in seconds.

Parameters:

  • total (Integer) —

    the total number of seconds

Returns:

  • (String) —

    a formatted string of the form (XmYY.00s)



93
94
95
96
97
98
 
# File 'lib/kitchen/util.rb', line 93

def self.duration(total)
  total = 0 if total.nil?
  minutes = (total / 60).to_i
  seconds = (total - (minutes * 60))
  format("(%dm%.2fs)", minutes, seconds)
end

.from_logger_level(const) ⇒ Symbol

Returns the symbol represenation of a logging levels for a given standard library Logger::Severity constant.

Parameters:

  • const (Integer) —

    Logger::Severity constant value for a logging level (Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR, Logger::FATAL)

Returns:

  • (Symbol) —

    symbol representation of the logging level



45
46
47
48
49
50
51
52
53
 
# File 'lib/kitchen/util.rb', line 45

def self.from_logger_level(const)
  case const
  when Logger::DEBUG then :debug
  when Logger::INFO then :info
  when Logger::WARN then :warn
  when Logger::ERROR then :error
  else :fatal
  end
end

.list_directory(path, include_dot: false, recurse: false) ⇒ Object

Note:

You should prefer this method to using Dir.glob directly. The reason is

Lists the contents of the given directory. path will be prepended to the list returned. '.' and '..' are never returned.

because Dir.glob behaves strangely on Windows. It wont accept '\' and doesn't like fake directories (C:\Documents and Settings) It also does not do any sort of error checking, so things one would expect to fail just return an empty list

Parameters:

  • path (String) —

    the directory to list

  • include_dot (Boolean) (defaults to: false) —

    if true, dot files will be included

  • recurse (Boolean) (defaults to: false) —

    if true, listing will be recursive

Returns:

  • A listing of the specified path



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/kitchen/util.rb', line 158

def self.list_directory(path, include_dot: false, recurse: false)
  # Things (such as tests) are relying on this to not blow up if
  # the directory does not exist
  return [] if !Dir.exist?(path)

  Dir.chdir(path) do
    glob_pattern = if recurse
                     "**/*"
                   else
                     "*"
                   end
    flags = if include_dot
              [File::FNM_DOTMATCH]
            else
              []
            end
    Dir.glob(glob_pattern, *flags)
      .reject { |f| [".", ".."].include?(f) }
      .map { |f| File.join(path, f) }
  end
end

.outdent!(string) ⇒ String

Modifes the given string to strip leading whitespace on each line, the amount which is calculated by using the first line of text.

Examples:


string = "a\nb\nc\n"
Util.outdent!(string) # => "a\n  b\nc\n"

Parameters:

  • string (String) —

    the string that will be modified

Returns:

  • (String) —

    the modified string



130
131
132
 
# File 'lib/kitchen/util.rb', line 130

def self.outdent!(string)
  string.gsub!(/^ {#{string.index(/[^ ]/)}}/, "")
end

.safe_glob(path, pattern, *flags) ⇒ Object

Similar to Dir.glob.

The difference is this function forces you to specify where to glob from. You should glob from the path closest to what you want. The reason for this is because if you have symlinks on windows of any kind, Dir.glob will not traverse them.

Parameters:

  • path (String) —

    the directory to glob from

  • pattern (String) —

    The pattern to match

  • flags (Integer) —

    You can specify flags you would have passed to Dir.glob

Returns:

  • Files matching the specified pattern in the given path



191
192
193
194
195
196
197
 
# File 'lib/kitchen/util.rb', line 191

def self.safe_glob(path, pattern, *flags)
  return [] if !Dir.exist?(path)

  Dir.chdir(path) do
    Dir.glob(pattern, *flags).map { |f| File.join(path, f) }
  end
end

.shell_helpers ⇒ String

Returns a set of Bourne Shell (AKA /bin/sh) compatible helper functions. This function is usually called inline in a string that will be executed remotely on a test instance.

Returns:

  • (String) —

    a string representation of useful helper functions



139
140
141
142
143
 
# File 'lib/kitchen/util.rb', line 139

def self.shell_helpers
  IO.read(File.join(
            File.dirname(__FILE__), %w{.. .. support download_helpers.sh}
  ))
end

.stringified_hash(obj) ⇒ Object

Returns a new Hash with all key values coerced to strings. All keys within a Hash are coerced by calling #to_s and hashes with arrays and other hashes are traversed.

Parameters:

  • obj (Object) —

    the hash to be processed. While intended for hashes, this method safely processes arbitrary objects

Returns:

  • (Object) —

    a converted hash with all keys as strings



79
80
81
82
83
84
85
86
87
 
# File 'lib/kitchen/util.rb', line 79

def self.stringified_hash(obj)
  if obj.is_a?(Hash)
    obj.inject({}) { |h, (k, v)| h[k.to_s] = stringified_hash(v); h }
  elsif obj.is_a?(Array)
    obj.inject([]) { |a, e| a << stringified_hash(e); a }
  else
    obj
  end
end

.symbolized_hash(obj) ⇒ Object

Returns a new Hash with all key values coerced to symbols. All keys within a Hash are coerced by calling #to_sym and hashes within arrays and other hashes are traversed.

Parameters:

  • obj (Object) —

    the hash to be processed. While intended for hashes, this method safely processes arbitrary objects

Returns:

  • (Object) —

    a converted hash with all keys as symbols



62
63
64
65
66
67
68
69
70
 
# File 'lib/kitchen/util.rb', line 62

def self.symbolized_hash(obj)
  if obj.is_a?(Hash)
    obj.inject({}) { |h, (k, v)| h[k.to_sym] = symbolized_hash(v); h }
  elsif obj.is_a?(Array)
    obj.inject([]) { |a, e| a << symbolized_hash(e); a }
  else
    obj
  end
end

.to_logger_level(symbol) ⇒ Integer

Returns the standard library Logger level constants for a given symbol representation.

Parameters:

  • symbol (Symbol) —

    symbol representation of a logger level (:debug, :info, :warn, :error, :fatal)

Returns:

  • (Integer) —

    Logger::Severity constant value or nil if input is not valid



32
33
34
35
36
 
# File 'lib/kitchen/util.rb', line 32

def self.to_logger_level(symbol)
  return nil unless [:debug, :info, :warn, :error, :fatal].include?(symbol)

  Logger.const_get(symbol.to_s.upcase)
end

.wrap_command(cmd) ⇒ String

Generates a command (or series of commands) wrapped so that it can be invoked on a remote instance or locally.

This method uses the Bourne shell (/bin/sh) to maximize the chance of cross platform portability on Unixlike systems.

Parameters:

  • the (String) —

    command

Returns:

  • (String) —

    a wrapped command string



108
109
110
111
112
113
114
 
# File 'lib/kitchen/util.rb', line 108

def self.wrap_command(cmd)
  cmd = "false" if cmd.nil?
  cmd = "true" if cmd.to_s.empty?
  cmd = cmd.sub(/\n\Z/, "") if cmd =~ /\n\Z/

  "sh -c '\n#{cmd}\n'"
end