bolt 0.24.0 → 0.25.0

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

@@ -1,43 +0,0 @@
-# The `yaml_data` is a hiera 5 `data_hash` data provider function.
-# See [the configuration guide documentation](https://puppet.com/docs/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 = Puppet::Util::Yaml.safe_load(content, [Symbol], path)
-        if data.is_a?(Hash)
-          Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
-        else
-          msg = _("%{path}: file does not contain a valid yaml hash" % { path: path })
-          raise Puppet::DataBinding::LookupError, msg if Puppet[:strict] == :error && data != false
-          Puppet.warning(msg)
-          {}
-        end
-      rescue Puppet::Util::Yaml::YamlLoadError => ex
-        # YamlLoadErrors include the absolute path to the file, so no need to add that
-        raise Puppet::DataBinding::LookupError, _("Unable to parse %{message}") % { message: 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

data/vendored/puppet/lib/puppet/gettext/config.rb

@@ -1,275 +0,0 @@
-require 'puppet/util/platform'
-require 'puppet/file_system'
-
-module Puppet::GettextConfig
-  LOCAL_PATH = File.absolute_path('../../../locales', File.dirname(__FILE__))
-  POSIX_PATH = File.absolute_path('../../../../../share/locale', File.dirname(__FILE__))
-  WINDOWS_PATH = File.absolute_path('../../../../../../puppet/share/locale', File.dirname(__FILE__))
-
-  # This is the only domain name that won't be a symbol, making it unique from environments.
-  DEFAULT_TEXT_DOMAIN = 'default-text-domain'
-
-  # Load gettext helpers and track whether they're available.
-  # Used instead of features because we initialize gettext before features is available.
-  begin
-    require 'fast_gettext'
-    require 'locale'
-
-    # Make translation methods (e.g. `_()` and `n_()`) available everywhere.
-    class ::Object
-      include FastGettext::Translation
-    end
-
-    @gettext_loaded = true
-  rescue LoadError
-    # Stub out gettext's `_` and `n_()` methods, which attempt to load translations,
-    # with versions that do nothing
-    require 'puppet/gettext/stubs'
-    @gettext_loaded = false
-  end
-
-  # @api private
-  # Whether we were able to require fast_gettext and locale
-  # @return [Boolean] true if translation gems were successfully loaded
-  def self.gettext_loaded?
-    @gettext_loaded
-  end
-
-  # @api private
-  # Returns the currently selected locale from FastGettext,
-  # or 'en' of gettext has not been loaded
-  # @return [String] the active locale
-  def self.current_locale
-    if gettext_loaded?
-      return FastGettext.default_locale
-    else
-      return 'en'
-    end
-  end
-
-  # @api private
-  # Returns a list of the names of the loaded text domains
-  # @return [[String]] the names of the loaded text domains
-  def self.loaded_text_domains
-    return [] if @gettext_disabled || !gettext_loaded?
-
-    return FastGettext.translation_repositories.keys
-  end
-
-  # @api private
-  # Clears the translation repository for the given text domain,
-  # creating it if it doesn't exist, then adds default translations
-  # and switches to using this domain.
-  # @param [String, Symbol] domain_name the name of the domain to create
-  def self.reset_text_domain(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-    domain_name = domain_name.to_sym
-
-    Puppet.debug "Reset text domain to #{domain_name.inspect}"
-    FastGettext.add_text_domain(domain_name,
-                                type: :chain,
-                                chain: [],
-                                report_warning: false)
-    copy_default_translations(domain_name)
-    FastGettext.text_domain = domain_name
-  end
-
-  # @api private
-  # Resets the thread's configured text_domain to the default text domain.
-  # In Puppet Server, thread A may process a compile request that configures
-  # a domain, while thread B may invalidate that environment and delete the
-  # domain. That leaves thread A with an invalid text_domain selected.
-  # To avoid that, clear_text_domain after any processing that needs the
-  # non-default text domain.
-  def self.clear_text_domain
-    return if @gettext_disabled || !gettext_loaded?
-    FastGettext.text_domain = nil
-  end
-
-  # @api private
-  # Creates a default text domain containing the translations for
-  # Puppet as the start of chain. When semantic_puppet gets initialized,
-  # its translations are added to this chain. This is used as a cache
-  # so that all non-module translations only need to be loaded once as
-  # we create and reset environment-specific text domains.
-  #
-  # @return true if Puppet translations were successfully loaded, false
-  # otherwise
-  def self.create_default_text_domain
-    return if @gettext_disabled || !gettext_loaded?
-
-    FastGettext.add_text_domain(DEFAULT_TEXT_DOMAIN,
-                                type: :chain,
-                                chain: [],
-                                report_warning: false)
-    FastGettext.default_text_domain = DEFAULT_TEXT_DOMAIN
-
-    load_translations('puppet', puppet_locale_path, translation_mode(puppet_locale_path), DEFAULT_TEXT_DOMAIN)
-  end
-
-  # @api private
-  # Switches the active text domain, if the requested domain exists.
-  # @param [String, Symbol] domain_name the name of the domain to switch to
-  def self.use_text_domain(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-    domain_name = domain_name.to_sym
-
-    if FastGettext.translation_repositories.include?(domain_name)
-      Puppet.debug "Use text domain #{domain_name.inspect}"
-      FastGettext.text_domain = domain_name
-    else
-      Puppet.debug "Requested unknown text domain #{domain_name.inspect}"
-    end
-  end
-
-  # @api private
-  # Delete all text domains.
-  def self.delete_all_text_domains
-    FastGettext.translation_repositories.clear
-    FastGettext.default_text_domain = nil
-    FastGettext.text_domain = nil
-  end
-
-  # @api private
-  # Deletes the text domain with the given name
-  # @param [String, Symbol] domain_name the name of the domain to delete
-  def self.delete_text_domain(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-    domain_name = domain_name.to_sym
-
-    deleted = FastGettext.translation_repositories.delete(domain_name)
-    if FastGettext.text_domain == domain_name
-      Puppet.debug "Deleted current text domain #{domain_name.inspect}: #{!deleted.nil?}"
-      FastGettext.text_domain = nil
-    else
-      Puppet.debug "Deleted text domain #{domain_name.inspect}: #{!deleted.nil?}"
-    end
-  end
-
-  # @api private
-  # Deletes all text domains except the default one
-  def self.delete_environment_text_domains
-    return if @gettext_disabled || !gettext_loaded?
-
-    FastGettext.translation_repositories.keys.each do |key|
-      # do not clear default translations
-      next if key == DEFAULT_TEXT_DOMAIN
-
-      FastGettext.translation_repositories.delete(key)
-    end
-    FastGettext.text_domain = nil
-  end
-
-  # @api private
-  # Adds translations from the default text domain to the specified
-  # text domain. Creates the default text domain if one does not exist
-  # (this will load Puppet's translations).
-  #
-  # Since we are currently (Nov 2017) vendoring semantic_puppet, in normal
-  # flows these translations will be copied along with Puppet's.
-  #
-  # @param [Symbol] domain_name the name of the domain to add translations to
-  def self.copy_default_translations(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-
-    if FastGettext.default_text_domain.nil?
-      create_default_text_domain
-    end
-
-    puppet_translations = FastGettext.translation_repositories[FastGettext.default_text_domain].chain
-    FastGettext.translation_repositories[domain_name].chain.push(*puppet_translations)
-  end
-
-  # @api private
-  # Search for puppet gettext config files
-  # @return [String] path to the config, or nil if not found
-  def self.puppet_locale_path
-    if Puppet::FileSystem.exist?(LOCAL_PATH)
-      return LOCAL_PATH
-    elsif Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(WINDOWS_PATH)
-      return WINDOWS_PATH
-    elsif !Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(POSIX_PATH)
-      return POSIX_PATH
-    else
-      nil
-    end
-  end
-
-  # @api private
-  # Determine which translation file format to use
-  # @param [String] conf_path the path to the gettext config file
-  # @return [Symbol] :mo if in a package structure, :po otherwise
-  def self.translation_mode(conf_path)
-    if WINDOWS_PATH == conf_path || POSIX_PATH == conf_path
-      return :mo
-    else
-      return :po
-    end
-  end
-
-  # @api private
-  # Prevent future gettext initializations
-  def self.disable_gettext
-    @gettext_disabled = true
-  end
-
-  # @api private
-  # Attempt to load translations for the given project.
-  # @param [String] project_name the project whose translations we want to load
-  # @param [String] locale_dir the path to the directory containing translations
-  # @param [Symbol] file_format translation file format to use, either :po or :mo
-  # @return true if initialization succeeded, false otherwise
-  def self.load_translations(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
-    if project_name.nil? || project_name.empty?
-      raise Puppet::Error, "A project name must be specified in order to initialize translations."
-    end
-
-    return false if @gettext_disabled || !@gettext_loaded
-
-    return false unless locale_dir && Puppet::FileSystem.exist?(locale_dir)
-
-    unless file_format == :po || file_format == :mo
-      raise Puppet::Error, "Unsupported translation file format #{file_format}; please use :po or :mo"
-    end
-
-    add_repository_to_domain(project_name, locale_dir, file_format, text_domain)
-    return true
-  end
-
-  # @api private
-  # Add the translations for this project to the domain's repository chain
-  # chain for the currently selected text domain, if needed.
-  # @param [String] project_name the name of the project for which to load translations
-  # @param [String] locale_dir the path to the directory containing translations
-  # @param [Symbol] file_format the format of the translations files, :po or :mo
-  def self.add_repository_to_domain(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
-    return if @gettext_disabled || !gettext_loaded?
-
-    current_chain = FastGettext.translation_repositories[text_domain].chain
-
-    repository = FastGettext::TranslationRepository.build(project_name,
-                                                          path: locale_dir,
-                                                          type: file_format,
-                                                          report_warning: false)
-    current_chain << repository
-  end
-
-  # @api private
-  # Sets FastGettext's locale to the current system locale
-  def self.setup_locale
-    return if @gettext_disabled || !gettext_loaded?
-
-    set_locale(Locale.current.language)
-  end
-
-  # @api private
-  # Sets the language in which to display strings.
-  # @param [String] locale the language portion of a locale string (e.g. "ja")
-  def self.set_locale(locale)
-    return if @gettext_disabled || !gettext_loaded?
-    # make sure we're not using the `available_locales` machinery
-    FastGettext.default_available_locales = nil
-
-    FastGettext.default_locale = locale
-  end
-end