Module: PDK::Util

Defined in:
lib/pdk/util.rb,
lib/pdk/util/env.rb,
lib/pdk/util/git.rb,
lib/pdk/util/bundler.rb,
lib/pdk/util/version.rb,
lib/pdk/util/windows.rb,
lib/pdk/util/filesystem.rb,
lib/pdk/util/json_finder.rb,
lib/pdk/util/ruby_version.rb,
lib/pdk/util/template_uri.rb,
lib/pdk/util/windows/file.rb,
lib/pdk/util/vendored_file.rb,
lib/pdk/util/puppet_strings.rb,
lib/pdk/util/puppet_version.rb,
lib/pdk/util/windows/string.rb,
lib/pdk/util/windows/process.rb,
lib/pdk/util/windows/api_types.rb,
lib/pdk/util/changelog_generator.rb

Defined Under Namespace

Modules: Bundler, ChangelogGenerator, Filesystem, Git, PuppetStrings, Version, Windows Classes: Env, GitError, JSONFinder, PuppetVersion, RubyVersion, TemplateURI, VendoredFile

Constant Summary collapse

MODULE_FOLDERS = 
['manifests', 'lib/puppet', 'lib/puppet_x', 'lib/facter', 'tasks', 'facts.d', 'functions', 'types'].freeze

Class Method Summary collapse

Class Method Details

.cachedir ⇒ String

Returns the fully qualified path to a per-user PDK cachedir.

Returns:

  • (String) —

    Fully qualified path to per-user PDK cachedir.



125
126
127
128
129
130
131
 
# File 'lib/pdk/util.rb', line 125

def cachedir
  if Gem.win_platform?
    File.join(PDK::Util::Env['LOCALAPPDATA'], 'PDK', 'cache')
  else
    File.join(Dir.home, '.pdk', 'cache')
  end
end

.canonical_path(path) ⇒ String

Return an expanded, absolute path

Parameters:

  • path (String) —

    Existing path that may not be canonical

Returns:

  • (String) —

    Canonical path



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

def canonical_path(path)
  if Gem.win_platform?
    raise PDK::CLI::FatalError, format("Cannot resolve a full path to '%{path}', as it does not currently exist.", path: path) unless PDK::Util::Filesystem.exist?(path)

    PDK::Util::Windows::File.get_long_pathname(path)
  else
    PDK::Util::Filesystem.expand_path(path)
  end
end

.configdir ⇒ Object 



134
135
136
137
138
139
140
 
# File 'lib/pdk/util.rb', line 134

def configdir
  if Gem.win_platform?
    File.join(PDK::Util::Env['LOCALAPPDATA'], 'PDK')
  else
    File.join(PDK::Util::Env.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config')), 'pdk')
  end
end

.deep_duplicate(object) ⇒ Object

Does a deep copy instead of a shallow copy of an object.

Parameters:

  • object (Object) —

    The object to duplicate

Returns:

  • (Object) —

    duplicate of the original object the current working dir does not appear to be within a module.



257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/pdk/util.rb', line 257

def deep_duplicate(object)
  case object
  when Array
    object.map { |item| deep_duplicate(item) }
  when Hash
    hash = object.dup
    hash.each_pair { |key, value| hash[key] = deep_duplicate(value) }
    hash
  else
    object
  end
end

.development_mode? ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
99
100
 
# File 'lib/pdk/util.rb', line 96

def development_mode?
  require 'pdk/util/version'

  !PDK::Util::Version.git_ref.nil? || PDK::VERSION.end_with?('.pre')
end

.exit_process(exit_code) ⇒ Object

Calls Kernel.exit with an exitcode



32
33
34
 
# File 'lib/pdk/util.rb', line 32

def exit_process(exit_code)
  exit exit_code
end

.find_all_json_in(text) ⇒ Array<Hash>

Iterate through possible JSON documents for all valid JSON

Parameters:

  • text (String) —

    the text in which to find JSON document(s)

Returns:

  • (Array<Hash>) —

    subset of text as Array of all JSON object found, empty Array if none are found JSON found in the text



202
203
204
 
# File 'lib/pdk/util.rb', line 202

def find_all_json_in(text)
  PDK::Util::JSONFinder.new(text).objects
end

.find_first_json_in(text) ⇒ Hash?

Iterate through possible JSON documents until we find one that is valid.

Parameters:

  • text (String) —

    the text in which to find a JSON document

Returns:

  • (Hash, nil) —

    subset of text as Hash of first valid JSON found, or nil if no valid JSON found in the text



192
193
194
 
# File 'lib/pdk/util.rb', line 192

def find_first_json_in(text)
  find_all_json_in(text).first
end

.find_upwards(target, start_dir = nil) ⇒ String?

Searches upwards from current working directory for the given target file.

Parameters:

  • target (String) —

    Name of file to search for.

  • start_dir (String) (defaults to: nil) —

    Directory to start searching from, defaults to Dir.pwd

Returns:

  • (String, nil) —

    Fully qualified path to the given target file if found, nil if the target file could not be found.



45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/pdk/util.rb', line 45

def find_upwards(target, start_dir = nil)
  previous = nil
  current  = PDK::Util::Filesystem.expand_path(start_dir || Dir.pwd)

  until !PDK::Util::Filesystem.directory?(current) || current == previous
    filename = File.join(current, target)
    return filename if PDK::Util::Filesystem.file?(filename)

    previous = current
    current = PDK::Util::Filesystem.expand_path('..', current)
  end
end

.gem_install? ⇒ Boolean

Returns:

  • (Boolean) 


103
104
105
 
# File 'lib/pdk/util.rb', line 103

def gem_install?
  !(package_install? || development_mode?)
end

.in_module_root?(path = Dir.pwd) ⇒ boolean

Returns true or false depending on if any of the common directories in a module are found in the specified directory. If a directory is not specified, the current working directory is used.

Returns:

  • (boolean) —

    True if any folders from MODULE_FOLDERS are found in the current dir, false otherwise.



181
182
183
184
 
# File 'lib/pdk/util.rb', line 181

def in_module_root?(path = Dir.pwd)
  PDK::Util::MODULE_FOLDERS.any? { |dir| PDK::Util::Filesystem.directory?(File.join(path, dir)) } ||
    PDK::Util::Filesystem.file?(File.join(path, 'metadata.json'))
end

.make_tmpdir_name(base) ⇒ String

Generate a name for a temporary directory.

Parameters:

  • base (String) —

    A string to base the name generation off.

Returns:

  • (String) —

    The temporary directory path.



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

def make_tmpdir_name(base)
  require 'tmpdir'

  t = Time.now.strftime('%Y%m%d')
  name = "#{base}#{t}-#{Process.pid}-#{rand(0x100000000).to_s(36)}"
  File.join(Dir.tmpdir, name)
end

.module_fixtures_dir ⇒ String

The module’s fixtures directory for spec testing

Returns:

  • (String) —

    • the path to the module’s fixtures directory



169
170
171
172
 
# File 'lib/pdk/util.rb', line 169

def module_fixtures_dir
  dir = module_root
  File.join(module_root, 'spec', 'fixtures') unless dir.nil?
end

.module_metadata(module_path = nil) ⇒ Object

TO-DO: Refactor replacement of lib/pdk/module/build.rb:metadata to use this function instead

Parameters:

  • module_path (String) (defaults to: nil) —

    The path to the root of the module. Default is determine the module root automatically



223
224
225
226
227
 
# File 'lib/pdk/util.rb', line 223

def module_metadata(module_path = nil)
  require 'pdk/module/metadata'
  module_path ||= module_root
  PDK::Module::Metadata.from_file(File.join(module_path, 'metadata.json')).data
end

.module_pdk_compatible?(module_path = nil) ⇒ Boolean

TO-DO: Refactor replacement of lib/pdk/module/build.rb:module_pdk_compatible? to use this function instead

Parameters:

  • module_path (String) (defaults to: nil) —

    The path to the root of the module. Default is determine the module root automatically

Returns:

  • (Boolean) 


232
233
234
 
# File 'lib/pdk/util.rb', line 232

def module_pdk_compatible?(module_path = nil)
  ['pdk-version', 'template-url'].any? { |key| module_metadata(module_path).key?(key) }
end

.module_pdk_version ⇒ Object 



237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/pdk/util.rb', line 237

def module_pdk_version
  metadata = module_metadata

  if metadata.nil? || metadata.fetch('pdk-version', nil).nil?
    nil
  else
    metadata['pdk-version'].split.first
  end
rescue ArgumentError => e
  PDK.logger.error(e)
  nil
end

.module_root ⇒ String?

Returns path to the root of the module being worked on.

Returns:

  • (String, nil) —

    Fully qualified base path to module, or nil if the current working dir does not appear to be within a module.



157
158
159
160
161
162
163
164
 
# File 'lib/pdk/util.rb', line 157

def module_root
  metadata_path = find_upwards('metadata.json')
  if metadata_path
    File.dirname(metadata_path)
  elsif in_module_root?
    Dir.pwd
  end
end

.package_cachedir ⇒ Object 



117
118
119
 
# File 'lib/pdk/util.rb', line 117

def package_cachedir
  File.join(pdk_package_basedir, 'share', 'cache')
end

.package_install? ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
92
93
 
# File 'lib/pdk/util.rb', line 89

def package_install?
  require 'pdk/util/version'

  !PDK::Util::Version.version_file.nil?
end

.pdk_package_basedir ⇒ Object

Raises:



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

def pdk_package_basedir
  raise PDK::CLI::FatalError, 'Package basedir requested for non-package install.' unless package_install?

  require 'pdk/util/version'

  File.dirname(PDK::Util::Version.version_file)
end

.system_configdir ⇒ Object 



143
144
145
146
147
148
149
150
 
# File 'lib/pdk/util.rb', line 143

def system_configdir
  return @system_configdir unless @system_configdir.nil?
  return @system_configdir = File.join(File::SEPARATOR, 'opt', 'puppetlabs', 'pdk', 'config') unless Gem.win_platform?

  return @system_configdir = File.join(PDK::Util::Env['ProgramData'], 'PuppetLabs', 'PDK') unless PDK::Util::Env['ProgramData'].nil?

  @system_configdir = File.join(PDK::Util::Env['AllUsersProfile'], 'PuppetLabs', 'PDK')
end

.targets_relative_to_pwd(targets) ⇒ Array<String>

Returns the targets’ paths relative to the working directory

Returns:

  • (Array<String>) —

    The absolute or path to the target



210
211
212
213
214
215
216
217
218
 
# File 'lib/pdk/util.rb', line 210

def targets_relative_to_pwd(targets)
  targets.map do |t|
    if Pathname.new(t).absolute?
      Pathname.new(t).relative_path_from(Pathname.pwd)
    else
      t
    end
  end
end