puppet 8.3.1-x64-mingw32 → 8.4.0-x64-mingw32

data/lib/puppet/pops/model/ast_transformer.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/parser/ast'
 
 # The receiver of `import(file)` calls; once per imported file, or nil if imports are ignored
@@ -11,6 +12,7 @@ class Puppet::Pops::Model::AstTransformer
   Model = Puppet::Pops::Model
 
   attr_reader :importer
+
   def initialize(source_file = "unknown-file", importer=nil)
     @@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform",0,0)
     @@query_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"query",0,0)
@@ -60,12 +62,12 @@ class Puppet::Pops::Model::AstTransformer
   # Transforms pops expressions into AST 3.1 statements/expressions
   def transform(o)
     begin
-    @@transform_visitor.visit_this_0(self,o)
+      @@transform_visitor.visit_this_0(self,o)
     rescue StandardError => e
       loc_data = {}
       merge_location(loc_data, o)
       raise Puppet::ParseError.new(_("Error while transforming to Puppet 3 AST: %{message}") % { message: e.message },
-        loc_data[:file], loc_data[:line], loc_data[:pos], e)
+                                   loc_data[:file], loc_data[:line], loc_data[:pos], e)
     end
   end
 
@@ -79,7 +81,6 @@ class Puppet::Pops::Model::AstTransformer
     @@hostname_transform_visitor.visit_this_0(self, o)
   end
 
-
   # Ensures transformation fails if a 3.1 non supported object is encountered in a query expression
   #
   def query_Object(o)

data/lib/puppet/pops/model/factory.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Factory is a helper class that makes construction of a Pops Model
 # much more convenient. It can be viewed as a small internal DSL for model
 # constructions.
@@ -598,7 +599,6 @@ class Factory
 
   def lambda=(lambda)
     @init_hash['lambda'] = lambda
-    self
   end
 
   # Assignment =
@@ -646,6 +646,7 @@ class Factory
   def self.set_resource_form(expr, form)
     # Note: Validation handles illegal combinations
     return false unless expr.instance_of?(self) && expr.model_class <= AbstractResource
+
     expr['form'] = form
     return true
   end
@@ -694,7 +695,7 @@ class Factory
 
   def self.block(*args);                 new(BlockExpression, args.map { |arg| infer(arg) }); end
 
-  def self.string(*args);                new(ConcatenatedString, args.map { |arg| infer(arg) });           end
+  def self.string(*args);                new(ConcatenatedString, args.map { |arg| infer(arg) }); end
 
   def self.text(o);                      infer(o).text;                                  end
 
@@ -809,7 +810,7 @@ class Factory
       end
     else
       # Bad number should already have been caught by lexer - this should never happen
-      #TRANSLATORS 'NUMBER' refers to a method name and the 'name_or_numeric' was the passed in value and should not be translated
+      # TRANSLATORS 'NUMBER' refers to a method name and the 'name_or_numeric' was the passed in value and should not be translated
       raise ArgumentError, _("Internal Error, NUMBER token does not contain a valid number, %{name_or_numeric}") %
           { name_or_numeric: name_or_numeric }
     end
@@ -971,19 +972,19 @@ class Factory
     'realize' => true,
     'include' => true,
     'contain' => true,
-    'tag'     => true,
+    'tag' => true,
 
-    'debug'   => true,
-    'info'    => true,
-    'notice'  => true,
+    'debug' => true,
+    'info' => true,
+    'notice' => true,
     'warning' => true,
-    'err'     => true,
+    'err' => true,
 
-    'fail'    => true,
-    'import'  => true,  # discontinued, but transform it to make it call error reporting function
-    'break'   => true,
-    'next'    => true,
-    'return'  => true
+    'fail' => true,
+    'import' => true, # discontinued, but transform it to make it call error reporting function
+    'break' => true,
+    'next' => true,
+    'return' => true
   }.freeze
 
   # Returns true if the given name is a "statement keyword" (require, include, contain,
@@ -995,6 +996,7 @@ class Factory
 
   class ArgsToNonCallError < RuntimeError
     attr_reader :args, :name_expr
+
     def initialize(args, name_expr)
       @args = args
       @name_expr = name_expr
@@ -1043,8 +1045,10 @@ class Factory
     # Returning nil means accepting the given as a potential resource expression
     return nil unless attribute_ops.is_a? Array
     return nil unless left.model_class <= QualifiedName
+
     keyed_entries = attribute_ops.map do |ao|
       return nil if ao[KEY_OPERATOR] == '+>'
+
       KEY_ENTRY(infer(ao['attribute_name']), ao['value_expr'])
     end
     a_hash = HASH(keyed_entries)

data/lib/puppet/pops/model/model_label_provider.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Model
 # A provider of labels for model object, producing a human name for the model object.
@@ -117,7 +118,6 @@ class ModelLabelProvider
     'Resource Statement'
   end
 
-
   def label_Class o
     if o <= Types::PAnyType
       simple_name = o.name.split('::').last

data/lib/puppet/pops/model/model_tree_dumper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Dumps a Pops::Model in reverse polish notation; i.e. LISP style
 # The intention is to use this for debugging output
 # TODO: BAD NAME - A DUMP is a Ruby Serialization
@@ -66,7 +67,7 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
 
   def dump_EppExpression o
     result = ["epp"]
-#    result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
+    #    result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
     if o.body
       result << do_dump(o.body)
     else
@@ -319,21 +320,21 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
 
   def dump_IfExpression o
     result = ["if", do_dump(o.test), :indent, :break,
-      ["then", :indent, do_dump(o.then_expr), :dedent]]
+              ["then", :indent, do_dump(o.then_expr), :dedent]]
     result +=
-    [:break,
-      ["else", :indent, do_dump(o.else_expr), :dedent],
-      :dedent] unless is_nop? o.else_expr
+      [:break,
+       ["else", :indent, do_dump(o.else_expr), :dedent],
+       :dedent] unless is_nop? o.else_expr
     result
   end
 
   def dump_UnlessExpression o
     result = ["unless", do_dump(o.test), :indent, :break,
-      ["then", :indent, do_dump(o.then_expr), :dedent]]
+              ["then", :indent, do_dump(o.then_expr), :dedent]]
     result +=
-    [:break,
-      ["else", :indent, do_dump(o.else_expr), :dedent],
-      :dedent] unless is_nop? o.else_expr
+      [:break,
+       ["else", :indent, do_dump(o.else_expr), :dedent],
+       :dedent] unless is_nop? o.else_expr
     result
   end
 

data/lib/puppet/pops/model/pn_transformer.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
 module Model
-
-
 class PNTransformer
   extend Puppet::Concurrent::ThreadLocalSingleton
 
@@ -248,9 +247,9 @@ class PNTransformer
 
   def transform_ResourceBody(e)
     PN::Map.new([
-      transform(e.title).with_name('title'),
-      transform(e.operations).with_name('ops')
-    ]).as_call('resource_body')
+                  transform(e.title).with_name('title'),
+                  transform(e.operations).with_name('ops')
+                ]).as_call('resource_body')
   end
 
   def transform_ResourceDefaultsExpression(e)
@@ -381,6 +380,5 @@ class PNTransformer
     PN::Map.new(entries).as_call(name)
   end
 end
-
 end
 end

data/lib/puppet/pops/model/tree_dumper.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
+
 # Base class for formatted textual dump of a "model"
 #
 class Puppet::Pops::Model::TreeDumper
   attr_accessor :indent_count
+
   def initialize initial_indentation = 0
     @@dump_visitor ||= Puppet::Pops::Visitor.new(nil,"dump",0,0)
     @indent_count = initial_indentation

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 class Puppet::Pops::Parser::CodeMerger
-
   # Concatenates the logic in the array of parse results into one parse result.
   # @return Puppet::Parser::AST::BlockExpression
   #

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 # The EppParser is a specialized Puppet Parser that starts parsing in Epp Text mode
 class Puppet::Pops::Parser::EppParser < Puppet::Pops::Parser::Parser
-
   # Initializes the epp parser support by creating a new instance of {Puppet::Pops::Parser::Lexer}
   # configured to start in Epp Lexing mode.
   # @return [void]

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Parser
 # This module is an integral part of the Lexer.
@@ -6,7 +7,6 @@ module Parser
 #
 require 'strscan'
 module EppSupport
-
   TOKEN_RENDER_STRING = [:RENDER_STRING, nil, 0]
   TOKEN_RENDER_EXPR   = [:RENDER_EXPR, nil, 0]
 
@@ -183,6 +183,7 @@ module EppSupport
       @skip_leading = skip_leading
 
       return nil if scanner.eos?
+
       s = ''.dup
       until scanner.eos?
         part = @scanner.scan_until(/(<%)|\z/)
@@ -260,7 +261,6 @@ module EppSupport
       end
     end
   end
-
 end
 end
 end

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
 module Parser
-
 # Does not support "import" and parsing ruby files
 #
 class EvaluatingParser
@@ -58,6 +58,7 @@ class EvaluatingParser
 
   def evaluate(scope, model)
     return nil unless model
+
     evaluator.evaluate(model, scope)
   end
 
@@ -73,6 +74,7 @@ class EvaluatingParser
     if (Puppet.lookup(:migration_checker) { nil })
       return Evaluator::EvaluatorImpl.new()
     end
+
     @@evaluator ||= Evaluator::EvaluatorImpl.new()
     @@evaluator
   end
@@ -97,13 +99,14 @@ class EvaluatingParser
 
   def assert_and_report(parse_result, file_source)
     return nil unless parse_result
+
     if parse_result['source_ref'].nil? || parse_result['source_ref'] == ''
       parse_result['source_ref'] = file_source
     end
     validation_result = validate(parse_result.model)
 
     IssueReporter.assert_and_report(validation_result,
-                                          :emit_warnings => true)
+                                    :emit_warnings => true)
     parse_result
   end
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Parser
 module HeredocSupport
@@ -9,7 +10,6 @@ module HeredocSupport
   #
   PATTERN_HEREDOC = %r{@\(([^:/\r\n\)]+)(?::[[:blank:]]*([a-z][a-zA-Z0-9_+]+)[[:blank:]]*)?(?:/((?:\w|[$])*)[[:blank:]]*)?\)}
 
-
   def heredoc
     scn = @scanner
     ctx = @lexing_context
@@ -86,6 +86,7 @@ module HeredocSupport
     while !scn.eos? do
       one_line = scn.scan_until(/(?:\n|\z)/)
       raise eof_error unless one_line
+
       md = one_line.match(endline_pattern)
       if md
         leading      = md[1]
@@ -94,7 +95,6 @@ module HeredocSupport
         # Record position where next heredoc (from same line as current @()) should start scanning for content
         ctx[:newline_jump] = scn.pos
 
-
         # Process captured lines - remove leading, and trailing newline
         # get processed string and index of removed margin/leading size per line
         str, margin_per_line = heredoc_text(lines, leading, has_margin, remove_break)
@@ -106,10 +106,10 @@ module HeredocSupport
         # Emit a token that provides the grammar with location information about the lines on which the heredoc
         # content is based.
         enqueue([:SUBLOCATE,
-          LexerSupport::TokenValue.new([:SUBLOCATE,
-            lines, lines.reduce(0) {|size, s| size + s.length} ],
-            heredoc_offset,
-            locator)])
+                 LexerSupport::TokenValue.new([:SUBLOCATE,
+                                               lines, lines.reduce(0) {|size, s| size + s.length} ],
+                                              heredoc_offset,
+                                              locator)])
 
         sublexer.lex_unquoted_string(str, locator, resulting_escapes, dqstring_style)
         sublexer.interpolate_uq_to(self)
@@ -148,7 +148,6 @@ module HeredocSupport
     result.gsub!(/\r?\n\z/m, '') if remove_break
     [result, margin_per_line]
   end
-
 end
 end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # This module is an integral part of the Lexer.
 # It defines interpolation support
 # PERFORMANCE NOTE: There are 4 very similar methods in this module that are designed to be as
@@ -6,8 +7,7 @@
 # of passing parameters and evaluating conditional logic has a negative impact on performance.
 #
 module Puppet::Pops::Parser::InterpolationSupport
-
-  PATTERN_VARIABLE       = %r{(::)?(\w+::)*\w+}
+  PATTERN_VARIABLE = %r{(::)?(\w+::)*\w+}
 
   # This is the starting point for a double quoted string with possible interpolation
   # The structure mimics that of the grammar.
@@ -246,5 +246,4 @@ module Puppet::Pops::Parser::InterpolationSupport
       lexer.enqueue(queue.shift)
     end
   end
-
 end

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

@@ -1,4 +1,5 @@
 # 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.
 #
@@ -103,9 +104,11 @@ class Lexer2
   TOKEN_HEREDOC        = [:HEREDOC,     nil,  0].freeze
 
   # EPP_START is currently a marker token, may later get syntax
+  # rubocop:disable Layout/ExtraSpacing
   TOKEN_EPPSTART    = [:EPP_START,      nil,  0].freeze
   TOKEN_EPPEND      = [:EPP_END,       '%>',  2].freeze
   TOKEN_EPPEND_TRIM = [:EPP_END_TRIM, '-%>',  3].freeze
+  # rubocop:enable Layout/ExtraSpacing
 
   # 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.
@@ -115,29 +118,29 @@ class Lexer2
   # 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],
+    '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],
+    '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],
+    'type' => [:TYPE,     'type',     4],
+    'attr' => [:ATTR,     'attr',     4],
+    'private' => [:PRIVATE, 'private', 7],
   }
 
-  KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
+  KEYWORDS.each {|_k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze
 
   # Reverse lookup of keyword name to string
@@ -168,7 +171,7 @@ class Lexer2
   PATTERN_CLASSREF       = %r{((::){0,1}[A-Z][\w]*)+}
   PATTERN_NAME           = %r{^((::)?[a-z][\w]*)(::[a-z][\w]*)*$}
 
-  PATTERN_BARE_WORD     = %r{((?:::){0,1}(?:[a-z_](?:[\w-]*[\w])?))+}
+  PATTERN_BARE_WORD      = %r{((?:::){0,1}(?:[a-z_](?:[\w-]*[\w])?))+}
 
   PATTERN_DOLLAR_VAR     = %r{\$(::)?(\w+::)*\w+}
   PATTERN_NUMBER         = %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b}
@@ -182,8 +185,8 @@ class Lexer2
 
   def initialize()
     @selector = {
-      '.' =>  lambda { emit(TOKEN_DOT, @scanner.pos) },
-      ',' => lambda {  emit(TOKEN_COMMA, @scanner.pos) },
+      '.' => lambda { emit(TOKEN_DOT, @scanner.pos) },
+      ',' => lambda { emit(TOKEN_COMMA, @scanner.pos) },
       '[' => lambda do
         before = @scanner.pos
         # Must check the preceding character to see if it is whitespace.
@@ -245,7 +248,6 @@ class Lexer2
         emit(TOKEN_RBRACE, @scanner.pos)
       end,
 
-
       # TOKENS @, @@, @(
       '@' => lambda do
         scn = @scanner
@@ -358,6 +360,7 @@ class Lexer2
             while escaped_end(value)
               more = scn.scan_until(PATTERN_REGEX_END)
               return emit(TOKEN_DIV, before) unless more
+
               value << more
             end
             regex = value.sub(PATTERN_REGEX_A, '').sub(PATTERN_REGEX_Z, '').gsub(PATTERN_REGEX_ESC, '/')
@@ -511,6 +514,7 @@ class Lexer2
                 invalid_number = nil
                 before = scn.pos
                 break if before == 0
+
                 scn.pos = scn.pos - 1
               end
             end
@@ -524,7 +528,7 @@ class Lexer2
       end
     end
     ['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|
+     '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
@@ -547,7 +551,7 @@ class Lexer2
     end
 
     ['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|
+     '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
@@ -573,7 +577,7 @@ class Lexer2
         emit([:OTHER, scn.peek(0), 1], scn.pos)
       end
     end
-    @selector.each { |k,v| k.freeze }
+    @selector.each { |k,_v| k.freeze }
     @selector.freeze
   end
 
@@ -666,7 +670,7 @@ class Lexer2
       :line_lexical_start => 0
     }
     # Use of --tasks introduces the new keyword 'plan'
-    @taskm_keywords = Puppet[:tasks] ? { 'plan' => [:PLAN, 'plan',  4], 'apply' => [:APPLY, 'apply', 5] }.freeze : EMPTY_HASH
+    @taskm_keywords = Puppet[:tasks] ? { 'plan' => [:PLAN, 'plan', 4], 'apply' => [:APPLY, 'apply', 5] }.freeze : EMPTY_HASH
   end
 
   # Scans all of the content and returns it in an array
@@ -691,7 +695,7 @@ class Lexer2
     # This makes a small but notable difference since instance member access is avoided for
     # every token in the lexed content.
     #
-    scn   = @scanner
+    scn = @scanner
     lex_error_without_pos(Issues::NO_INPUT_TO_LEXER) unless scn
 
     ctx   = @lexing_context
@@ -771,7 +775,6 @@ class Lexer2
       true
     end
   end
-
 end
 end
 end