puppet 5.3.4 → 6.29.0

data/lib/puppet/pops/pcore.rb

@@ -31,7 +31,31 @@ module Pcore
     instance
   end
 
-  def self.init(loader, ir, for_agent)
+  def self.init_env(loader)
+    if Puppet[:tasks]
+      add_object_type('Task', <<-PUPPET, loader)
+        {
+          attributes => {
+            # Fully qualified name of the task
+            name => { type => Pattern[/\\A[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] },
+
+            # List of file references referenced by metadata and their paths on disk.
+            # If there are no implementations listed in metadata, the first file is always
+            # the task executable.
+            files => { type => Array[Struct[name => String, path => String]] },
+
+            # Task metadata
+            metadata => { type => Hash[String, Any] },
+
+            # Map parameter names to their parsed data type
+            parameters => { type => Optional[Hash[Pattern[/\\A[a-z][a-z0-9_]*\\z/], Type]], value => undef },
+          }
+        }
+      PUPPET
+    end
+  end
+
+  def self.init(loader, ir)
     add_alias('Pcore::URI_RX', TYPE_URI_RX, loader)
     add_type(TYPE_URI_ALIAS, loader)
     add_alias('Pcore::SimpleTypeName', TYPE_SIMPLE_TYPE_NAME, loader)
@@ -42,14 +66,23 @@ module Pcore
 
     @type = create_object_type(loader, ir, Pcore, 'Pcore', nil)
 
-    ir.register_implementation_namespace('Pcore', 'Puppet::Pops::Pcore', loader)
-    ir.register_implementation_namespace('Puppet::AST', 'Puppet::Pops::Model', loader)
-    ir.register_implementation('Puppet::AST::Locator', 'Puppet::Pops::Parser::Locator::Locator19', loader)
-    unless for_agent
-      Resource.register_ptypes(loader, ir)
-      Lookup::Context.register_ptype(loader, ir);
-      Lookup::DataProvider.register_types(loader)
-    end
+    ir.register_implementation_namespace('Pcore', 'Puppet::Pops::Pcore')
+    ir.register_implementation_namespace('Puppet::AST', 'Puppet::Pops::Model')
+    ir.register_implementation('Puppet::AST::Locator', 'Puppet::Pops::Parser::Locator::Locator19')
+    Resource.register_ptypes(loader, ir)
+    Lookup::Context.register_ptype(loader, ir);
+    Lookup::DataProvider.register_types(loader)
+
+    add_object_type('Deferred', <<-PUPPET, loader)
+      {
+        attributes => {
+          # Fully qualified name of the function
+          name  => { type => Pattern[/\\A[$]?[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] },
+          arguments => { type => Optional[Array[Any]], value => undef},
+        }
+      }
+    PUPPET
+
   end
 
   # Create and register a new `Object` type in the Puppet Type System and map it to an implementation class
@@ -71,7 +104,7 @@ module Pcore
     init_hash[Types::KEY_ATTRIBUTES] = attributes_hash unless attributes_hash.empty?
     init_hash[Types::KEY_FUNCTIONS] = functions_hash unless functions_hash.empty?
     init_hash[Types::KEY_EQUALITY] = equality unless equality.nil?
-    ir.register_implementation(type_name, impl_class, loader)
+    ir.register_implementation(type_name, impl_class)
     add_type(Types::PObjectType.new(type_name, init_hash), loader)
   end
 

data/lib/puppet/pops/pn.rb

@@ -0,0 +1,236 @@
+module Puppet::Pops
+module PN
+  KEY_PATTERN = /^[A-Za-z_-][0-9A-Za-z_-]*$/
+
+  def pnError(message)
+    raise ArgumentError, message
+  end
+
+  def as_call(name)
+    Call.new(name, self)
+  end
+
+  def as_parameters
+    [self]
+  end
+
+  def ==(o)
+    eql?(o)
+  end
+
+  def to_s
+    s = ''
+    format(nil, s)
+    s
+  end
+
+  def with_name(name)
+    Entry.new(name, self)
+  end
+
+  def double_quote(str, bld)
+    bld << '"'
+    str.each_codepoint do |codepoint|
+      case codepoint
+      when 0x09
+        bld << '\\t'
+      when 0x0a
+        bld << '\\n'
+      when 0x0d
+        bld << '\\r'
+      when 0x22
+        bld << '\\"'
+      when 0x5c
+        bld << '\\\\'
+      else
+        if codepoint < 0x20
+          bld << sprintf('\\o%3.3o', codepoint)
+        elsif codepoint <= 0x7f
+          bld << codepoint
+        else
+          bld << [codepoint].pack('U')
+        end
+      end
+    end
+    bld << '"'
+  end
+
+  def format_elements(elements, indent, b)
+    elements.each_with_index do |e, i|
+      if indent
+        b << "\n" << indent.current
+      elsif i > 0
+        b << ' '
+      end
+      e.format(indent, b)
+    end
+  end
+
+  class Indent
+    attr_reader :current
+    def initialize(indent = '  ', current = '')
+      @indent = indent
+      @current = current
+    end
+
+    def increase
+      Indent.new(@indent, @current + @indent)
+    end
+  end
+
+  class Call
+    include PN
+    attr_reader :name, :elements
+
+    def initialize(name, *elements)
+      @name = name
+      @elements = elements
+    end
+
+    def [](idx)
+      @elements[idx]
+    end
+
+    def as_call(name)
+      Call.new(name, *@elements)
+    end
+
+    def as_parameters
+      List.new(@elements)
+    end
+
+    def eql?(o)
+      o.is_a?(Call) && @name == o.name && @elements == o.elements
+    end
+
+    def format(indent, b)
+      b << '(' << @name
+      if @elements.size > 0
+        b << ' ' unless indent
+        format_elements(@elements, indent ? indent.increase : nil, b)
+      end
+      b << ')'
+    end
+
+    def to_data
+      { '^' => [@name] + @elements.map { |e| e.to_data } }
+    end
+  end
+
+  class Entry
+    attr_reader :key, :value
+    def initialize(key, value)
+      @key = key
+      @value = value
+    end
+
+    def eql?(o)
+      o.is_a?(Entry) && @key == o.key && @value == o.value
+    end
+
+    alias == eql?
+  end
+
+  class List
+    include PN
+    attr_reader :elements
+
+    def initialize(elements)
+      @elements = elements
+    end
+
+    def [](idx)
+      @elements[idx]
+    end
+
+    def as_call(name)
+      Call.new(name, *@elements)
+    end
+
+    def as_parameters
+      @elements
+    end
+
+    def eql?(o)
+      o.is_a?(List) && @elements == o.elements
+    end
+
+    def format(indent, b)
+      b << '['
+      format_elements(@elements, indent ? indent.increase : nil, b) unless @elements.empty?
+      b << ']'
+    end
+
+    def to_data
+      @elements.map { |e| e.to_data }
+    end
+  end
+
+  class Literal
+    include PN
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def format(indent, b)
+      if @value.nil?
+        b << 'nil'
+      elsif value.is_a?(String)
+        double_quote(value, b)
+      else
+        b << value.to_s
+      end
+    end
+
+    def eql?(o)
+      o.is_a?(Literal) && @value == o.value
+    end
+
+    def to_data
+      @value
+    end
+  end
+
+  class Map
+    include PN
+    attr_reader :entries
+
+    def initialize(entries)
+      entries.each { |e| pnError("key #{e.key} does not conform to pattern /#{KEY_PATTERN.source}/)") unless e.key =~ KEY_PATTERN }
+      @entries = entries
+    end
+
+    def eql?(o)
+      o.is_a?(Map) && @entries == o.entries
+    end
+
+    def format(indent, b)
+      local_indent = indent ? indent.increase : nil
+      b << '{'
+      @entries.each_with_index do |e,i|
+        if indent
+          b << "\n" << local_indent.current
+        elsif i > 0
+          b << ' '
+        end
+        b << ':' << e.key
+        b << ' '
+        e.value.format(local_indent, b)
+      end
+      b << '}'
+    end
+
+    def to_data
+      r = []
+      @entries.each { |e| r << e.key << e.value.to_data }
+      { '#' => r }
+    end
+  end
+end
+end
+
+require_relative 'model/pn_transformer'
+require_relative 'parser/pn_parser'
+

data/lib/puppet/pops/puppet_stack.rb

@@ -1,43 +1,61 @@
-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
-  # 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?
+require 'puppet/thread_local'
 
-    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
+module Puppet
+  module Pops
+    # Utility class for keeping track of the "Puppet stack", ie the file
+    # and line numbers of Puppet Code that created the current context.
+    #
+    # To use this make a call with:
+    #
+    # ```rb
+    # Puppet::Pops::PuppetStack.stack(file, line, receiver, message, args)
+    # ```
+    #
+    # To get the stack call:
+    #
+    # ```rb
+    # Puppet::Pops::PuppetStack.stacktrace
+    # ```
+    #
+    # or
+    #
+    # ```rb
+    # Puppet::Pops::PuppetStack.top_of_stack
+    # ```
+    #
+    # 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
+      @stack = Puppet::ThreadLocal.new { Array.new }
+
+      def self.stack(file, line, obj, message, args, &block)
+        file = 'unknown' if (file.nil? || file == '')
+        line = 0 if line.nil?
+
+        result = nil
+        @stack.value.unshift([file, line])
+        begin
+          if block_given?
+            result = obj.send(message, *args, &block)
+          else
+            result = obj.send(message, *args)
+          end
+        ensure
+          @stack.value.shift()
+        end
+        result
+      end
+
+      def self.stacktrace
+        @stack.value.dup
+      end
 
-  def self.stacktrace
-    caller().reduce([]) do |memo, loc|
-      if loc =~ /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function')/
-        memo << [$1.nil? ? 'unknown' : $1, $2.to_i]
+      # 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
+        @stack.value.first || []
       end
-      memo
     end
   end
 end
-end

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

@@ -15,7 +15,7 @@
 module Puppet::Pops
 module Resource
 class Param
-  # This make this class instantiateable from Puppet
+  # This make this class instantiable from Puppet
   include Puppet::Pops::Types::PuppetObject
 
   def self.register_ptype(loader, ir)

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

@@ -11,7 +11,7 @@ def self.register_ptypes(loader, ir)
 end
 
 class ResourceTypeImpl
-  # Make instances of this class directly createable from the Puppet Language
+  # Make instances of this class directly creatable from the Puppet Language
   # as object.
   #
   include Puppet::Pops::Types::PuppetObject
@@ -149,7 +149,7 @@ class ResourceTypeImpl
         # Here it is silently ignored.
         nil
       when 1
-        if @title_pattners_hash.nil?
+        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.
@@ -248,6 +248,8 @@ class ResourceTypeImpl
   #######################
 
   # Applications are not supported
+  #
+  # @deprecated application orchestration will be removed in puppet 7
   def application?
     false
   end

data/lib/puppet/pops/serialization/abstract_reader.rb

@@ -170,6 +170,10 @@ class AbstractReader
       # are written as binary data.
       read_payload(data) { |ep| Types::PBinaryType::Binary.new(ep.read) }
     end
+
+    register_type(Extension::URI) do |data|
+      read_payload(data) { |ep| URI(ep.read) }
+    end
   end
 end
 end

data/lib/puppet/pops/serialization/abstract_writer.rb

@@ -202,6 +202,12 @@ class AbstractWriter
         build_payload { |ep| ep.write(o.to_s) }
       end
     end
+
+    URI.scheme_list.values.each do |uri_class|
+      register_type(Extension::URI, uri_class) do |o|
+        build_payload { |ep| ep.write(o.to_s) }
+      end
+    end
   end
 
   def to_s

data/lib/puppet/pops/serialization/extension.rb

@@ -30,6 +30,7 @@ module Extension
   VERSION_RANGE = 0x36
   BINARY = 0x37
   BASE64 = 0x38
+  URI    = 0x39
 
   # Marker module indicating whether or not an instance is tabulated or not
   module NotTabulated; end

data/lib/puppet/pops/serialization/from_data_converter.rb

@@ -1,5 +1,57 @@
 module Puppet::Pops
 module Serialization
+  class Builder
+    def initialize(values)
+      @values = values
+      @resolved = true
+    end
+
+    def [](key)
+      @values[key]
+    end
+
+    def []=(key, value)
+      @values[key] = value
+      @resolved = false if value.is_a?(Builder)
+    end
+
+    def resolve
+      unless @resolved
+        @resolved = true
+        if @values.is_a?(Array)
+          @values.each_with_index { |v, idx| @values[idx] = v.resolve if v.is_a?(Builder) }
+        elsif @values.is_a?(Hash)
+          @values.each_pair { |k, v| @values[k] = v.resolve if v.is_a?(Builder) }
+        end
+      end
+      @values
+    end
+  end
+
+  class ObjectHashBuilder < Builder
+    def initialize(instance)
+      super({})
+      @instance = instance
+    end
+
+    def resolve
+      @instance._pcore_init_from_hash(super)
+      @instance
+    end
+  end
+
+  class ObjectArrayBuilder < Builder
+    def initialize(instance)
+      super({})
+      @instance = instance
+    end
+
+    def resolve
+      @instance.send(:initialize, *super.values)
+      @instance
+    end
+  end
+
   # Class that can process the `Data` produced by the {ToDataConverter} class and reassemble
   # the objects that were converted.
   #
@@ -12,7 +64,7 @@ module Serialization
     # @option options [Loaders::Loader] :loader the loader to use. Can be `nil` in which case the default is
     #    determined by the {Types::TypeParser}.
     # @option options [Boolean] :allow_unresolved `true` to allow that rich_data hashes are kept "as is" if the
-    #    designated '__pcore_type__' cannot be resolved. Defaults to `false`.
+    #    designated '__ptype' cannot be resolved. Defaults to `false`.
     # @return [RichData] the processed result.
     #
     # @api public
@@ -26,7 +78,7 @@ module Serialization
     # @option options [Loaders::Loader] :loader the loader to use. Can be `nil` in which case the default is
     #    determined by the {Types::TypeParser}.
     # @option options [Boolean] :allow_unresolved `true` to allow that rich_data hashes are kept "as is" if the
-    #    designated '__pcore_type__' cannot be resolved. Defaults to `false`.
+    #    designated '__ptype' cannot be resolved. Defaults to `false`.
     #
     # @api public
     def initialize(options = EMPTY_HASH)
@@ -83,6 +135,7 @@ module Serialization
             end
             hash
           else
+            # not a string
             pcore_type_hash_to_value(type, value)
           end
         end
@@ -98,7 +151,7 @@ module Serialization
     def convert(value)
       if value.is_a?(Hash)
         pcore_type = value[PCORE_TYPE_KEY]
-        if pcore_type
+        if pcore_type && (pcore_type.is_a?(String) || pcore_type.is_a?(Hash))
           @pcore_type_procs[pcore_type].call(value, pcore_type)
         else
           build({}) { value.each_pair { |key, elem| with(key) { convert(elem) }}}
@@ -137,9 +190,16 @@ module Serialization
     end
 
     def build(value, &block)
-      @current[@key] = value unless @current.nil?
-      with_value(value, &block) if block_given?
-      value
+      vx = Builder.new(value)
+      @current[@key] = vx unless @current.nil?
+      with_value(vx, &block) if block_given?
+      vx.resolve
+    end
+
+    def build_object(builder, &block)
+      @current[@key] = builder unless @current.nil?
+      with_value(builder, &block) if block_given?
+      builder.resolve
     end
 
     def pcore_type_hash_to_value(pcore_type, value)
@@ -148,14 +208,9 @@ module Serialization
         if value.empty?
           build(pcore_type.create)
         elsif pcore_type.implementation_class.respond_to?(:_pcore_init_from_hash)
-          build(pcore_type.allocate) do
-            @current._pcore_init_from_hash(with_value({}) { value.each_pair { |key, elem| with(key) { convert(elem) } } })
-          end
+          build_object(ObjectHashBuilder.new(pcore_type.allocate)) { value.each_pair { |key, elem| with(key) { convert(elem) } } }
         else
-          build(pcore_type.allocate) do
-            args = with_value([]) { value.values.each_with_index { |elem, idx| with(idx) { convert(elem) }}}
-            @current.send(:initialize, *args)
-          end
+          build_object(ObjectArrayBuilder.new(pcore_type.allocate)) { value.each_pair { |key, elem| with(key) { convert(elem) } } }
         end
       elsif value.is_a?(String)
         build(pcore_type.create(value))

data/lib/puppet/pops/serialization/json.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 
 module Puppet::Pops
 module Serialization
@@ -146,12 +146,12 @@ module JSON
     end
 
     def to_a
-      ::JSON.parse(io_string)
+      ::Puppet::Util::Json.load(io_string)
     end
 
     def to_json
       if @indent > 0
-        ::JSON.pretty_unparse(to_a, { :indent => ' ' * @indent })
+        ::Puppet::Util::Json.dump(to_a, { :pretty => true, :indent => ' ' * @indent })
       else
         io_string
       end
@@ -159,7 +159,7 @@ module JSON
 
     # Write a payload object. Not subject to extensions
     def write_pl(obj)
-      @io << obj.to_json << ','
+      @io << Puppet::Util::Json.dump(obj) << ','
     end
 
     def io_string
@@ -198,7 +198,7 @@ module JSON
       if ext.nil?
         case obj
         when Numeric, String, true, false, nil
-          @io << obj.to_json
+          @io << Puppet::Util::Json.dump(obj)
           write_delim
         else
           raise SerializationError, _("Unable to serialize a %{obj}") % { obj: obj.class.name }
@@ -284,9 +284,9 @@ module JSON
     def parse_io(io)
       case io
       when IO, StringIO
-        ::JSON.parse(io.read)
+        ::Puppet::Util::Json.load(io.read)
       when String
-        ::JSON.parse(io)
+        ::Puppet::Util::Json.load(io)
       else
         io
       end

data/lib/puppet/pops/serialization/json_path.rb

@@ -1,3 +1,5 @@
+require 'puppet/concurrent/thread_local_singleton'
+
 module Puppet::Pops
 module Serialization
 module JsonPath
@@ -31,9 +33,7 @@ module JsonPath
   #
   # @api private
   class Resolver
-    def self.singleton
-      @singleton ||= self.new
-    end
+    extend Puppet::Concurrent::ThreadLocalSingleton
 
     def initialize
       @parser = Parser::Parser.new
@@ -47,7 +47,8 @@ module JsonPath
     #
     def resolve(context, path)
       factory = @parser.parse_string(path)
-      resolve_any(factory.model.body, context, path)
+      v = resolve_any(factory.model.body, context, path)
+      v.is_a?(Builder) ? v.resolve : v
     end
 
     def resolve_any(ast, context, path)