puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/functions/strftime.rb

@@ -0,0 +1,35 @@
+# (Documentation in 3.x stub)
+#
+# @since 4.8.0
+#
+Puppet::Functions.create_function(:strftime) do
+  dispatch :format_timespan do
+    param 'Timespan', :time_object
+    param 'String', :format
+  end
+
+  dispatch :format_timestamp do
+    param 'Timestamp', :time_object
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  dispatch :legacy_strftime do
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  def format_timespan(time_object, format)
+    time_object.format(format)
+  end
+
+  def format_timestamp(time_object, format, timezone = nil)
+    time_object.format(format, timezone)
+  end
+
+  def legacy_strftime(format, timezone = nil)
+    Puppet.warn_once('deprecation', 'legacy#strftime',
+      'The argument signature (String format, [String timezone]) is deprecated for #strfime. See #strftime documentation and Timespan type for more info')
+    Puppet::Pops::Time::Timestamp.format_time(format, Time.now.utc, timezone)
+  end
+end

data/vendor/pup410/lib/puppet/functions/then.rb

@@ -0,0 +1,14 @@
+# (Documented in 3.x stub)
+# @since 4.5.0
+#
+Puppet::Functions.create_function(:then) do
+  dispatch :then do
+    param 'Any', :arg
+    block_param 'Callable[1,1]', :block
+  end
+
+  def then(arg)
+    return nil if arg.nil?
+    yield(arg)
+  end
+end

data/vendor/pup410/lib/puppet/functions/type.rb

@@ -0,0 +1,31 @@
+# (Documentation in 3.x stub)
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:type) do
+  dispatch :type_detailed do
+    param 'Any', :value
+    optional_param 'Enum[detailed]', :inference_method
+  end
+
+  dispatch :type_parameterized do
+    param 'Any', :value
+    param 'Enum[reduced]', :inference_method
+  end
+
+  dispatch :type_generalized do
+    param 'Any', :value
+    param 'Enum[generalized]', :inference_method
+  end
+
+  def type_detailed(value, _ = nil)
+    Puppet::Pops::Types::TypeCalculator.infer_set(value)
+  end
+
+  def type_parameterized(value, _)
+    Puppet::Pops::Types::TypeCalculator.infer(value)
+  end
+
+  def type_generalized(value, _)
+    Puppet::Pops::Types::TypeCalculator.infer(value).generalize
+  end
+end

data/vendor/pup410/lib/puppet/functions/unwrap.rb

@@ -0,0 +1,40 @@
+# Unwraps a Sensitive value and returns the wrapped object.
+#
+# ~~~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.
+#
+# ~~~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/vendor/pup410/lib/puppet/functions/warning.rb

@@ -0,0 +1,14 @@
+# Log 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/vendor/pup410/lib/puppet/functions/yaml_data.rb

@@ -0,0 +1,42 @@
+# 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")
+          {}
+        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/vendor/pup410/lib/puppet/generate/models/type/property.rb

@@ -0,0 +1,70 @@
+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/vendor/pup410/lib/puppet/generate/models/type/type.rb

@@ -0,0 +1,62 @@
+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/vendor/pup410/lib/puppet/generate/templates/type/pcore.erb

@@ -0,0 +1,42 @@
+# This file was automatically generated on <%= Time.now %>.
+# Use the 'puppet generate types' command to regenerate this file.
+
+<%- unless doc.empty? -%>
+  <%- doc.each_line do |line| -%>
+# <%= line -%>
+  <%- end %>
+<%- end -%>
+Puppet::Resource::ResourceType3.new(
+  <%= name %>,
+  [
+<%- properties.each_with_index do |property, index| -%>
+  <%- unless property.doc.empty? -%>
+    <%- property.doc.each_line do |line| -%>
+    # <%= line -%>
+    <%- end %>
+  <%- end -%>
+    Puppet::Resource::Param(<%= property.type %>, <%= property.name %><% if property.is_namevar? %>, true<% end %>)<% if index + 1 < properties.size %>,
+
+    <%- end -%>
+<%- end %>
+  ],
+  [
+<%- parameters.each_with_index do |parameter, index| -%>
+  <%- unless parameter.doc.empty? -%>
+    <%- parameter.doc.each_line do |line| -%>
+    # <%= line -%>
+    <%- end %>
+  <%- end -%>
+    Puppet::Resource::Param(<%= parameter.type %>, <%= parameter.name %><% if parameter.is_namevar? %>, true<% end %>)<% if index + 1 < parameters.size %>,
+
+    <%- end -%>
+<%- end %>
+  ],
+  {
+<%- title_patterns.each_with_index do |mapping, index| -%>
+    <%= mapping[0] %> => <%= mapping[1] %><%= "," if index + 1 < title_patterns.size %>
+<%- end -%>
+  },
+  <%= isomorphic -%>,
+  <%= capability -%>
+)

data/vendor/pup410/lib/puppet/generate/type.rb

@@ -0,0 +1,239 @@
+require 'erb'
+require 'fileutils'
+require 'puppet/util/autoload'
+require 'puppet/generate/models/type/type'
+
+module Puppet
+  module Generate
+    # Reponsible 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}'." 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}'."
+            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}'."
+            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") 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}'." 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}': #{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}'."
+            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 '#{input.format}' 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}': #{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