bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/pops/puppet_stack.rb

@@ -1,57 +0,0 @@
-module Puppet::Pops
-# Module for making a call such that there is an identifiable entry on
-# the ruby call stack enabling getting a puppet call stack
-# To use this make a call with:
-# ```
-# Puppet::Pops::PuppetStack.stack(file, line, receiver, message, args)
-# ```
-# To get the stack call:
-# ```
-# Puppet::Pops::PuppetStack.stacktrace
-#
-# When getting a backtrace in Ruby, the puppet stack frames are
-# identified as coming from "in 'stack'" and having a ".pp" file
-# name.
-# To support testing, a given file that is an empty string, or nil
-# as well as a nil line number are supported. Such stack frames
-# will be represented with the text `unknown` and `0´ respectively.
-#
-module PuppetStack
-  # Pattern matching an entry in the ruby stack that is a puppet entry
-  PP_ENTRY_PATTERN = /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function'|`<eval>')/
-
-  # Sends a message to an obj such that it appears to come from
-  # file, line when calling stacktrace.
-  #
-  def self.stack(file, line, obj, message, args, &block)
-    file = '' if file.nil?
-    line = 0 if line.nil?
-
-    if block_given?
-      Kernel.eval("obj.send(message, *args, &block)", Kernel.binding(), file, line)
-    else
-      Kernel.eval("obj.send(message, *args)", Kernel.binding(), file, line)
-    end
-  end
-
-  def self.stacktrace
-    caller().reduce([]) do |memo, loc|
-      if loc =~ PP_ENTRY_PATTERN
-        memo << [$1.nil? ? 'unknown' : $1, $2.to_i]
-      end
-      memo
-    end
-  end
-
-  # Returns an Array with the top of the puppet stack, or an empty Array if there was no such entry.
-  #
-  def self.top_of_stack
-    caller.each do |loc|
-      if loc =~ PP_ENTRY_PATTERN
-        return [$1.nil? ? 'unknown' : $1, $2.to_i]
-      end
-    end
-    []
-  end
-end
-end

data/vendored/puppet/lib/puppet/pops/resource/param.rb

@@ -1,55 +0,0 @@
-# An implementation of the interface Puppet::Resource
-# that adapts the 3.x compiler and catalog expectations on
-# a resource instance. This instance is backed by a
-# pcore representation of the resource type an instance of this
-# ruby class.
-#
-# This class must inherit from Puppet::Resource because of the
-# class expectations in existing logic.
-#
-# This implementation does not support
-# * setting 'strict' - strictness (must refer to an existing type) is always true
-# * does not support the indirector
-#
-#
-module Puppet::Pops
-module Resource
-class Param
-  # This make this class instantiable from Puppet
-  include Puppet::Pops::Types::PuppetObject
-
-  def self.register_ptype(loader, ir)
-    @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::Param', nil,
-      {
-        Types::KEY_TYPE => Types::PTypeType::DEFAULT,
-        Types::KEY_NAME => Types::PStringType::NON_EMPTY,
-        'name_var' => {
-          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
-          Types::KEY_VALUE => false
-        }
-      },
-      EMPTY_HASH,
-      [Types::KEY_NAME]
-    )
-  end
-
-  attr_reader :name
-  attr_reader :type
-  attr_reader :name_var
-
-  def initialize(type, name, name_var = false)
-    @type = type
-    @name = name
-    @name_var = name_var
-  end
-
-  def to_s
-    name
-  end
-
-  def self._pcore_type
-    @ptype
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/resource/resource_type_impl.rb

@@ -1,314 +0,0 @@
-require_relative 'param'
-
-module Puppet::Pops
-module Resource
-
-def self.register_ptypes(loader, ir)
-  types = [Param, ResourceTypeImpl].map do |c|
-    c.register_ptype(loader, ir)
-  end
-  types.each {|t| t.resolve(loader) }
-end
-
-class ResourceTypeImpl
-  # Make instances of this class directly creatable from the Puppet Language
-  # as object.
-  #
-  include Puppet::Pops::Types::PuppetObject
-
-  # Instances of ResourceTypeImpl can be used as the type of a Puppet::Parser::Resource/Puppet::Resource when compiling
-  #
-  include Puppet::CompilableResourceType
-
-  # Returns the Puppet Type for this instance.
-  def self._pcore_type
-    @ptype
-  end
-
-  def self.register_ptype(loader, ir)
-    param_ref = Types::PTypeReferenceType.new('Puppet::Resource::Param')
-    @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::ResourceType3', nil,
-      {
-        Types::KEY_NAME => Types::PStringType::NON_EMPTY,
-        'properties' => {
-          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
-          Types::KEY_VALUE => EMPTY_ARRAY
-        },
-        'parameters' => {
-          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
-          Types::KEY_VALUE => EMPTY_ARRAY
-        },
-        'title_patterns_hash' => {
-          Types::KEY_TYPE => Types::POptionalType.new(
-            Types::PHashType.new(Types::PRegexpType::DEFAULT, Types::PArrayType.new(Types::PStringType::NON_EMPTY))),
-          Types::KEY_VALUE => nil
-        },
-        'isomorphic' => {
-          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
-          Types::KEY_VALUE => true
-        },
-        'capability' => {
-          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
-          Types::KEY_VALUE => false
-        },
-      },
-      EMPTY_HASH,
-      [Types::KEY_NAME]
-    )
-  end
-
-  def eql?(other)
-    other.is_a?(Puppet::CompilableResourceType) && @name == other.name
-  end
-  alias == eql?
-
-  # Compares this type against the given _other_ (type) and returns -1, 0, or +1 depending on the order.
-  # @param other [Object] the object to compare against (produces nil, if not kind of Type}
-  # @return [-1, 0, +1, nil] produces -1 if this type is before the given _other_ type, 0 if equals, and 1 if after.
-  #   Returns nil, if the given _other_ is not a kind of Type.
-  # @see Comparable
-  #
-  def <=>(other)
-    # Order is only maintained against other types, not arbitrary objects.
-    # The natural order is based on the reference name used when comparing
-    return nil unless other.is_a?(Puppet::CompilableResourceType)
-    # against other type instances.
-    self.ref <=> other.ref
-  end
-
-  METAPARAMS = [
-    :noop,
-    :schedule,
-    :audit,
-    :loglevel,
-    :alias,
-    :tag,
-    :require,
-    :subscribe,
-    :before,
-    :notify,
-    :stage,
-    :export,
-    :consume
-    ].freeze
-
-  # Speed up lookup
-  METAPARAMSET = Set.new(METAPARAMS).freeze
-
-  attr_reader :name
-  attr_reader :properties
-  attr_reader :parameters
-  attr_reader :title_patterns_hash
-  attr_reader :title_patterns
-
-  def initialize(name, properties = EMPTY_ARRAY, parameters = EMPTY_ARRAY, title_patterns_hash = nil, isomorphic = true, capability = false)
-    @name = name
-    @properties = properties
-    @parameters = parameters
-    @title_patterns_hash = title_patterns_hash
-    @isomorphic = isomorphic
-    @capability = capability
-
-    # Compute attributes hash
-    # Compute key_names (possibly compound key if there are multiple name vars).
-    @attributes = {}
-    @key_attributes = []
-
-    # Name to kind of attribute
-    @attr_types = {}
-
-    # Add all meta params
-    METAPARAMS.each {|p| @attr_types[p] = :meta }
-
-    @property_set = Set.new(properties.map do |p|
-      symname = p.name.to_sym
-      @attributes[symname] = p
-      @key_attributes << symname if p.name_var
-      @attr_types[symname] = :property
-      symname
-    end).freeze
-
-    @param_set = Set.new(parameters.map do |p|
-      symname = p.name.to_sym
-      @attributes[symname] = p
-      @key_attributes << symname if p.name_var
-      @attr_types[symname] = :param
-      symname
-    end).freeze
-
-    # API for title patterns is [ [regexp, [ [ [sym, <lambda>], [sym, <lambda>] ] ] ] ]
-    # Where lambdas are optional. This resource type impl does not support lambdas
-    # Note that the pcore file has a simpler hashmap that is post processed here
-    # since the structure must have Symbol instances for names which the .pp representation
-    # does not deliver.
-    #
-    @title_patterns =
-      case @key_attributes.length
-      when 0
-        # TechDebt: The case of specifying title patterns when having no name vars is unspecified behavior in puppet
-        # Here it is silently ignored.
-        nil
-      when 1
-        if @title_patterns_hash.nil?
-          [ [ /(.*)/m, [ [@key_attributes.first] ] ] ]
-        else
-          # TechDebt: The case of having one namevar and an empty title patterns is unspecified behavior in puppet.
-          # Here, it may lead to an empty map which may or may not trigger the wanted/expected behavior.
-          #
-          @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym ] } ] }
-        end
-      else
-        if @title_patterns_hash.nil? || @title_patterns_hash.empty?
-          # TechDebt: While title patterns must be specified when more than one is used, they do not have
-          # to match/set them all since some namevars can be omitted (to support the use case in
-          # the 'package' type where 'provider' attribute is handled as part of the key without being
-          # set from the title.
-          #
-          raise Puppet::DevError, _("you must specify title patterns when there are two or more key attributes")
-        end
-        @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym] } ] }
-      end
-  end
-
-  # Override CompilableResource inclusion
-  def is_3x_ruby_plugin?
-    false
-  end
-
-  def is_capability?
-    @capability
-  end
-
-  # Answers if the parameter name is a parameter/attribute of this type
-  # This is part of the Puppet::Type API
-  # Check if used when compiling (it is triggered in an apply)
-  #
-  def valid_parameter?(name)
-    @attributes.include?(name) || METAPARAMSET.include?(name)
-  end
-
-  # The type implementation of finish does a lot of things
-  # * iterates over all parameters and calls post_compile on them if the parameter impl responds to post_compile
-  # * validates the relationship parameters
-  #
-  # This implementation does nothing - it is assumed that the catalog is already validated
-  # via the relationship validator (done late in the game).
-  def finish()
-    # Do nothing.
-  end
-
-  # This is called on a resource type
-  # it performs tagging if it is a Class or Node.
-  # It also ensure the parent type is in the catalog, but that is weird since
-  # resource types cannot really inherit
-  def instantiate_resource(scope, resource)
-    # Do nothing because nothing is needed when compiling.
-
-    # This is what the Puppet::Type implementation does
-    # None of this should be needed
-
-      #    # Make sure our parent class has been evaluated, if we have one.
-      #    if parent && !scope.catalog.resource(resource.type, parent)
-      #      parent_type(scope).ensure_in_catalog(scope)
-      #    end
-
-    # This will never happen
-
-      #    if ['Class', 'Node'].include? resource.type
-      #      scope.catalog.tag(*resource.tags)
-      #    end
-  end
-
-  # Being isomorphic in puppet means that the resource is managing a state
-  # (as opposed to a resource like Exec that is a function, possibly with side effect.
-  # In a Ruby implementation of a resource type, @isomorphic = false is used to turn
-  # off isomorphism, it is true by default.
-  # This is part of the Puppet::Type API.
-  #
-  def isomorphic?
-    @isomorphic
-  end
-
-  # Produces the names of the attributes that make out the unique id of a resource
-  #
-  def key_attributes
-    @key_attributes
-  end
-
-  # Gives a type a chance to issue deprecations for parameters.
-  # @param title [String] the title of the resource of this type
-  # @param attributes [Array<Param>] the set parameters in the resource instance
-  def deprecate_params(title, attributes)
-    # TODO: Current API somewhat unclear, if done at type level, or per
-    #       Param.
-  end
-
-  #######################
-  # UNSUPPORTED STUFF
-  #######################
-
-  # Applications are not supported
-  def application?
-    false
-  end
-
-  ############################
-  # DON'T KNOW YET
-  ############################
-
-
-  ##################################################
-  # NEVER CALLED COMPILE SIDE FOR A COMPILATION
-  ##################################################
-
-  # Answers :property, :param or :meta depending on the type of the attribute
-  # According to original version, this is called millions of times
-  # and a cache is required.
-  # @param name [Symbol]
-  def attrtype(name)
-    raise NotImplementedError, "attrtype() - returns the kind (:meta, :param, or :property) of the parameter"
-    # @attr_types[name]
-  end
-
-  # Returns the implementation of a param/property/attribute - i.e. a Param class
-  def attrclass(name)
-    raise NotImplementedError, "attrclass() - returns the (param) class of the parameter"
-  end
-
-  # PROBABLY NOT USED WHEN COMPILING
-  # Returns the names of all attributes in a defined order:
-  # * all key attributes (the composite id)
-  # * :provider if it is specified
-  # * all properties
-  # * all parameters
-  # * meta parameters
-  #
-  def allattrs
-    raise NotImplementedError, "allattrs() - return all attribute names in order - probably not used master side"
-    # key_attributes | (parameters & [:provider]) | properties.collect { |property| property.name } | parameters | metaparams
-  end
-
-  # Sets "applies to host"
-  def apply_to
-    raise NotImplementedError, "apply_to() - probably used when selecting a provider (device/host support)"
-  end
-
-  def apply_to_host
-    raise NotImplementedError, "apply_to_host() - probably used when selecting a provider (device/host support)"
-  end
-
-  def apply_to_device
-    raise NotImplementedError, "apply_to_device() - probably used when selecting a provider (device/host support)"
-  end
-
-  def apply_to_all
-    raise NotImplementedError, "apply_to_all() - probably used when selecting a provider (device/host support)"
-  end
-
-  def can_apply_to_target(target)
-    raise NotImplementedError, "can_apply_to_target() - probably used when selecting a provider (device/host support)"
-  end
-
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/semantic_error.rb

@@ -1,29 +0,0 @@
-# Error that is used to raise an Issue. See {Puppet::Pops::Issues}.
-#
-class Puppet::Pops::SemanticError < RuntimeError
-  attr_accessor :issue
-  attr_accessor :semantic
-  attr_accessor :options
-
-  # @param issue [Puppet::Pops::Issues::Issue] the issue describing the severity and message
-  # @param semantic [Puppet::Pops::Model::Locatable, nil] the expression causing the failure, or nil if unknown
-  # @param options [Hash] an options hash with Symbol to value mapping - these are the arguments to the issue
-  #
-  def initialize(issue, semantic=nil, options = {})
-    @issue = issue
-    @semantic = semantic
-    @options = options
-  end
-
-  def file
-    @options[:file]
-  end
-
-  def line
-    @options[:line]
-  end
-
-  def pos
-    @options[:pos]
-  end
-end