puppet 5.0.0 → 6.0.0

data/lib/puppet/pops/pcore.rb

@@ -31,7 +31,54 @@ 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 implementations with requirements
+            implementations => { type => Array[Struct[name => String, path => String, Optional[requirements] => Array[String]], 1] },
+
+            # Task description
+            description => { type => Optional[String], value => undef },
+
+            # Puppet Task version
+            puppet_task_version => { type => Integer, value => 1 },
+
+            # Type, description, and sensitive property of each parameter
+            parameters => {
+              type => Optional[Hash[
+                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
+                Struct[
+                  Optional[description] => String,
+                  Optional[sensitive] => Boolean,
+                  type => Type]]],
+              value => undef
+            },
+
+             # Type, description, and sensitive property of each output
+            output => {
+              type => Optional[Hash[
+                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
+                Struct[
+                  Optional[description] => String,
+                  Optional[sensitive] => Boolean,
+                  type => Type]]],
+              value => undef
+            },
+
+            supports_noop => { type => Boolean, value => false },
+            input_method => { type => Optional[String] },
+          }
+        }
+      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 +89,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 +127,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
 
@@ -96,8 +152,7 @@ module Pcore
     aliases.each do |name, type_string|
       add_type(Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(type_string), nil), loader, name_authority)
     end
-    parser = Types::TypeParser.singleton
-    aliases.each_key.map { |name| loader.load(:type, name).resolve(parser, loader) }
+    aliases.each_key.map { |name| loader.load(:type, name).resolve(loader) }
   end
 end
 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

@@ -17,6 +17,9 @@ module Puppet::Pops
 # will be represented with the text `unknown` and `0´ respectively.
 #
 module PuppetStack
+  # Pattern matching an entry in the ruby stack that is a puppet entry
+  PP_ENTRY_PATTERN = /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function'|`<eval>')/
+
   # Sends a message to an obj such that it appears to come from
   # file, line when calling stacktrace.
   #
@@ -33,11 +36,22 @@ module PuppetStack
 
   def self.stacktrace
     caller().reduce([]) do |memo, loc|
-      if loc =~ /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function')/
+      if loc =~ PP_ENTRY_PATTERN
         memo << [$1.nil? ? 'unknown' : $1, $2.to_i]
       end
       memo
     end
   end
+
+  # 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
+    caller.each do |loc|
+      if loc =~ PP_ENTRY_PATTERN
+        return [$1.nil? ? 'unknown' : $1, $2.to_i]
+      end
+    end
+    []
+  end
 end
 end

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

@@ -15,13 +15,13 @@
 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)
     @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::Param', nil,
       {
-        Types::KEY_TYPE => Types::PType::DEFAULT,
+        Types::KEY_TYPE => Types::PTypeType::DEFAULT,
         Types::KEY_NAME => Types::PStringType::NON_EMPTY,
         'name_var' => {
           Types::KEY_TYPE => Types::PBooleanType::DEFAULT,

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

@@ -7,11 +7,11 @@ def self.register_ptypes(loader, ir)
   types = [Param, ResourceTypeImpl].map do |c|
     c.register_ptype(loader, ir)
   end
-  types.each {|t| t.resolve(Types::TypeParser.singleton, loader) }
+  types.each {|t| t.resolve(loader) }
 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.
@@ -164,7 +164,7 @@ class ResourceTypeImpl
           # the 'package' type where 'provider' attribute is handled as part of the key without being
           # set from the title.
           #
-          raise Puppet::DevError,"you must specify title patterns when there are two or more key attributes"
+          raise Puppet::DevError, _("you must specify title patterns when there are two or more key attributes")
         end
         @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym] } ] }
       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

@@ -99,7 +99,8 @@ class AbstractWriter
   #
   # @api private
   def write_tpl(ep, value)
-    raise ArgumentError, 'Internal error. Integers cannot be tabulated in extension payload' if value.is_a?(Integer)
+    #TRANSLATORS 'Integers' is a Ruby class for numbers and should not be translated
+    raise ArgumentError, _('Internal error. Integers cannot be tabulated in extension payload') if value.is_a?(Integer)
     if @tabulate
       index = @written[value]
       if index.nil?
@@ -201,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,34 +208,17 @@ 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))
       else
-        raise SerializationError, _('Cannot create a %{type_name} from a %{arg_class') %
+        raise SerializationError, _('Cannot create a %{type_name} from a %{arg_class}') %
             { :type_name => pcore_type.name, :arg_class => value.class.name }
       end
     end
-
-    def data_to_pcore_type(pcore_type)
-      if pcore_type.is_a?(Hash)
-        without_value { convert(pcore_type) }
-      else
-        type = Types::TypeParser.singleton.parse(pcore_type, @loader)
-        if type.is_a?(Types::PTypeReferenceType)
-          raise SerializationError, _('No implementation mapping found for Puppet Type %{type_name}') % { type_name: pcore_type }
-        end
-        type
-      end
-    end
   end
 end
 end

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

@@ -26,7 +26,7 @@ module JsonPath
   # with '$' which denotes the value that is passed into the parser. This parser can easily
   # be extended with more elaborate resolution mechanisms involving document sets.
   #
-  # The parser is limited to constructs generated by the {JsonPath#json_path_reference}
+  # The parser is limited to constructs generated by the {JsonPath#to_json_path}
   # method.
   #
   # @api private
@@ -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)