puppet 5.3.7-x64-mingw32 → 5.4.0-x64-mingw32

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

@@ -123,7 +123,7 @@ module EppSupport
   # The scanner supports
   # * scanning text until <%, <%-, <%=
   # * while scanning text:
-  #   * tokens <%% and %%> are translated to <% and %> respetively and is returned as text.
+  #   * tokens <%% and %%> are translated to <% and %>, respectively, and is returned as text.
   #   * tokens <%# and %> (or ending with -%>) and the enclosed text is a comment and is not included in the returned text
   #   * text following a comment that ends with -%> gets trailing whitespace (up to and including a line break) trimmed
   #     and this whitespace is not included in the returned text.
@@ -201,8 +201,6 @@ module EppSupport
           if s.end_with? "<%"
             @mode = :error
             @issue = Issues::EPP_UNBALANCED_EXPRESSION
-          else
-            mode = :epp
           end
           return s
 

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

@@ -80,7 +80,7 @@ class EvaluatingParser
   end
 
   def convert_to_3x(object, scope)
-    val = evaluator.convert(object, scope, nil)
+    evaluator.convert(object, scope, nil)
   end
 
   def validate(parse_result)

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

@@ -10,7 +10,7 @@ module Puppet::Pops::Parser::InterpolationSupport
 
   # This is the starting point for a double quoted string with possible interpolation
   # The structure mimics that of the grammar.
-  # The logic is explicit (where the former implementation used parameters/strucures) given to a
+  # The logic is explicit (where the former implementation used parameters/structures) given to a
   # generic handler.
   # (This is both easier to understand and faster).
   #
@@ -221,7 +221,7 @@ module Puppet::Pops::Parser::InterpolationSupport
 
   def transform_to_variable(token)
     token_name = token[0]
-    if [:NUMBER, :NAME, :WORD].include?(token_name) || self.class::KEYWORD_NAMES[token_name]
+    if [:NUMBER, :NAME, :WORD].include?(token_name) || self.class::KEYWORD_NAMES[token_name] || @taskm_keywords[token_name]
       t = token[1]
       ta = t.token_array
       [:VARIABLE, self.class::TokenValue.new([:VARIABLE, ta[1], ta[2]], t.offset, t.locator)]

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

@@ -1,4 +1,4 @@
-# The Lexer is responsbile for turning source text into tokens.
+# 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.
 #
 # Old returns tokens [:KEY, value, { locator = }
@@ -513,7 +513,6 @@ class Lexer2
             scn.pos = before
             invalid_number = scn.peek(after - before) unless invalid_number
           end
-          length = scn.pos - before
           assert_numeric(invalid_number, before)
           scn.pos = before + 1
           lex_error(Issues::ILLEGAL_NUMBER, {:value => invalid_number})
@@ -523,12 +522,11 @@ class Lexer2
     ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
       'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '_'].each do |c|
       @selector[c] = lambda do
-
         scn = @scanner
         before = scn.pos
         value = scn.scan(PATTERN_BARE_WORD)
         if value && value =~ PATTERN_NAME
-          emit_completed(KEYWORDS[value] || [:NAME, value.freeze, scn.pos - before], before)
+          emit_completed(KEYWORDS[value] || @taskm_keywords[value] || [:NAME, value.freeze, scn.pos - before], before)
         elsif value
           emit_completed([:WORD, value.freeze, scn.pos - before], before)
         else
@@ -663,6 +661,8 @@ class Lexer2
       :after => nil,
       :line_lexical_start => 0
     }
+    # Use of --tasks introduces the new keyword 'plan'
+    @taskm_keywords = Puppet[:tasks] ? { 'plan' => [:PLAN, 'plan',  4] }.freeze : EMPTY_HASH
   end
 
   # Scans all of the content and returns it in an array

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

@@ -135,7 +135,7 @@ module LexerSupport
     end
 
     def to_s
-      # This format is very compact and is intended for debugging output from racc parsser in
+      # This format is very compact and is intended for debugging output from racc parser in
       # debug mode. If this is made more elaborate the output from a debug run becomes very hard to read.
       #
       "'#{self[:value]} #{@token_array[0]}'"
@@ -204,7 +204,7 @@ module LexerSupport
 
   def get_bom(content)
     # get 5 bytes as efficiently as possible (none of the string methods works since a bom consists of
-    # illegal characters on most platforms, and there is no get_bytes(n). xplicit calls are faster than
+    # illegal characters on most platforms, and there is no get_bytes(n). Explicit calls are faster than
     # looping with a lambda. The get_byte returns nil if there are too few characters, and they
     # are changed to spaces
     MM.new(

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

@@ -1,4 +1,4 @@
-# Interface for something that is "locateable" (holds offset and length).
+# Interface for something that is "locatable" (holds offset and length).
 class Puppet::Pops::Parser::Locatable
 
   # The offset in the locator's content

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

@@ -43,11 +43,7 @@ class Locator
   def char_offset(byte_offset)
   end
 
-  # Returns the length measured in number of characters from the given start and end reported offset
-  def char_length(offset, end_offset)
-  end
-
-  # Returns the length measured in number of characters from the given start and end byte offseta
+  # Returns the length measured in number of characters from the given start and end byte offset
   def char_length(offset, end_offset)
   end
 
@@ -164,8 +160,6 @@ class Locator
   class AbstractLocator < Locator
     attr_accessor :line_index
     attr_accessor :string
-    attr_accessor :prev_offset
-    attr_accessor :prev_line
     attr_reader   :string
     attr_reader   :file
 
@@ -255,19 +249,19 @@ class Locator
 
     # Returns the line number (first line is 1) for the given offset
     def line_for_offset(offset)
-      if prev_offset == offset
+      if @prev_offset == offset
         # use cache
-        return prev_line
+        return @prev_line
       end
       if line_nbr = ary_bsearch_i(line_index, offset)
         # cache
-        prev_offset = offset
-        prev_line = line_nbr
+        @prev_offset = offset
+        @prev_line = line_nbr
         return line_nbr
       end
       # If not found it is after last
       # clear cache
-      prev_offset = prev_line = nil
+      @prev_offset = @prev_line = nil
       return line_index.size
     end
   end
@@ -328,7 +322,7 @@ class Locator
       string.byteslice(0, byte_offset).length
     end
 
-    # Returns the length measured in number of characters from the given start and end byte offseta
+    # Returns the length measured in number of characters from the given start and end byte offset
     def char_length(offset, end_offset)
       string.byteslice(offset, end_offset - offset).length
     end

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

@@ -91,7 +91,7 @@ class Parser
   #
   def on_error(token,value,stack)
     if token == 0 # denotes end of file
-      value_at = 'end of file'
+      value_at = 'end of input'
     else
       value_at = "'#{value[:value]}'"
     end
@@ -121,7 +121,7 @@ class Parser
       file = lexer.file
     end
     file = nil unless file.is_a?(String) && !file.empty?
-    raise Puppet::ParseErrorWithIssue.new(error, file, line, pos, nil, issue_code = Issues::SYNTAX_ERROR.issue_code)
+    raise Puppet::ParseErrorWithIssue.new(error, file, line, pos, nil, Issues::SYNTAX_ERROR.issue_code)
   end
 
   # Parses a String of pp DSL code.
@@ -219,7 +219,7 @@ class Parser
     # Create a synthetic NOOP token at EOF offset with 0 size. The lexer does not produce an EOF token that is
     # visible to the grammar rules. Creating this token is mainly to reuse the positioning logic as it
     # expects a token decorated with location information.
-    token_sym, token = @lexer.emit_completed([:NOOP,'',0], locator.string.bytesize)
+    _, token = @lexer.emit_completed([:NOOP,'',0], locator.string.bytesize)
     loc(no_op, token)
     # Program with a Noop
     program = Factory.PROGRAM(no_op, [], locator)

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

@@ -45,9 +45,6 @@ module SlurpSupport
    # Copy from old lexer - can do much better
    def slurp_uqstring
      scn = @scanner
-     last = scn.matched
-     ignore = true
-
      str = slurp(scn, @lexing_context[:uq_slurp_pattern], @lexing_context[:escapes], :ignore_invalid_escapes)
 
      # Terminator may be a single char '$', two characters '${', or empty string '' at the end of intput.

data/lib/puppet/pops/pcore.rb

@@ -38,6 +38,51 @@ module Pcore
     add_alias('Pcore::MemberName', TYPE_MEMBER_NAME, loader)
     add_alias('Pcore::TypeName', TYPE_QUALIFIED_REFERENCE, loader)
     add_alias('Pcore::QRef', TYPE_QUALIFIED_REFERENCE, 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/] },
+
+            # Full path to executable
+            executable => { type => String },
+
+            # 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 => String, value => 'both' },
+          }
+        }
+      PUPPET
+    end
     Types::TypedModelObject.register_ptypes(loader, ir)
 
     @type = create_object_type(loader, ir, Pcore, 'Pcore', nil)

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

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.
   #
@@ -137,9 +189,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 +207,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_path.rb

@@ -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)

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

@@ -9,8 +9,7 @@ module Serialization
 class ObjectReader
   include InstanceReader
 
-  def read(impl_class, value_count, deserializer)
-    type = impl_class._pcore_type
+  def read(type, impl_class, value_count, deserializer)
     (names, types, required_count) = type.parameter_info(impl_class)
     max = names.size
     unless value_count >= required_count && value_count <= max
@@ -25,7 +24,7 @@ class ObjectReader
         Types::TypeAsserter.assert_instance_of(nil, ptype, arg) { "#{type.name}[#{names[index]}]" } unless arg == :default
       else
         attr = type[names[index]]
-        raise Serialization::SerializationError, _("Missing default value for %{type_name}[%{name}]") % { type_name: type.name, name: names[index] } unless attr.value?
+        raise Serialization::SerializationError, _("Missing default value for %{type_name}[%{name}]") % { type_name: type.name, name: names[index] } unless attr && attr.value?
         args << attr.value
       end
     end
@@ -43,7 +42,7 @@ class ObjectWriter
 
   def write(type, value, serializer)
     impl_class = value.class
-    (names, types, required_count) = type.parameter_info(impl_class)
+    (names, _, required_count) = type.parameter_info(impl_class)
     args = names.map { |name| value.send(name) }
 
     # Pop optional arguments that are default

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

@@ -108,7 +108,8 @@ module Serialization
           value.instance_of?(SemanticPuppet::VersionRange),
           value.instance_of?(Time::Timestamp),
           value.instance_of?(Time::Timespan),
-          value.instance_of?(Types::PBinaryType::Binary)
+          value.instance_of?(Types::PBinaryType::Binary),
+          value.is_a?(URI)
         push_written(value)
         @writer.write(value)
       when value.instance_of?(Array)