puppet 6.16.0-x86-mingw32 → 7.0.0-x86-mingw32

data/lib/puppet/pops/parser/lexer2.rb

@@ -134,10 +134,10 @@ class Lexer2
     'type'     => [:TYPE,     'type',     4],
     'attr'     => [:ATTR,     'attr',     4],
     'private'  => [:PRIVATE,  'private',  7],
-    'application' => [:APPLICATION, 'application',  11],
-    'consumes'    => [:CONSUMES,    'consumes',  8],
-    'produces'    => [:PRODUCES,    'produces',  8],
-    'site'        => [:SITE,        'site',  4],
+    'application' => [:APPLICATION, 'application',  11], # reserved
+    'consumes'    => [:CONSUMES,    'consumes',  8], # reserved
+    'produces'    => [:PRODUCES,    'produces',  8], # reserved
+    'site'        => [:SITE,        'site',  4], # reserved
   }
 
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }

data/lib/puppet/pops/parser/parser_support.rb

@@ -178,11 +178,6 @@ class Parser
     definition
   end
 
-  def add_mapping(produces)
-    # The actual handling of mappings happens in PopsBridge
-    add_definition(produces)
-  end
-
   # Transforms an array of expressions containing literal name expressions to calls if followed by an
   # expression, or expression list
   #

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

@@ -87,9 +87,7 @@ class ResourceTypeImpl
     :subscribe,
     :before,
     :notify,
-    :stage,
-    :export,
-    :consume
+    :stage
     ].freeze
 
   # Speed up lookup
@@ -107,7 +105,7 @@ class ResourceTypeImpl
     @parameters = parameters
     @title_patterns_hash = title_patterns_hash
     @isomorphic = isomorphic
-    @capability = capability
+    # ignore capability parameter
 
     # Compute attributes hash
     # Compute key_names (possibly compound key if there are multiple name vars).
@@ -175,10 +173,6 @@ class ResourceTypeImpl
     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)
@@ -243,20 +237,6 @@ class ResourceTypeImpl
     #       Param.
   end
 
-  #######################
-  # UNSUPPORTED STUFF
-  #######################
-
-  # Applications are not supported
-  def application?
-    false
-  end
-
-  ############################
-  # DON'T KNOW YET
-  ############################
-
-
   ##################################################
   # NEVER CALLED COMPILE SIDE FOR A COMPILATION
   ##################################################

data/lib/puppet/pops/types/iterable.rb

@@ -23,13 +23,16 @@ module Puppet::Pops::Types
     #
     # An `ArgumentError` is raised for all other objects.
     #
-    # @param o [Object] The object to produce an `Iterable` for
+    # @param my_caller [Object] The calling object to reference in errors
+    # @param obj [Object] The object to produce an `Iterable` for
+    # @param infer_elements [Boolean] Whether or not to recursively infer all elements of obj. Optional
+    #
     # @return [Iterable,nil] The produced `Iterable`
     # @raise [ArgumentError] In case an `Iterable` cannot be produced
     # @api public
-    def self.asserted_iterable(caller, obj)
-      iter = self.on(obj)
-      raise ArgumentError, "#{caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
+    def self.asserted_iterable(my_caller, obj, infer_elements = false)
+      iter = self.on(obj, nil, infer_elements)
+      raise ArgumentError, "#{my_caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
       iter
     end
 
@@ -48,11 +51,14 @@ module Puppet::Pops::Types
     # The value `nil` is returned for all other objects.
     #
     # @param o [Object] The object to produce an `Iterable` for
-    # @param element_type [PAnyType] the element type for the iterator. Optional (inferred if not provided)
+    # @param element_type [PAnyType] the element type for the iterator. Optional
+    # @param infer_elements [Boolean] if element_type is nil, whether or not to recursively
+    #   infer types for the entire collection. Optional
+    #
     # @return [Iterable,nil] The produced `Iterable` or `nil` if it couldn't be produced
     #
     # @api public
-    def self.on(o, element_type = nil)
+    def self.on(o, element_type = nil, infer_elements = true)
       case o
       when IteratorProducer
         o.iterator
@@ -64,7 +70,7 @@ module Puppet::Pops::Types
         if o.empty?
           Iterator.new(PUnitType::DEFAULT, o.each)
         else
-          if element_type.nil?
+          if element_type.nil? && infer_elements
             tc = TypeCalculator.singleton
             element_type = PVariantType.maybe_create(o.map {|e| tc.infer_set(e) })
           end
@@ -75,7 +81,7 @@ module Puppet::Pops::Types
         if o.empty?
           HashIterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
         else
-          if element_type.nil?
+          if element_type.nil? && infer_elements
             tc = TypeCalculator.singleton
             element_type = PTupleType.new([
               PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
@@ -202,6 +208,26 @@ module Puppet::Pops::Types
       @enumeration.send(name, *arguments, &block)
     end
 
+    def next
+      @enumeration.next
+    end
+
+    def map(*args, &block)
+      @enumeration.map(*args, &block)
+    end
+
+    def reduce(*args, &block)
+      @enumeration.reduce(*args, &block)
+    end
+
+    def all?(&block)
+      @enumeration.all?(&block)
+    end
+
+    def any?(&block)
+      @enumeration.any?(&block)
+    end
+
     def step(step, &block)
       raise ArgumentError if step <= 0
       r = self

data/lib/puppet/pops/types/p_meta_type.rb

@@ -22,7 +22,7 @@ class PMetaType < PAnyType
   end
 
   def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
+    raise NotImplementedError, "Subclass of PMetaType should implement 'instance?'"
   end
 
   # Called from the TypeParser once it has found a type using the Loader. The TypeParser will

data/lib/puppet/pops/types/p_type_set_type.rb

@@ -349,6 +349,10 @@ class PTypeSetType < PMetaType
     self.class == o.class && @name_authority == o.name_authority && @name == o.name && @version == o.version
   end
 
+  def instance?(o, guard = nil)
+    o.is_a?(PTypeSetType)
+  end
+
   DEFAULT = self.new({
     KEY_NAME => 'DefaultTypeSet',
     KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,

data/lib/puppet/pops/types/type_calculator.rb

@@ -181,13 +181,6 @@ class TypeCalculator
     t.is_a?(PAnyType) ? t.assignable?(t2) : false
   end
 
-  # Returns an iterable if the t represents something that can be iterated
-  def enumerable(t)
-    #TRANSLATOR 'TypeCalculator.enumerable' and 'iterable' are methods and should not be translated
-    Puppet.deprecation_warning(_('TypeCalculator.enumerable is deprecated. Use iterable'))
-    iterable(t)
-  end
-
   # Returns an iterable if the t represents something that can be iterated
   def iterable(t)
     # Create an iterable on the type if possible

data/lib/puppet/pops/types/type_parser.rb

@@ -94,10 +94,6 @@ class TypeParser
     interpret_any(o.text_expr, context)
   end
 
-  def interpret_SubLocatedExpression(o, context)
-    interpret_any(o.expr, context)
-  end
-
   # @api private
   def interpret_QualifiedName(o, context)
     o.value

data/lib/puppet/pops/types/types.rb

@@ -1,5 +1,4 @@
 require_relative 'iterable'
-require_relative 'enumeration'
 require_relative 'recursion_guard'
 require_relative 'type_acceptor'
 require_relative 'type_asserter'

data/lib/puppet/pops/validation/checker4_0.rb

@@ -236,7 +236,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     case p
     when Model::AbstractResource
     when Model::CollectExpression
-    when Model::CapabilityMapping
       acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, p, :operator=>'* =>')
     else
       # protect against just testing a snippet that has no parent, error message will be a bit strange
@@ -295,32 +294,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
-  def check_CapabilityMapping(o)
-    ok =
-    case o.component
-    when Model::QualifiedReference
-      name = o.component.cased_value
-      acceptor.accept(Issues::ILLEGAL_CLASSREF, o.component, {:name=>name}) unless name =~ Patterns::CLASSREF_EXT
-      true
-    when Model::AccessExpression
-      keys = o.component.keys
-      expr = o.component.left_expr
-      if expr.is_a?(Model::QualifiedReference) && keys.size == 1
-        key = keys[0]
-        key.is_a?(Model::LiteralString) || key.is_a?(Model::QualifiedName) || key.is_a?(Model::QualifiedReference)
-      else
-        false
-      end
-    else
-      false
-    end
-    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.component, :feature=>'capability mapping', :container => o) unless ok
-
-    if o.capability !~ Patterns::CLASSREF_EXT
-      acceptor.accept(Issues::ILLEGAL_CLASSREF, o, {:name=>o.capability})
-    end
-  end
-
   def check_EppExpression(o)
     p = container
     if p.is_a?(Model::LambdaExpression)
@@ -397,6 +370,15 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     'regexp' => true,
     'pattern' => true,
     'runtime' => true,
+    'init' => true,
+    'object' => true,
+    'sensitive' => true,
+    'semver' => true,
+    'semverrange' => true,
+    'string' => true,
+    'timestamp' => true,
+    'timespan' => true,
+    'typeset' => true,
   }
 
   FUTURE_RESERVED_WORDS = {
@@ -589,36 +571,40 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   # @api private
   class Puppet::Util::FileNamespaceAdapter < Puppet::Pops::Adaptable::Adapter
     attr_accessor :file_to_namespace
+
+    def self.create_adapter(env)
+      adapter = super(env)
+      adapter.file_to_namespace = {}
+      adapter
+    end
   end
 
   def namespace_for_file(file)
     env = Puppet.lookup(:current_environment)
     return NO_NAMESPACE if env.nil?
 
-    Puppet::Util::FileNamespaceAdapter.adapt(env) do |adapter|
-      adapter.file_to_namespace ||= {}
+    adapter = Puppet::Util::FileNamespaceAdapter.adapt(env)
 
-      file_namespace = adapter.file_to_namespace[file]
-      return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
+    file_namespace = adapter.file_to_namespace[file]
+    return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
 
-      path = Pathname.new(file)
+    path = Pathname.new(file)
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
 
-      path = path.expand_path
+    path = path.expand_path
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
 
-      #All auto-loaded files from modules come from a module search path dir
-      relative_path = get_module_relative_path(path, env.full_modulepath)
+    #All auto-loaded files from modules come from a module search path dir
+    relative_path = get_module_relative_path(path, env.full_modulepath)
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
 
-      #If a file comes from a module, but isn't in the right place, always error
-      names = dir_to_names(relative_path)
+    #If a file comes from a module, but isn't in the right place, always error
+    names = dir_to_names(relative_path)
 
-      return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
-    end
+    return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
   end
 
   def initial_manifest?(path, manifest_setting)

data/lib/puppet/pops/validation/tasks_checker.rb

@@ -13,14 +13,6 @@ class TasksChecker < Checker4_0
     end
   end
 
-  def check_Application(o)
-    illegalTasksExpression(o)
-  end
-
-  def check_CapabilityMapping(o)
-    illegalTasksExpression(o)
-  end
-
   def check_CollectExpression(o)
     # Only virtual resource queries are allowed in apply blocks, not exported
     # resource queries
@@ -83,10 +75,6 @@ class TasksChecker < Checker4_0
     illegalTasksExpression(o)
   end
 
-  def check_SiteDefinition(o)
-    illegalTasksExpression(o)
-  end
-
   def check_ApplyExpression(o)
     if in_ApplyExpression?
       acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, {:klass => o})

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -35,7 +35,7 @@ class ValidatorFactory_4_0 < Factory
     p[Issues::DUPLICATE_KEY]                  = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
     p[Issues::NAME_WITH_HYPHEN]               = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION]  = :ignore
-    p[Issues::CLASS_NOT_VIRTUALIZABLE]        = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+    p[Issues::CLASS_NOT_VIRTUALIZABLE]        = :error
     p
   end
 end

data/lib/puppet/provider.rb

@@ -117,19 +117,6 @@ class Puppet::Provider
     Puppet::Util::Execution.execpipe(*args, &block)
   end
 
-  # Convenience methods - see class method with the same name.
-  # @return (see self.execfail)
-  # @deprecated
-  def execfail(*args)
-    Puppet::Util::Execution.execfail(*args)
-  end
-
-  # (see Puppet::Util::Execution.execfail)
-  # @deprecated
-  def self.execfail(*args)
-    Puppet::Util::Execution.execfail(*args)
-  end
-
   # Returns the absolute path to the executable for the command referenced by the given name.
   # @raise [Puppet::DevError] if the name does not reference an existing command.
   # @return [String] the absolute path to the found executable for the command

data/lib/puppet/provider/file/windows.rb

@@ -126,7 +126,7 @@ Puppet::Type.type(:file).provide :windows do
           # If the SYSTEM account does _not_ have FullControl in this scenario, we should
           # force the resource out of sync no matter what.
           #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.debug _("%{resource_name}: %{mode_part_type} set to SYSTEM. SYSTEM permissions cannot be set below FullControl ('7')") % { resource_name: resource[:name], mode_part_type: mode_part['type']}
+          Puppet.debug { _("%{resource_name}: %{mode_part_type} set to SYSTEM. SYSTEM permissions cannot be set below FullControl ('7')") % { resource_name: resource[:name], mode_part_type: mode_part['type']} }
           return nil
         end
       end

data/lib/puppet/provider/nameservice.rb

@@ -54,24 +54,6 @@ class Puppet::Provider::NameService < Puppet::Provider
       end
     end
 
-    # List everything out by name.  Abstracted a bit so that it works
-    # for both users and groups.
-    def listbyname
-      Puppet.deprecation_warning(_("listbyname is deprecated and will be removed in a future release of Puppet. Please use `self.instances` to obtain a list of users."))
-      names = []
-      Puppet::Etc.send("set#{section()}ent")
-      begin
-        while ent = Puppet::Etc.send("get#{section()}ent") #rubocop:disable Lint/AssignmentInCondition
-          names << ent.name
-          yield ent.name if block_given?
-        end
-      ensure
-        Puppet::Etc.send("end#{section()}ent")
-      end
-
-      names
-    end
-
     def resource_type=(resource_type)
       super
       @resource_type.validproperties.each do |prop|

data/lib/puppet/provider/package/apt.rb

@@ -16,6 +16,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
 
   commands :aptget => "/usr/bin/apt-get"
   commands :aptcache => "/usr/bin/apt-cache"
+  commands :aptmark => "/usr/bin/apt-mark"
   commands :preseed => "/usr/bin/debconf-set-selections"
 
   defaultfor :osfamily => :debian
@@ -30,6 +31,39 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     false
   end
 
+  def self.instances
+    packages = super
+    manual_marks = aptmark('showmanual').split("\n")
+    packages.each do |package|
+      package.mark = :manual if manual_marks.include?(package.name)
+    end
+    packages
+  end
+
+  def query
+    hash = super
+    hash[:mark] = :manual if aptmark('showmanual').split("\n").include?(@resource[:name])
+    hash
+  end
+
+  def initialize(value={})
+    super(value)
+    @property_flush = {}
+  end
+
+  def mark=(value)
+    @property_flush[:mark] = value
+  end
+
+  def flush
+    # unless we are removing the package mark it if it hasn't already been marked
+    if @property_flush
+      unless @property_flush[:mark] || [:purge, :absent].include?(resource[:ensure])
+        aptmark('manual', resource[:name])
+      end
+    end
+  end
+
   # A derivative of DPKG; this is how most people actually manage
   # Debian boxes, and the only thing that differs is that it can
   # install packages from remote sites.