bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/functions/unwrap.rb

@@ -1,44 +0,0 @@
-# Unwraps a Sensitive value and returns the wrapped object.
-#
-# @example Usage of unwrap
-#
-# ```puppet
-# $plaintext = 'hunter2'
-# $pw = Sensitive.new($plaintext)
-# notice("Wrapped object is $pw") #=> Prints "Wrapped object is Sensitive [value redacted]"
-# $unwrapped = $pw.unwrap
-# notice("Unwrapped object is $unwrapped") #=> Prints "Unwrapped object is hunter2"
-# ```
-#
-# You can optionally pass a block to unwrap in order to limit the scope where the
-# unwrapped value is visible.
-#
-# @example Unwrapping with a block of code
-#
-# ```puppet
-# $pw = Sensitive.new('hunter2')
-# notice("Wrapped object is $pw") #=> Prints "Wrapped object is Sensitive [value redacted]"
-# $pw.unwrap |$unwrapped| {
-#   $conf = inline_template("password: ${unwrapped}\n")
-#   Sensitive.new($conf)
-# } #=> Returns a new Sensitive object containing an interpolated config file
-# # $unwrapped is now out of scope
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:unwrap) do
-  dispatch :unwrap do
-    param 'Sensitive', :arg
-    optional_block_param
-  end
-
-  def unwrap(arg)
-    unwrapped = arg.unwrap
-    if block_given?
-      yield(unwrapped)
-    else
-      unwrapped
-    end
-  end
-end

data/vendored/puppet/lib/puppet/functions/values.rb

@@ -1,25 +0,0 @@
-# Returns the values of a hash as an Array
-#
-# @example Using `values`
-#
-# ```puppet
-# $hsh = {"apples" => 3, "oranges" => 4 }
-# $hsh.values()
-# values($hsh)
-# # both results in the array [3, 4]
-# ```
-#
-# * Note that a hash in the puppet language accepts any data value (including `undef`) unless
-#   it is constrained with a `Hash` data type that narrows the allowed data types.
-# * For an empty hash, an empty array is returned.
-# * The order of the values is the same as the order in the hash (typically the order in which they were added).
-#
-Puppet::Functions.create_function(:values) do
-  dispatch :values do
-    param 'Hash', :hsh
-  end
-
-  def values(hsh)
-    hsh.values
-  end
-end

data/vendored/puppet/lib/puppet/functions/versioncmp.rb

@@ -1,36 +0,0 @@
-require 'puppet/util/package'
-
-# Compares two version numbers.
-#
-# Prototype:
-#
-#     \$result = versioncmp(a, b)
-#
-# Where a and b are arbitrary version strings.
-#
-# This function returns:
-#
-# * `1` if version a is greater than version b
-# * `0` if the versions are equal
-# * `-1` if version a is less than version b
-#
-# @example Using versioncmp
-#
-#     if versioncmp('2.6-1', '2.4.5') > 0 {
-#         notice('2.6-1 is > than 2.4.5')
-#     }
-#
-# This function uses the same version comparison algorithm used by Puppet's
-# `package` type.
-#
-Puppet::Functions.create_function(:versioncmp) do
-
-  dispatch :versioncmp do
-    param 'String', :a
-    param 'String', :b
-  end
-
-  def versioncmp(a, b)
-    Puppet::Util::Package.versioncmp(a, b)
-  end
-end

data/vendored/puppet/lib/puppet/functions/warning.rb

@@ -1,14 +0,0 @@
-# Logs a message on the server at level `notice`.
-Puppet::Functions.create_function(:warning, Puppet::Functions::InternalFunction) do
-  # @param values The values to log.
-  # @return [Undef]
-  dispatch :warning do
-    scope_param
-    repeated_param 'Any', :values
-    return_type 'Undef'
-  end
-
-  def warning(scope, *values)
-    Puppet::Util::Log.log_func(scope, :warning, values)
-  end
-end

data/vendored/puppet/lib/puppet/functions/with.rb

@@ -1,32 +0,0 @@
-# Calls a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
-# with the given arguments and returns the result.
-#
-# Since a lambda's scope is
-# [local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
-# to the lambda, you can use the `with` function to create private blocks of code within a
-# class using variables whose values cannot be accessed outside of the lambda.
-#
-# @example Using `with`
-#
-# ```puppet
-# # Concatenate three strings into a single string formatted as a list.
-# $fruit = with("apples", "oranges", "bananas") |$x, $y, $z| { 
-#   "${x}, ${y}, and ${z}" 
-# }
-# $check_var = $x
-# # $fruit contains "apples, oranges, and bananas"
-# # $check_var is undefined, as the value of $x is local to the lambda.
-# ```
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:with) do
-  dispatch :with do
-    repeated_param 'Any', :arg
-    block_param
-  end
-
-  def with(*args)
-    yield(*args)
-  end
-end

data/vendored/puppet/lib/puppet/functions/yaml_data.rb

@@ -1,42 +0,0 @@
-# The `yaml_data` is a hiera 5 `data_hash` data provider function.
-# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
-# how to use this function.
-#
-# @since 4.8.0
-#
-require 'yaml'
-
-Puppet::Functions.create_function(:yaml_data) do
-  dispatch :yaml_data do
-    param 'Struct[{path=>String[1]}]', :options
-    param 'Puppet::LookupContext', :context
-  end
-
-  argument_mismatch :missing_path do
-    param 'Hash', :options
-    param 'Puppet::LookupContext', :context
-  end
-
-  def yaml_data(options, context)
-    path = options['path']
-    context.cached_file_data(path) do |content|
-      begin
-        data = YAML.load(content, path)
-        if data.is_a?(Hash)
-          Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
-        else
-          Puppet.warning(_("%{path}: file does not contain a valid yaml hash" % { path: path }))
-          {}
-        end
-      rescue YAML::SyntaxError => ex
-        # Psych errors includes the absolute path to the file, so no need to add that
-        # to the message
-        raise Puppet::DataBinding::LookupError, "Unable to parse #{ex.message}"
-      end
-    end
-  end
-
-  def missing_path(options, context)
-    "one of 'path', 'paths' 'glob', 'globs' or 'mapped_paths' must be declared in hiera.yaml when using this data_hash function"
-  end
-end

data/vendored/puppet/lib/puppet/generate/models/type/property.rb

@@ -1,70 +0,0 @@
-module Puppet
-  module Generate
-    module Models
-      module Type
-        # A model for resource type properties and parameters.
-        class Property
-          # Gets the name of the property as a Puppet string literal.
-          attr_reader :name
-
-          # Gets the Puppet type of the property.
-          attr_reader :type
-
-          # Gets the doc string of the property.
-          attr_reader :doc
-
-          # Initializes a property model.
-          # @param property [Puppet::Property] The Puppet property to model.
-          # @return [void]
-          def initialize(property)
-            @name = Puppet::Pops::Types::StringConverter.convert(property.name.to_s, '%p')
-            @type = self.class.get_puppet_type(property)
-            @doc = property.doc.strip
-            @is_namevar = property.isnamevar?
-          end
-
-          # Determines if this property is a namevar.
-          # @return [Boolean] Returns true if the property is a namevar or false if not.
-          def is_namevar?
-            @is_namevar
-          end
-
-          # Gets the Puppet type for a property.
-          # @param property [Puppet::Property] The Puppet property to get the Puppet type for.
-          # @return [String] Returns the string representing the Puppet type.
-          def self.get_puppet_type(property)
-            # HACK: the value collection does not expose the underlying value information at all
-            #       thus this horribleness to get the underlying values hash
-            regexes = []
-            strings = []
-            values = property.value_collection.instance_variable_get('@values') || {}
-            values.each do |_, value|
-              if value.regex?
-                regexes << Puppet::Pops::Types::StringConverter.convert(value.name, '%p')
-                next
-              end
-
-              strings << Puppet::Pops::Types::StringConverter.convert(value.name.to_s, '%p')
-              value.aliases.each do |a|
-                strings << Puppet::Pops::Types::StringConverter.convert(a.to_s, '%p')
-              end
-            end
-
-            # If no string or regexes, default to Any type
-            return 'Any' if strings.empty? && regexes.empty?
-
-            # Calculate a variant of supported values
-            # Note that boolean strings are mapped to Variant[Boolean, Enum['true', 'false']]
-            # because of tech debt...
-            enum    = strings.empty? ? nil : "Enum[#{strings.join(', ')}]"
-            pattern = regexes.empty? ? nil : "Pattern[#{regexes.join(', ')}]"
-            boolean = strings.include?('\'true\'') || strings.include?('\'false\'') ? 'Boolean' : nil
-            variant = [boolean, enum, pattern].reject { |t| t.nil? }
-            return variant[0] if variant.size == 1
-            "Variant[#{variant.join(', ')}]"
-          end
-        end
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/generate/models/type/type.rb

@@ -1,62 +0,0 @@
-require 'puppet/generate/models/type/property'
-
-module Puppet
-  module Generate
-    module Models
-      module Type
-        # A model for Puppet resource types.
-        class Type
-          # Gets the name of the type as a Puppet string literal.
-          attr_reader :name
-
-          # Gets the doc string of the type.
-          attr_reader :doc
-
-          # Gets the properties of the type.
-          attr_reader :properties
-
-          # Gets the parameters of the type.
-          attr_reader :parameters
-
-          # Gets the title patterns of the type
-          attr_reader :title_patterns
-
-          # Gets the isomorphic member attribute of the type
-          attr_reader :isomorphic
-
-          # Gets the capability member attribute of the type
-          attr_reader :capability
-
-          # Initializes a type model.
-          # @param type [Puppet::Type] The Puppet type to model.
-          # @return [void]
-          def initialize(type)
-            @name = Puppet::Pops::Types::StringConverter.convert(type.name.to_s, '%p')
-            @doc = type.doc.strip
-            @properties = type.properties.map { |p| Property.new(p) }
-            @parameters = type.parameters.map do |name|
-              Property.new(type.paramclass(name))
-            end
-            sc = Puppet::Pops::Types::StringConverter.singleton
-            @title_patterns = Hash[type.title_patterns.map do |mapping|
-              [
-                sc.convert(mapping[0], '%p'),
-                sc.convert(mapping[1].map do |names|
-                  next if names.empty?
-                  raise Puppet::Error, _('title patterns that use procs are not supported.') unless names.size == 1
-                  names[0].to_s
-                end, '%p')
-              ]
-            end]
-            @isomorphic = type.isomorphic?
-            @capability = type.is_capability?
-          end
-
-          def render(template)
-            template.result(binding)
-          end
-        end
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/generate/type.rb

@@ -1,239 +0,0 @@
-require 'erb'
-require 'fileutils'
-require 'puppet/util/autoload'
-require 'puppet/generate/models/type/type'
-
-module Puppet
-  module Generate
-    # Responsible for generating type definitions in Puppet
-    class Type
-      # Represents an input to the type generator
-      class Input
-        # Gets the path to the input.
-        attr_reader :path
-
-        # Gets the format to use for generating the output file.
-        attr_reader :format
-
-        # Initializes an input.
-        # @param base [String] The base path where the input is located.
-        # @param path [String] The path to the input file.
-        # @param format [Symbol] The format to use for generation.
-        # @return [void]
-        def initialize(base, path, format)
-          @base = base
-          @path = path
-          self.format = format
-        end
-
-        # Gets the expected resource type name for the input.
-        # @return [Symbol] Returns the expected resource type name for the input.
-        def type_name
-          File.basename(@path, '.rb').to_sym
-        end
-
-        # Sets the format to use for this input.
-        # @param format [Symbol] The format to use for generation.
-        # @return [Symbol] Returns the new format.
-        def format=(format)
-          format = format.to_sym
-          raise _("unsupported format '%{format}'.") % { format: format } unless self.class.supported_format?(format)
-          @format = format
-        end
-
-        # Determines if the output file is up-to-date with respect to the input file.
-        # @param [String, nil] The path to output to, or nil if determined by input
-        # @return [Boolean] Returns true if the output is up-to-date or false if not.
-        def up_to_date?(outputdir)
-          f = effective_output_path(outputdir)
-          Puppet::FileSystem::exist?(f) && (Puppet::FileSystem::stat(@path) <=> Puppet::FileSystem::stat(f)) <= 0
-        end
-
-        # Gets the filename of the output file.
-        # @return [String] Returns the name to the output file.
-        def output_name
-          @output_name ||=
-            case @format
-            when :pcore
-              "#{File.basename(@path, '.rb')}.pp"
-            else
-              raise _("unsupported format '%{format}'.") % { format: @format }
-            end
-        end
-
-        # Gets the path to the output file.
-        # @return [String] Returns the path to the output file.
-        def output_path
-          @output_path ||=
-            case @format
-            when :pcore
-              File.join(@base, 'pcore', 'types', output_name)
-            else
-              raise _("unsupported format '%{format}'.") % { format: @format }
-            end
-        end
-
-        # Sets the path to the output file.
-        # @param path [String] The new path to the output file.
-        # @return [String] Returns the new path to the output file.
-        def output_path=(path)
-          @output_path = path
-        end
-
-        # Returns the outputpath to use given an outputdir that may be nil
-        # If outputdir is not nil, the returned path is relative to that outpudir
-        # otherwise determined by this input.
-        # @param [String, nil] The outputdirectory to use, or nil if to be determined by this Input
-        def effective_output_path(outputdir)
-          outputdir ? File.join(outputdir, output_name) : output_path
-        end
-
-        # Gets the path to the template to use for this input.
-        # @return [String] Returns the path to the template.
-        def template_path
-          File.join(File.dirname(__FILE__), 'templates', 'type', "#{@format}.erb")
-        end
-
-        # Gets the string representation of the input.
-        # @return [String] Returns the string representation of the input.
-        def to_s
-          @path
-        end
-
-        # Determines if the given format is supported
-        # @param format [Symbol] The format to use for generation.
-        # @return [Boolean] Returns true if the format is supported or false if not.
-        def self.supported_format?(format)
-          [:pcore].include?(format)
-        end
-      end
-
-      # Finds the inputs for the generator.
-      # @param format [Symbol] The format to use.
-      # @param environment [Puppet::Node::Environment] The environment to search for inputs. Defaults to the current environment.
-      # @return [Array<Input>] Returns the array of inputs.
-      def self.find_inputs(format = :pcore, environment = Puppet.lookup(:current_environment))
-        Puppet.debug "Searching environment '#{environment.name}' for custom types."
-        inputs = []
-        environment.modules.each do |mod|
-          directory = File.join(Puppet::Util::Autoload.cleanpath(mod.plugin_directory), 'puppet', 'type')
-          unless Puppet::FileSystem.exist?(directory)
-            Puppet.debug "Skipping '#{mod.name}' module because it contains no custom types."
-            next
-          end
-
-          Puppet.debug "Searching '#{mod.name}' module for custom types."
-          Dir.glob("#{directory}/*.rb") do |file|
-            next unless Puppet::FileSystem.file?(file)
-            Puppet.debug "Found custom type source file '#{file}'."
-            inputs << Input.new(mod.path, file, format)
-          end
-        end
-
-        # Sort the inputs by path
-        inputs.sort_by! { |input| input.path }
-      end
-
-      # Generates files for the given inputs.
-      # If a file is up to date (newer than input) it is kept.
-      # If a file is out of date it is regenerated.
-      # If there is a file for a non existing output in a given output directory it is removed.
-      # If using input specific output removal must be made by hand if input is removed.
-      #
-      # @param inputs [Array<Input>] The inputs to generate files for.
-      # @param outputdir [String, nil] the outputdir where all output should be generated, or nil if next to input
-      # @param force [Boolean] True to force the generation of the output files (skip up-to-date checks) or false if not.
-      # @return [void]
-      def self.generate(inputs, outputdir = nil, force = false)
-        # remove files for non existing inputs
-        unless outputdir.nil?
-          filenames_to_keep = inputs.map {|i| i.output_name }
-          existing_files = Puppet::FileSystem.children(outputdir).map {|f| Puppet::FileSystem.basename(f) }
-          files_to_remove = existing_files - filenames_to_keep
-          files_to_remove.each do |f|
-            Puppet::FileSystem.unlink(File.join(outputdir, f))
-          end
-          Puppet.notice(_("Removed output '%{files_to_remove}' for non existing inputs") % { files_to_remove: files_to_remove }) unless files_to_remove.empty?
-        end
-
-        if inputs.empty?
-          Puppet.notice _('No custom types were found.')
-          return nil
-        end
-
-        templates = {}
-        templates.default_proc = lambda { |hash, key|
-          raise _("template was not found at '%{key}'.") % { key: key } unless Puppet::FileSystem.file?(key)
-          template = ERB.new(File.read(key), nil, '-')
-          template.filename = key
-          template
-        }
-
-        up_to_date = true
-        Puppet.notice _('Generating Puppet resource types.')
-        inputs.each do |input|
-          if !force && input.up_to_date?(outputdir)
-            Puppet.debug "Skipping '#{input}' because it is up-to-date."
-            next
-          end
-
-          up_to_date = false
-
-          type_name = input.type_name
-          Puppet.debug "Loading custom type '#{type_name}' in '#{input}'."
-          begin
-            require input.path
-          rescue SystemExit
-            raise
-          rescue Exception => e
-            # Log the exception and move on to the next input
-            Puppet.log_exception(e, _("Failed to load custom type '%{type_name}' from '%{input}': %{message}") % { type_name: type_name, input: input, message: e.message })
-            next
-          end
-
-          # HACK: there's no way to get a type without loading it (sigh); for now, just get the types hash directly
-          types ||= Puppet::Type.instance_variable_get('@types')
-
-          # Assume the type follows the naming convention
-          unless type = types[type_name]
-            Puppet.err _("Custom type '%{type_name}' was not defined in '%{input}'.") % { type_name: type_name, input: input }
-            next
-          end
-
-          # Create the model
-          begin
-            model = Models::Type::Type.new(type)
-          rescue Exception => e
-            # Move on to the next input
-            Puppet.log_exception(e, "#{input}: #{e.message}")
-            next
-          end
-
-          # Render the template
-          begin
-            result = model.render(templates[input.template_path])
-          rescue Exception => e
-            Puppet.log_exception(e)
-            raise
-          end
-
-          # Write the output file
-          begin
-            effective_output_path = input.effective_output_path(outputdir)
-            Puppet.notice _("Generating '%{effective_output_path}' using '%{format}' format.") % { effective_output_path: effective_output_path, format: input.format }
-            FileUtils.mkdir_p(File.dirname(effective_output_path))
-            Puppet::FileSystem.open(effective_output_path, nil, 'w:UTF-8') do |file|
-              file.write(result)
-            end
-          rescue Exception => e
-            Puppet.log_exception(e, _("Failed to generate '%{effective_output_path}': %{message}") % { effective_output_path: effective_output_path, message: e.message })
-            # Move on to the next input
-            next
-          end
-        end
-
-        Puppet.notice _('No files were generated because all inputs were up-to-date.') if up_to_date
-      end
-    end
-  end
-end