puppet 6.23.0 → 7.0.0

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,22 +237,6 @@ class ResourceTypeImpl
     #       Param.
   end
 
-  #######################
-  # UNSUPPORTED STUFF
-  #######################
-
-  # Applications are not supported
-  #
-  # @deprecated application orchestration will be removed in puppet 7
-  def application?
-    false
-  end
-
-  ############################
-  # DON'T KNOW YET
-  ############################
-
-
   ##################################################
   # NEVER CALLED COMPILE SIDE FOR A COMPILATION
   ##################################################

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

@@ -95,22 +95,16 @@ class PSemVerType < PScalarType
       end
 
       def from_args(major, minor, patch, prerelease = nil, build = nil)
-        SemanticPuppet::Version.new(major, minor, patch, to_array(prerelease), to_array(build))
+        SemanticPuppet::Version.new(major, minor, patch, prerelease, build)
       end
 
       def from_hash(hash)
-        SemanticPuppet::Version.new(hash['major'], hash['minor'], hash['patch'], to_array(hash['prerelease']), to_array(hash['build']))
+        SemanticPuppet::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
       end
 
       def on_error(str)
         _("The string '%{str}' cannot be converted to a SemVer") % { str: str }
       end
-
-      private
-
-      def to_array(component)
-        component ? [component] : nil
-      end
     end
   end
 

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

@@ -24,16 +24,6 @@ class PSensitiveType < PTypeWithContainedType
     def inspect
       "#<#{self}>"
     end
-
-    def hash
-      @value.hash
-    end
-
-    def ==(other)
-      other.is_a?(Sensitive) &&
-        other.hash == hash
-    end
-    alias eql? ==
   end
 
   def self.register_ptype(loader, ir)

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

@@ -199,11 +199,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
-  def check_Application(o)
-    check_NamedDefinition(o)
-    acceptor.accept(Issues::DEPRECATED_APP_ORCHESTRATION, o, {:klass => o})
-  end
-
   def check_AssignmentExpression(o)
     case o.operator
     when '='
@@ -241,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
@@ -300,33 +294,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
-  def check_CapabilityMapping(o)
-    acceptor.accept(Issues::DEPRECATED_APP_ORCHESTRATION, o, {:klass => 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)
@@ -403,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 = {
@@ -875,10 +851,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     rvalue(o.matching_expr)
   end
 
-  def check_SiteDefinition(o)
-    acceptor.accept(Issues::DEPRECATED_APP_ORCHESTRATION, o, {:klass => o})
-  end
-
   def check_UnaryExpression(o)
     rvalue(o.expr)
   end

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

@@ -31,12 +31,11 @@ class ValidatorFactory_4_0 < Factory
     p[Issues::RT_NO_STORECONFIGS]             = Puppet[:storeconfigs] ? :ignore : :warning
 
     p[Issues::FUTURE_RESERVED_WORD]           = :deprecation
-    p[Issues::DEPRECATED_APP_ORCHESTRATION]   = :deprecation
 
     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/property/list.rb

@@ -47,7 +47,7 @@ module Puppet
         #ok, some 'convention' if the list property is named groups, provider should implement a groups method
         tmp = provider.send(name) if provider
         if tmp && tmp != :absent
-          return tmp.instance_of?(Array) ? tmp : tmp.split(delimiter)
+          return tmp.split(delimiter)
         else
           return :absent
         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/group/groupadd.rb

@@ -130,21 +130,16 @@ Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameSe
   private
 
   def findgroup(key, value)
-    group_file = '/etc/group'
+    group_file = "/etc/group"
     group_keys = [:group_name, :password, :gid, :user_list]
-
-    unless @groups
-      unless Puppet::FileSystem.exist?(group_file)
-        raise Puppet::Error.new("Forcelocal set for group resource '#{resource[:name]}', but #{group_file} does not exist")
-      end
-
-      @groups = []
-      Puppet::FileSystem.each_line(group_file) do |line|
-        group = line.chomp.split(':')
-        @groups << Hash[group_keys.zip(group)]
+    index = group_keys.index(key)
+    @group_content ||= File.read(group_file)
+    @group_content.each_line do |line|
+      group = line.split(":")
+      if group[index] == value
+        return Hash[group_keys.zip(group)]
       end
     end
-
-    @groups.find { |param| param[key] == value } || false
+    false
   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

@@ -42,11 +42,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
 
   def query
     hash = super
-
-    if !%i(absent purged).include?(hash[:ensure]) && aptmark('showmanual', @resource[:name]).strip == @resource[:name]
-      hash[:mark] = :manual
-    end
-
+    hash[:mark] = :manual if aptmark('showmanual').split("\n").include?(@resource[:name])
     hash
   end
 
@@ -55,10 +51,6 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     @property_flush = {}
   end
 
-  def mark
-    @property_flush[:mark]
-  end
-
   def mark=(value)
     @property_flush[:mark] = value
   end
@@ -151,13 +143,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     end
 
     cmd += install_options if @resource[:install_options]
-    cmd << :install
-
-    if source
-      cmd << source
-    else
-      cmd << str
-    end
+    cmd << :install << str
 
     self.unhold if self.properties[:mark] == :hold
     begin
@@ -165,18 +151,6 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     ensure
       self.hold if @resource[:mark] == :hold
     end
-
-    # If a source file was specified, we must make sure the expected version was installed from specified file
-    if source && !%i(present installed).include?(should)
-      is = self.query
-      raise Puppet::Error, _("Could not find package %{name}") % { name: self.name } unless is
-
-      version = is[:ensure]
-
-      raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: version } unless
-        insync?(version)
-    end
-
   end
 
   # What's the latest package version available?
@@ -253,10 +227,4 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     end
     should_range.include?(is_version)
   end
-
-  private
-
-  def source
-    @source ||= @resource[:source]
-  end
 end

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

@@ -26,10 +26,4 @@ Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg
   def purge
     aptitude '-y', 'purge', @resource[:name]
   end
-
-  private
-
-  def source
-    nil
-  end
 end