puppet 6.26.0-x64-mingw32 → 7.0.0-x64-mingw32

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

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 # The Lexer is responsible for turning source text into tokens.
 # This version is a performance enhanced lexer (in comparison to the 3.x and earlier "future parser" lexer.
 #
@@ -31,114 +30,114 @@ class Lexer2
   # The length is pre-calculated for all singleton tokens. The length is used both to signal the length of
   # the token, and to advance the scanner position (without having to advance it with a scan(regexp)).
   #
-  TOKEN_LBRACK       = [:LBRACK,       '[',   1].freeze
-  TOKEN_LISTSTART    = [:LISTSTART,    '[',   1].freeze
-  TOKEN_RBRACK       = [:RBRACK,       ']',   1].freeze
-  TOKEN_LBRACE       = [:LBRACE,       '{',   1].freeze
-  TOKEN_RBRACE       = [:RBRACE,       '}',   1].freeze
-  TOKEN_SELBRACE     = [:SELBRACE,     '{',   1].freeze
-  TOKEN_LPAREN       = [:LPAREN,       '(',   1].freeze
-  TOKEN_WSLPAREN     = [:WSLPAREN,     '(',   1].freeze
-  TOKEN_RPAREN       = [:RPAREN,       ')',   1].freeze
-
-  TOKEN_EQUALS       = [:EQUALS,       '=',   1].freeze
-  TOKEN_APPENDS      = [:APPENDS,      '+=',  2].freeze
-  TOKEN_DELETES      = [:DELETES,      '-=',  2].freeze
-
-  TOKEN_ISEQUAL      = [:ISEQUAL,      '==',  2].freeze
-  TOKEN_NOTEQUAL     = [:NOTEQUAL,     '!=',  2].freeze
-  TOKEN_MATCH        = [:MATCH,        '=~',  2].freeze
-  TOKEN_NOMATCH      = [:NOMATCH,      '!~',  2].freeze
-  TOKEN_GREATEREQUAL = [:GREATEREQUAL, '>=',  2].freeze
-  TOKEN_GREATERTHAN  = [:GREATERTHAN,  '>',   1].freeze
-  TOKEN_LESSEQUAL    = [:LESSEQUAL,    '<=',  2].freeze
-  TOKEN_LESSTHAN     = [:LESSTHAN,     '<',   1].freeze
-
-  TOKEN_FARROW       = [:FARROW,       '=>',  2].freeze
-  TOKEN_PARROW       = [:PARROW,       '+>',  2].freeze
-
-  TOKEN_LSHIFT       = [:LSHIFT,       '<<',  2].freeze
-  TOKEN_LLCOLLECT    = [:LLCOLLECT,    '<<|', 3].freeze
-  TOKEN_LCOLLECT     = [:LCOLLECT,     '<|',  2].freeze
-
-  TOKEN_RSHIFT       = [:RSHIFT,       '>>',  2].freeze
-  TOKEN_RRCOLLECT    = [:RRCOLLECT,    '|>>', 3].freeze
-  TOKEN_RCOLLECT     = [:RCOLLECT,     '|>',  2].freeze
-
-  TOKEN_PLUS         = [:PLUS,         '+',   1].freeze
-  TOKEN_MINUS        = [:MINUS,        '-',   1].freeze
-  TOKEN_DIV          = [:DIV,          '/',   1].freeze
-  TOKEN_TIMES        = [:TIMES,        '*',   1].freeze
-  TOKEN_MODULO       = [:MODULO,       '%',   1].freeze
-
-  TOKEN_NOT          = [:NOT,          '!',   1].freeze
-  TOKEN_DOT          = [:DOT,          '.',   1].freeze
-  TOKEN_PIPE         = [:PIPE,         '|',   1].freeze
-  TOKEN_AT           = [:AT ,          '@',   1].freeze
-  TOKEN_ATAT         = [:ATAT ,        '@@',  2].freeze
-  TOKEN_COLON        = [:COLON,        ':',   1].freeze
-  TOKEN_COMMA        = [:COMMA,        ',',   1].freeze
-  TOKEN_SEMIC        = [:SEMIC,        ';',   1].freeze
-  TOKEN_QMARK        = [:QMARK,        '?',   1].freeze
-  TOKEN_TILDE        = [:TILDE,        '~',   1].freeze # lexed but not an operator in Puppet
+  TOKEN_LBRACK       = [:LBRACK,       '['.freeze,   1].freeze
+  TOKEN_LISTSTART    = [:LISTSTART,    '['.freeze,   1].freeze
+  TOKEN_RBRACK       = [:RBRACK,       ']'.freeze,   1].freeze
+  TOKEN_LBRACE       = [:LBRACE,       '{'.freeze,   1].freeze
+  TOKEN_RBRACE       = [:RBRACE,       '}'.freeze,   1].freeze
+  TOKEN_SELBRACE     = [:SELBRACE,     '{'.freeze,   1].freeze
+  TOKEN_LPAREN       = [:LPAREN,       '('.freeze,   1].freeze
+  TOKEN_WSLPAREN     = [:WSLPAREN,     '('.freeze,   1].freeze
+  TOKEN_RPAREN       = [:RPAREN,       ')'.freeze,   1].freeze
+
+  TOKEN_EQUALS       = [:EQUALS,       '='.freeze,   1].freeze
+  TOKEN_APPENDS      = [:APPENDS,      '+='.freeze,  2].freeze
+  TOKEN_DELETES      = [:DELETES,      '-='.freeze,  2].freeze
+
+  TOKEN_ISEQUAL      = [:ISEQUAL,      '=='.freeze,  2].freeze
+  TOKEN_NOTEQUAL     = [:NOTEQUAL,     '!='.freeze,  2].freeze
+  TOKEN_MATCH        = [:MATCH,        '=~'.freeze,  2].freeze
+  TOKEN_NOMATCH      = [:NOMATCH,      '!~'.freeze,  2].freeze
+  TOKEN_GREATEREQUAL = [:GREATEREQUAL, '>='.freeze,  2].freeze
+  TOKEN_GREATERTHAN  = [:GREATERTHAN,  '>'.freeze,   1].freeze
+  TOKEN_LESSEQUAL    = [:LESSEQUAL,    '<='.freeze,  2].freeze
+  TOKEN_LESSTHAN     = [:LESSTHAN,     '<'.freeze,   1].freeze
+
+  TOKEN_FARROW       = [:FARROW,       '=>'.freeze,  2].freeze
+  TOKEN_PARROW       = [:PARROW,       '+>'.freeze,  2].freeze
+
+  TOKEN_LSHIFT       = [:LSHIFT,       '<<'.freeze,  2].freeze
+  TOKEN_LLCOLLECT    = [:LLCOLLECT,    '<<|'.freeze, 3].freeze
+  TOKEN_LCOLLECT     = [:LCOLLECT,     '<|'.freeze,  2].freeze
+
+  TOKEN_RSHIFT       = [:RSHIFT,       '>>'.freeze,  2].freeze
+  TOKEN_RRCOLLECT    = [:RRCOLLECT,    '|>>'.freeze, 3].freeze
+  TOKEN_RCOLLECT     = [:RCOLLECT,     '|>'.freeze,  2].freeze
+
+  TOKEN_PLUS         = [:PLUS,         '+'.freeze,   1].freeze
+  TOKEN_MINUS        = [:MINUS,        '-'.freeze,   1].freeze
+  TOKEN_DIV          = [:DIV,          '/'.freeze,   1].freeze
+  TOKEN_TIMES        = [:TIMES,        '*'.freeze,   1].freeze
+  TOKEN_MODULO       = [:MODULO,       '%'.freeze,   1].freeze
+
+  TOKEN_NOT          = [:NOT,          '!'.freeze,   1].freeze
+  TOKEN_DOT          = [:DOT,          '.'.freeze,   1].freeze
+  TOKEN_PIPE         = [:PIPE,         '|'.freeze,   1].freeze
+  TOKEN_AT           = [:AT ,          '@'.freeze,   1].freeze
+  TOKEN_ATAT         = [:ATAT ,        '@@'.freeze,  2].freeze
+  TOKEN_COLON        = [:COLON,        ':'.freeze,   1].freeze
+  TOKEN_COMMA        = [:COMMA,        ','.freeze,   1].freeze
+  TOKEN_SEMIC        = [:SEMIC,        ';'.freeze,   1].freeze
+  TOKEN_QMARK        = [:QMARK,        '?'.freeze,   1].freeze
+  TOKEN_TILDE        = [:TILDE,        '~'.freeze,   1].freeze # lexed but not an operator in Puppet
 
   TOKEN_REGEXP       = [:REGEXP,       nil,   0].freeze
 
-  TOKEN_IN_EDGE      = [:IN_EDGE,      '->',  2].freeze
-  TOKEN_IN_EDGE_SUB  = [:IN_EDGE_SUB,  '~>',  2].freeze
-  TOKEN_OUT_EDGE     = [:OUT_EDGE,     '<-',  2].freeze
-  TOKEN_OUT_EDGE_SUB = [:OUT_EDGE_SUB, '<~',  2].freeze
+  TOKEN_IN_EDGE      = [:IN_EDGE,      '->'.freeze,  2].freeze
+  TOKEN_IN_EDGE_SUB  = [:IN_EDGE_SUB,  '~>'.freeze,  2].freeze
+  TOKEN_OUT_EDGE     = [:OUT_EDGE,     '<-'.freeze,  2].freeze
+  TOKEN_OUT_EDGE_SUB = [:OUT_EDGE_SUB, '<~'.freeze,  2].freeze
 
   # Tokens that are always unique to what has been lexed
-  TOKEN_STRING         = [:STRING,      nil,  0].freeze
-  TOKEN_WORD           = [:WORD,        nil,  0].freeze
-  TOKEN_DQPRE          = [:DQPRE,       nil,  0].freeze
-  TOKEN_DQMID          = [:DQPRE,       nil,  0].freeze
-  TOKEN_DQPOS          = [:DQPRE,       nil,  0].freeze
-  TOKEN_NUMBER         = [:NUMBER,      nil,  0].freeze
-  TOKEN_VARIABLE       = [:VARIABLE,    nil,  1].freeze
-  TOKEN_VARIABLE_EMPTY = [:VARIABLE,    '',   1].freeze
+  TOKEN_STRING         =  [:STRING, nil,          0].freeze
+  TOKEN_WORD           =  [:WORD, nil,            0].freeze
+  TOKEN_DQPRE          =  [:DQPRE,  nil,          0].freeze
+  TOKEN_DQMID          =  [:DQPRE,  nil,          0].freeze
+  TOKEN_DQPOS          =  [:DQPRE,  nil,          0].freeze
+  TOKEN_NUMBER         =  [:NUMBER, nil,          0].freeze
+  TOKEN_VARIABLE       =  [:VARIABLE, nil,        1].freeze
+  TOKEN_VARIABLE_EMPTY =  [:VARIABLE, ''.freeze,  1].freeze
 
   # HEREDOC has syntax as an argument.
-  TOKEN_HEREDOC        = [:HEREDOC,     nil,  0].freeze
+  TOKEN_HEREDOC        =  [:HEREDOC, nil, 0].freeze
 
   # EPP_START is currently a marker token, may later get syntax
-  TOKEN_EPPSTART    = [:EPP_START,      nil,  0].freeze
-  TOKEN_EPPEND      = [:EPP_END,       '%>',  2].freeze
-  TOKEN_EPPEND_TRIM = [:EPP_END_TRIM, '-%>',  3].freeze
+  TOKEN_EPPSTART       =  [:EPP_START, nil, 0].freeze
+  TOKEN_EPPEND         =  [:EPP_END, '%>', 2].freeze
+  TOKEN_EPPEND_TRIM    =  [:EPP_END_TRIM, '-%>', 3].freeze
 
   # This is used for unrecognized tokens, will always be a single character. This particular instance
   # is not used, but is kept here for documentation purposes.
-  TOKEN_OTHER = [:OTHER, nil, 0]
+  TOKEN_OTHER        = [:OTHER,  nil,  0]
 
   # Keywords are all singleton tokens with pre calculated lengths.
   # Booleans are pre-calculated (rather than evaluating the strings "false" "true" repeatedly.
   #
   KEYWORDS = {
-    'case'        => [:CASE,        'case',         4],
-    'class'       => [:CLASS,       'class',        5],
-    'default'     => [:DEFAULT,     'default',      7],
-    'define'      => [:DEFINE,      'define',       6],
-    'if'          => [:IF,          'if',           2],
-    'elsif'       => [:ELSIF,       'elsif',        5],
-    'else'        => [:ELSE,        'else',         4],
-    'inherits'    => [:INHERITS,    'inherits',     8],
-    'node'        => [:NODE,        'node',         4],
-    'and'         => [:AND,         'and',          3],
-    'or'          => [:OR,          'or',           2],
-    'undef'       => [:UNDEF,       'undef',        5],
-    'false'       => [:BOOLEAN,     false,          5],
-    'true'        => [:BOOLEAN,     true,           4],
-    'in'          => [:IN,          'in',           2],
-    'unless'      => [:UNLESS,      'unless',       6],
-    'function'    => [:FUNCTION,    'function',     8],
-    '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],
+    'case'     => [:CASE,     'case',     4],
+    'class'    => [:CLASS,    'class',    5],
+    'default'  => [:DEFAULT,  'default',  7],
+    'define'   => [:DEFINE,   'define',   6],
+    'if'       => [:IF,       'if',       2],
+    'elsif'    => [:ELSIF,    'elsif',    5],
+    'else'     => [:ELSE,     'else',     4],
+    'inherits' => [:INHERITS, 'inherits', 8],
+    'node'     => [:NODE,     'node',     4],
+    'and'      => [:AND,      'and',      3],
+    'or'       => [:OR,       'or',       2],
+    'undef'    => [:UNDEF,    'undef',    5],
+    'false'    => [:BOOLEAN,  false,      5],
+    'true'     => [:BOOLEAN,  true,       4],
+    'in'       => [:IN,       'in',       2],
+    'unless'   => [:UNLESS,   'unless',   6],
+    'function' => [:FUNCTION, 'function', 8],
+    'type'     => [:TYPE,     'type',     4],
+    'attr'     => [:ATTR,     'attr',     4],
+    'private'  => [:PRIVATE,  'private',  7],
+    '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/parser/slurp_support.rb

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 module Puppet::Pops
 module Parser
 # This module is an integral part of the Lexer.

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/serialization/to_stringified_converter.rb

@@ -62,7 +62,7 @@ module Serialization
     end
 
     def to_data(value)
-      if value.instance_of?(String)
+      if value.is_a?(String)
         to_string_or_binary(value)
       elsif value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
         value

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_formatter.rb

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 require 'puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
@@ -23,7 +22,7 @@ class TypeFormatter
   end
 
   def initialize
-    @string_visitor = Visitor.new(nil, 'string', 0, 0)
+    @string_visitor = Visitor.new(nil, 'string',0,0)
   end
 
   def expanded
@@ -50,7 +49,7 @@ class TypeFormatter
   # @api public
   #
   def string(t)
-    @bld = ''.dup
+    @bld = ''
     append_string(t)
     @bld
   end
@@ -64,7 +63,7 @@ class TypeFormatter
   #
   # @api public
   def indented_string(t, indent = 0, indent_width = 2)
-    @bld = ''.dup
+    @bld = ''
     append_indented_string(t, indent, indent_width)
     @bld
   end

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

@@ -640,7 +640,7 @@ module Types
           result = ["#{label} expects (#{signature_string(sig)})"]
           result.concat(error_arrays[0].map { |e| "  rejected:#{e.chop_path(0).format}" })
         else
-          result = ["The function #{label} was called with arguments it does not accept. It expects one of:"]
+          result = ["#{label} expects one of:"]
           signatures.each_with_index do |sg, index|
             result << "  (#{signature_string(sg)})"
             result.concat(error_arrays[index].map { |e| "    rejected:#{e.chop_path(0).format}" })

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'
@@ -736,7 +735,7 @@ class PScalarDataType < PScalarType
   end
 
   def instance?(o, guard = nil)
-    return o.instance_of?(String) || o.is_a?(Integer) || o.is_a?(Float) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
+    return o.is_a?(String) || o.is_a?(Integer) || o.is_a?(Float) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
   end
 
   DEFAULT = PScalarDataType.new

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/aix_object.rb

@@ -279,7 +279,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
         name = object[:name]
         id = object[:attributes].delete(:id)
 
-        { name: name, id: id }
+        Hash[[[:name, name,],[:id, id]]]
       end
     end
 

data/lib/puppet/provider/exec/posix.rb

@@ -6,22 +6,10 @@ Puppet::Type.type(:exec).provide :posix, :parent => Puppet::Provider::Exec do
   defaultfor :feature => :posix
 
   desc <<-EOT
-    Executes external binaries by invoking Ruby's `Kernel.exec`.
-    When the command is a string, it will be executed directly,
-    without a shell, if it follows these rules:
-     - no meta characters
-     - no shell reserved word and no special built-in
-
-    When the command is an Array of Strings, passed as `[cmdname, arg1, ...]`
-    it will be executed directly(the first element is taken as a command name
-    and the rest are passed as parameters to command with no shell expansion)
-    This is a safer and more predictable way to execute most commands,
-    but prevents the use of globbing and shell built-ins (including control
-    logic like "for" and "if" statements).
-
-    If the use of globbing and shell built-ins is desired, please check
-    the `shell` provider
-
+    Executes external binaries directly, without passing through a shell or
+    performing any interpolation. This is a safer and more predictable way
+    to execute most commands, but prevents the use of globbing and shell
+    built-ins (including control logic like "for" and "if" statements).
   EOT
 
   # Verify that we have the executable

data/lib/puppet/provider/group/groupadd.rb

@@ -2,14 +2,11 @@ require 'puppet/provider/nameservice/objectadd'
 require 'puppet/util/libuser'
 
 Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameService::ObjectAdd do
-  desc "Group management via `groupadd` and its ilk. The default for most platforms.
-
- To use the `forcelocal` parameter, you need to install the `libuser` package (providing
-  `/usr/sbin/lgroupadd` and `/usr/sbin/luseradd`)."
+  desc "Group management via `groupadd` and its ilk. The default for most platforms."
 
   commands :add => "groupadd", :delete => "groupdel", :modify => "groupmod"
 
-  has_feature :system_groups unless %w{HP-UX Solaris}.include? Puppet.runtime[:facter].value(:operatingsystem)
+  has_feature :system_groups unless %w{HP-UX Solaris}.include? Facter.value(:operatingsystem)
 
   verify :gid, _("GID must be an integer") do |value|
     value.is_a? Integer
@@ -133,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