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

.camel_case(a_string) ⇒ Object 



224
225
226
 
# File 'lib/kitchen/util.rb', line 224

def self.camel_case(a_string)
  Thor::Util.camel_case(a_string)
end

.command_exists?(cmd) ⇒ Boolean

Check if a cmd exists on the PATH



233
234
235
236
237
238
239
240
 
# File 'lib/kitchen/util.rb', line 233

def self.command_exists?(cmd)
  paths = ENV["PATH"].split(File::PATH_SEPARATOR) + [ "/bin", "/usr/bin", "/sbin", "/usr/sbin" ]
  paths.each do |path|
    filename = File.join(path, cmd)
    return filename if File.executable?(filename)
  end
  false
end

.duration(total) ⇒ String

Returns a formatted string representing a duration in seconds.



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

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 representation of a logging levels for a given standard library Logger::Severity constant.



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

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

Note:

Dir.chdir is applied to the process, thus it is not thread-safe

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

and must be synchronized.



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/kitchen/util.rb', line 176

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 [] unless Dir.exist?(path)

  Kitchen.mutex_chdir.synchronize do
    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
end

.mask_values(string_to_mask, keys) ⇒ String

Returns a string with masked values for specified parameters.



96
97
98
99
100
101
102
 
# File 'lib/kitchen/util.rb', line 96

def self.mask_values(string_to_mask, keys)
  masked_string = string_to_mask
  keys.each do |key|
    masked_string.gsub!(/:#{key}=>"([^"]*)"/, %{:#{key}=>"******"})
  end
  masked_string
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\n    b\nc\n"
Util.outdent!(string) # => "a\n  b\nc\n"



145
146
147
 
# File 'lib/kitchen/util.rb', line 145

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

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

Note:

Dir.chdir is applied to the process, thus it is not thread-safe

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.

and must be synchronized.



214
215
216
217
218
219
220
221
222
 
# File 'lib/kitchen/util.rb', line 214

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

  Kitchen.mutex_chdir.synchronize do
    Dir.chdir(path) do
      Dir.glob(pattern, *flags).map { |f| File.join(path, f) }
    end
  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.



154
155
156
157
158
 
# File 'lib/kitchen/util.rb', line 154

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

.snake_case(a_string) ⇒ Object 



228
229
230
 
# File 'lib/kitchen/util.rb', line 228

def self.snake_case(a_string)
  Thor::Util.snake_case(a_string)
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.



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

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.



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

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.



34
35
36
37
38
 
# File 'lib/kitchen/util.rb', line 34

def self.to_logger_level(symbol)
  return nil unless i{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.



123
124
125
126
127
128
129
 
# File 'lib/kitchen/util.rb', line 123

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

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