puppet 5.5.22 → 6.0.0

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

@@ -91,8 +91,7 @@ class PBinaryType < PAnyType
     # @api private
     #
     def initialize(bin)
-      # TODO: When Ruby 1.9.3 support is dropped change this to `bin.b` for binary encoding instead of force_encoding
-      @binary_buffer = (bin.encoding.name == "ASCII-8BIT" ? bin : bin.dup.force_encoding("ASCII-8BIT")).freeze
+      @binary_buffer = (bin.encoding.name == "ASCII-8BIT" ? bin : bin.b).freeze
     end
 
     # Presents the binary content as a string base64 encoded string (without line breaks).

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

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

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

@@ -284,6 +284,9 @@ class PObjectType < PMetaType
     # @api public
     def initialize(name, container, init_hash)
       super(name, container, TypeAsserter.assert_instance_of(nil, TYPE_ATTRIBUTE, init_hash) { "initializer for #{self.class.label(container, name)}" })
+      if name == Serialization::PCORE_TYPE_KEY || name == Serialization::PCORE_VALUE_KEY
+        raise Puppet::ParseError, _("The attribute '%{name}' is reserved and cannot be used") % { name: name}
+      end
       @kind = init_hash[KEY_KIND]
       if @kind == ATTRIBUTE_KIND_CONSTANT # final is implied
         if init_hash.include?(KEY_FINAL) && !@final

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

@@ -22,7 +22,7 @@ class PSensitiveType < PTypeWithContainedType
     end
 
     def inspect
-      "#<#{self}>"
+      "#<#{to_s}>"
     end
   end
 

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

@@ -65,9 +65,9 @@ module Types
       when String
         impl_class.parse(arg)
       when Integer
-        impl_class.new(arg * Time::NSECS_PER_SEC)
+        arg == impl_class.new(arg * Time::NSECS_PER_SEC)
       when Float
-        impl_class.new(arg * Time::NSECS_PER_SEC)
+        arg == (min ? -Float::INFINITY : Float::INFINITY) ? arg : impl_class.new(arg * Time::NSECS_PER_SEC)
       else
         raise ArgumentError, "Unable to create a #{impl_class.name} from a #{arg.class.name}" unless arg.nil? || arg == :default
         nil

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

@@ -349,10 +349,6 @@ 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/string_converter.rb

@@ -484,17 +484,8 @@ class StringConverter
 
     value_type = TypeCalculator.infer_set(value)
     if string_formats.is_a?(String)
-      # For Array and Hash, the format is given as a Hash where 'format' key is the format for the collection itself
-      if Puppet::Pops::Types::PArrayType::DEFAULT.assignable?(value_type)
-        # add the format given for the exact type
-        string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => {'format' => string_formats }}
-      elsif Puppet::Pops::Types::PHashType::DEFAULT.assignable?(value_type)
-          # add the format given for the exact type
-          string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => {'format' => string_formats }}
-      else
-        # add the format given for the exact type
-        string_formats = { value_type => string_formats }
-      end
+      # add the format given for the exact type
+      string_formats = { value_type => string_formats }
     end
 
     case string_formats
@@ -728,7 +719,7 @@ class StringConverter
     when :c
       char = [val].pack("U")
       char = f.alt? ? "\"#{char}\"" : char
-      Kernel.format(f.orig_fmt.tr('c','s'), char)
+      Kernel.format(f.orig_fmt.gsub('c','s'), char)
 
     when :s
       fmt = f.alt? ? 'p' : 's'
@@ -781,7 +772,7 @@ class StringConverter
 
     when :p
       # width & precision applied to string, not the the name of the type
-      "Binary(\"#{Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)}\")"
+      "Binary(\"#{Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)}\")"
 
     when :b
       Kernel.format(f.orig_fmt.gsub('b', substitute), val.relaxed_to_s)
@@ -817,23 +808,23 @@ class StringConverter
 
     when :c
       c_val = val.capitalize
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('c', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('c', 's'), c_val)
 
     when :C
       c_val = val.split('::').map {|s| s.capitalize }.join('::')
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('C', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('C', 's'), c_val)
 
     when :u
       c_val = val.upcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('u', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('u', 's'), c_val)
 
     when :d
       c_val = val.downcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('d', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('d', 's'), c_val)
 
     when :t  # trim
       c_val = val.strip
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('t', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('t', 's'), c_val)
 
     else
       raise FormatError.new('String', f.format, 'cCudspt')
@@ -916,7 +907,7 @@ class StringConverter
     case f.format
     when :p
       str_regexp = PRegexpType.regexp_to_s_with_delimiters(val)
-      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.tr('p', 's'), str_regexp)
+      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.gsub('p', 's'), str_regexp)
     when :s
       str_regexp = PRegexpType.regexp_to_s(val)
       str_regexp = puppet_quote(str_regexp) if f.alt?
@@ -1093,10 +1084,10 @@ class StringConverter
     f = get_format(val_type, format_map)
     case f.format
     when :s
-      str_val = f.alt? ? "\"#{val}\"" : val.to_s
+      str_val = f.alt? ? "\"#{val.to_s}\"" : val.to_s
       Kernel.format(f.orig_fmt, str_val)
     when :p
-      Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)
+      Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)
     else
       raise FormatError.new('Type', f.format, 'sp')
     end

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

@@ -120,30 +120,6 @@ class TypeCalculator
     singleton.infer(o)
   end
 
-  # Infers a type if given object may have callable members, else returns nil.
-  # Caller must check for nil or if returned type supports members.
-  # This is a much cheaper call than doing a call to the general infer(o) method.
-  #
-  # @api private
-  def self.infer_callable_methods_t(o)
-    # If being a value that cannot have Pcore based methods callable from Puppet Language
-    if (o.is_a?(String) ||
-      o.is_a?(Numeric) ||
-      o.is_a?(TrueClass) ||
-      o.is_a?(FalseClass) ||
-      o.is_a?(Regexp) ||
-      o.instance_of?(Array) ||
-      o.instance_of?(Hash) ||
-      Types::PUndefType::DEFAULT.instance?(o)
-      )
-      return nil
-    end
-    # For other objects (e.g. PObjectType instances, and runtime types) full inference needed, since that will
-    # cover looking into the runtime type registry.
-    #
-    infer(o)
-  end
-
   # @api public
   def self.generalize(o)
     singleton.generalize(o)

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

@@ -6,6 +6,19 @@ module Types
 module TypeFactory
   @type_calculator = TypeCalculator.singleton
 
+  # Clears caches - used when testing
+  def self.clear
+    # these types are cached and needs to be nulled as the representation may change if loaders are cleared
+    @data_t = nil
+    @rich_data_t = nil
+    @rich_data_key_t = nil
+    @array_of_data_t = nil
+    @hash_of_data_t = nil
+    @error_t = nil
+    @task_t = nil
+    @deferred_t = nil
+  end
+
   # Produces the Integer type
   # @api public
   #
@@ -526,6 +539,10 @@ module TypeFactory
     @task_t ||= TypeParser.singleton.parse('Task')
   end
 
+  def self.deferred
+    @deferred_t ||= TypeParser.singleton.parse('Deferred')
+  end
+
   # Produces a type for URI[String or Hash]
   # @api public
   #

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

@@ -753,7 +753,7 @@ module Types
     end
 
     def describe_POptionalType(expected, original, actual, path)
-      return EMPTY_ARRAY if actual.is_a?(PUndefType) || expected.optional_type.nil?
+      return EMPTY_ARRAY if actual.is_a?(PUndefType)
       internal_describe(expected.optional_type, original.is_a?(PTypeAliasType) ? original : expected, actual, path)
     end
 

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

@@ -340,7 +340,7 @@ class PAnyType < TypedModelObject
   # @raises ArgumentError
   #
   def self.new_function(type)
-    raise ArgumentError.new("Creation of new instance of type '#{type}' is not supported")
+    raise ArgumentError.new("Creation of new instance of type '#{type.to_s}' is not supported")
   end
 
   # Answers the question if instances of this type can represent themselves as a string that
@@ -843,16 +843,14 @@ INTEGER_HEX = '(?:0[xX][0-9A-Fa-f]+)'
 INTEGER_OCT = '(?:0[0-7]+)'
 INTEGER_BIN = '(?:0[bB][01]+)'
 INTEGER_DEC = '(?:0|[1-9]\d*)'
-INTEGER_DEC_OR_OCT = '(?:\d+)'
 SIGN_PREFIX = '[+-]?\s*'
 
 OPTIONAL_FRACTION = '(?:\.\d+)?'
 OPTIONAL_EXPONENT = '(?:[eE]-?\d+)?'
 FLOAT_DEC = '(?:' + INTEGER_DEC + OPTIONAL_FRACTION + OPTIONAL_EXPONENT + ')'
 
-INTEGER_PATTERN          = '\A' + SIGN_PREFIX + '(?:' + INTEGER_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
-INTEGER_PATTERN_LENIENT = '\A' + SIGN_PREFIX + '(?:' + INTEGER_DEC_OR_OCT + '|' + INTEGER_HEX + '|' + INTEGER_BIN + ')\z'
-FLOAT_PATTERN            = '\A' + SIGN_PREFIX + '(?:' + FLOAT_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
+INTEGER_PATTERN = '\A' + SIGN_PREFIX + '(?:' + INTEGER_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
+FLOAT_PATTERN = '\A' + SIGN_PREFIX + '(?:' + FLOAT_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
 
 # @api public
 #
@@ -1091,7 +1089,7 @@ class PIntegerType < PNumericType
     @@new_function ||= Puppet::Functions.create_loaded_function(:new, loader) do
       local_types do
         type 'Radix       = Variant[Default, Integer[2,2], Integer[8,8], Integer[10,10], Integer[16,16]]'
-        type "Convertible = Variant[Numeric, Boolean, Pattern[/#{INTEGER_PATTERN_LENIENT}/], Timespan, Timestamp]"
+        type "Convertible = Variant[Numeric, Boolean, Pattern[/#{INTEGER_PATTERN}/], Timespan, Timestamp]"
         type 'NamedArgs   = Struct[{from => Convertible, Optional[radix] => Radix, Optional[abs] => Boolean}]'
       end
 
@@ -1268,7 +1266,7 @@ class PFloatType < PNumericType
         else
           begin
             # support a binary as float
-            if from[0] == '0' && from[1].casecmp('b').zero?
+            if from[0] == '0' && from[1].downcase == 'b'
               from = Integer(from)
             end
             Float(from)
@@ -1699,36 +1697,13 @@ class PRegexpType < PScalarType
   # @param regexp [Regexp] the regular expression
   # @return [String] the Regexp as a slash delimited string with slashes escaped
   def self.regexp_to_s_with_delimiters(regexp)
-    regexp.options == 0 ? regexp.inspect : "/#{regexp}/"
+    regexp.options == 0 ? regexp.inspect : "/#{regexp.to_s}/"
   end
 
   # @param regexp [Regexp] the regular expression
   # @return [String] the Regexp as a string without escaped slash
   def self.regexp_to_s(regexp)
-    # Rubies < 2.0.0 retains escaped delimiters in the source string.
-    @source_retains_escaped_slash ||= Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.0.0')
-    source = regexp.source
-    if @source_retains_escaped_slash && source.include?('\\')
-      # Restore corrupt string in rubies <2.0.0, i.e. turn '\/' into '/' but
-      # don't touch valid escapes such as '\s', '\{' etc.
-      escaped = false
-      bld = ''
-      source.each_codepoint do |codepoint|
-        if escaped
-          bld << 0x5c unless codepoint == 0x2f # '/'
-          bld << codepoint
-          escaped = false
-        elsif codepoint == 0x5c # '\'
-          escaped = true
-        elsif codepoint <= 0x7f
-          bld << codepoint
-        else
-          bld << [codepoint].pack('U')
-        end
-      end
-      source = bld
-    end
-    append_flags_group(source, regexp.options)
+    append_flags_group(regexp.source, regexp.options)
   end
 
   def self.append_flags_group(rx_string, options)

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

@@ -194,11 +194,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 '='
@@ -296,7 +291,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_CapabilityMapping(o)
-    acceptor.accept(Issues::DEPRECATED_APP_ORCHESTRATION, o, {:klass => o})
     ok =
     case o.component
     when Model::QualifiedReference
@@ -565,8 +559,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     return if namespace_for_file(file) == NO_NAMESPACE
 
     body = prog.body
-    return if prog.body.is_a?(Model::Nop) #Ignore empty or comment-only files
-
     if(body.is_a?(Model::BlockExpression))
       body.statements.each { |s| acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, s) unless valid_top_construct?(s) }
     else
@@ -581,40 +573,36 @@ 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?
 
-    adapter = Puppet::Util::FileNamespaceAdapter.adapt(env)
+    Puppet::Util::FileNamespaceAdapter.adapt(env) do |adapter|
+      adapter.file_to_namespace ||= {}
 
-    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)
+      return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
+    end
   end
 
   def initial_manifest?(path, manifest_setting)
@@ -635,9 +623,9 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def is_parent_dir_of(parent_dir, child_dir)
     parent_dir_path = Pathname.new(parent_dir)
-    clean_parent = parent_dir_path.cleanpath.to_s + File::SEPARATOR
+    clean_parent = parent_dir_path.cleanpath
 
-    return child_dir.to_s.start_with?(clean_parent)
+    return child_dir.to_s.start_with?(clean_parent.to_s)
   end
 
   def dir_to_names(relative_path)
@@ -860,10 +848,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
@@ -1102,6 +1086,12 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     true
   end
 
+  # An apply expression exists purely for the side effect of applying a
+  # catalog somewhere, so it always has side effects
+  def idem_ApplyExpression(o)
+    false
+  end
+
   def idem_IfExpression(o)
     [o.test, o.then_expr, o.else_expr].all? {|e| idem(e) }
   end

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

@@ -4,6 +4,15 @@ module Validation
 # Validator that limits the set of allowed expressions to not include catalog related operations
 # @api private
 class TasksChecker < Checker4_0
+  def in_ApplyExpression?
+    top = container(0)
+    step = -1
+    until container(step) == top do
+      return true if container(step).is_a? Puppet::Pops::Model::ApplyBlockExpression
+      step -= 1
+    end
+  end
+
   def check_Application(o)
     illegalTasksExpression(o)
   end
@@ -13,7 +22,17 @@ class TasksChecker < Checker4_0
   end
 
   def check_CollectExpression(o)
-    illegalTasksExpression(o)
+    # Only virtual resource queries are allowed in apply blocks, not exported
+    # resource queries
+    if in_ApplyExpression?
+      if o.query.is_a?(Puppet::Pops::Model::VirtualQuery)
+        super(o)
+      else
+        acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, {:klass => o})
+      end
+    else
+      illegalTasksExpression(o)
+    end
   end
 
   def check_HostClassDefinition(o)
@@ -25,19 +44,35 @@ class TasksChecker < Checker4_0
   end
 
   def check_RelationshipExpression(o)
-    illegalTasksExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
   end
 
   def check_ResourceDefaultsExpression(o)
-    illegalTasksExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
   end
 
   def check_ResourceExpression(o)
-    illegalTasksExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
   end
 
   def check_ResourceOverrideExpression(o)
-    illegalTasksExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
   end
 
   def check_ResourceTypeDefinition(o)
@@ -48,8 +83,14 @@ class TasksChecker < Checker4_0
     illegalTasksExpression(o)
   end
 
+  def check_ApplyExpression(o)
+    if in_ApplyExpression?
+      acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, {:klass => o})
+    end
+  end
+
   def illegalTasksExpression(o)
-    acceptor.accept(Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING, o)
+    acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING, o, {:klass => o})
   end
 
   def resource_without_title?(o)