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/ruby_version.rb,
lib/pdk/util/template_uri.rb,
lib/pdk/util/vendored_file.rb,
lib/pdk/util/puppet_strings.rb,
lib/pdk/util/puppet_version.rb,
lib/pdk/util/changelog_generator.rb

Defined Under Namespace

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

Constant Summary collapse

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

Class Method Summary collapse

Instance 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.



131
132
133
134
135
136
137
 
# File 'lib/pdk/util.rb', line 131

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



84
85
86
87
88
89
90
91
92
93
 
# File 'lib/pdk/util.rb', line 84

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

.configdir ⇒ Object 



140
141
142
143
144
145
146
 
# File 'lib/pdk/util.rb', line 140

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

.development_mode? ⇒ Boolean

Returns:

  • (Boolean) 


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

def development_mode?
  require 'pdk/util/version'

  (!PDK::Util::Version.git_ref.nil? || PDK::VERSION.end_with?('.pre'))
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



199
200
201
 
# File 'lib/pdk/util.rb', line 199

def find_all_json_in(text)
  find_valid_json_in(text, break_on_first: false)
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



189
190
191
 
# File 'lib/pdk/util.rb', line 189

def find_first_json_in(text)
  find_valid_json_in(text)
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.



52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/pdk/util.rb', line 52

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

.find_valid_json_in(text, opts = {}) ⇒ 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

  • opts (Hash) (defaults to: {}) —

    options

Options Hash (opts):

  • :break_on_first (Boolean) —

    Whether or not to break after valid JSON is found, defaults to true

Returns:

  • (Hash, Array<Hash>, nil) —

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



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/pdk/util.rb', line 214

def find_valid_json_in(text, opts = {})
  break_on_first = opts.key?(:break_on_first) ? opts[:break_on_first] : true

  json_result = break_on_first ? nil : []

  text.scan(%r{\{(?:[^{}]|(?:\g<0>))*\}}x) do |str|
    begin
      if break_on_first
        json_result = JSON.parse(str)
        break
      else
        json_result.push(JSON.parse(str))
      end
    rescue JSON::ParserError
      next
    end
  end

  json_result
end

.gem_install? ⇒ Boolean

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/pdk/util.rb', line 110

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.



179
180
181
 
# File 'lib/pdk/util.rb', line 179

def in_module_root?(path = Dir.pwd)
  PDK::Util::MODULE_FOLDERS.any? { |dir| PDK::Util::Filesystem.directory?(File.join(path, dir)) }
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.



70
71
72
73
74
75
76
 
# File 'lib/pdk/util.rb', line 70

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



167
168
169
170
 
# File 'lib/pdk/util.rb', line 167

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

.module_metadata ⇒ Object

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



251
252
253
254
255
 
# File 'lib/pdk/util.rb', line 251

def module_metadata
  require 'pdk/module/metadata'

  PDK::Module::Metadata.from_file(File.join(module_root, 'metadata.json')).data
end

.module_pdk_compatible? ⇒ Boolean

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

Returns:

  • (Boolean) 


259
260
261
 
# File 'lib/pdk/util.rb', line 259

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

.module_pdk_version ⇒ Object 



264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/pdk/util.rb', line 264

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.



153
154
155
156
157
158
159
160
161
162
 
# File 'lib/pdk/util.rb', line 153

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

.package_cachedir ⇒ Object 



123
124
125
 
# File 'lib/pdk/util.rb', line 123

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

.package_install? ⇒ Boolean

Returns:

  • (Boolean) 


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

def package_install?
  require 'pdk/util/version'

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

.pdk_package_basedir ⇒ Object

Raises:



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

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

.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



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

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

Instance Method Details

#exit_process(exit_code) ⇒ Object

Calls Kernel.exit with an exitcode



40
41
42
 
# File 'lib/pdk/util.rb', line 40

def exit_process(exit_code)
  exit exit_code
end