puppet 8.3.1-x86-mingw32 → 8.5.0-x86-mingw32

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
@@ -11,7 +11,7 @@ class EvaluatingParser
 
   attr_reader :parser
 
-  def initialize()
+  def initialize
     @parser = Parser.new()
   end
 
@@ -47,7 +47,7 @@ class EvaluatingParser
     evaluate(scope, parse_file(file))
   end
 
-  def clear()
+  def clear
     @acceptor = nil
   end
 
@@ -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
@@ -87,7 +89,7 @@ class EvaluatingParser
     resulting_acceptor
   end
 
-  def acceptor()
+  def acceptor
     Validation::Acceptor.new
   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
 
@@ -154,7 +157,7 @@ class EvaluatingParser
   end
 
   class EvaluatingEppParser < EvaluatingParser
-    def initialize()
+    def initialize
       @parser = EppParser.new()
     end
   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
@@ -72,7 +72,7 @@ module HeredocSupport
     end
     # offset 0 for the heredoc, and its line number
     heredoc_offset = scn.pos
-    heredoc_line = locator.line_for_offset(heredoc_offset)-1
+    heredoc_line = locator.line_for_offset(heredoc_offset) - 1
 
     # Compute message to emit if there is no end (to make it refer to the opening heredoc position).
     eof_error = create_lex_error(Issues::HEREDOC_WITHOUT_END_TAGGED_LINE)
@@ -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)
@@ -137,8 +137,8 @@ module HeredocSupport
       # The specification says that leading space up to the margin marker should be removed, but this implementation
       # simply leaves lines that have text in the margin untouched.
       #
-      processed_lines = lines.collect {|s| s.gsub(leading_pattern, '') }
-      margin_per_line = Array.new(processed_lines.length) {|x| lines[x].length - processed_lines[x].length }
+      processed_lines = lines.collect { |s| s.gsub(leading_pattern, '') }
+      margin_per_line = Array.new(processed_lines.length) { |x| lines[x].length - processed_lines[x].length }
       lines = processed_lines
     else
       # Array with a 0 per line
@@ -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.
@@ -21,19 +21,19 @@ module Puppet::Pops::Parser::InterpolationSupport
     before = scn.pos
     # skip the leading " by doing a scan since the slurp_dqstring uses last matched when there is an error
     scn.scan(/"/)
-    value,terminator = slurp_dqstring()
+    value, terminator = slurp_dqstring()
     text = value
     after = scn.pos
     loop do
       case terminator
       when '"'
         # simple case, there was no interpolation, return directly
-        return emit_completed([:STRING, text, scn.pos-before], before)
+        return emit_completed([:STRING, text, scn.pos - before], before)
       when '${'
         count = ctx[:brace_count]
         ctx[:brace_count] += 1
         # The ${ terminator is counted towards the string part
-        enqueue_completed([:DQPRE, text, scn.pos-before], before)
+        enqueue_completed([:DQPRE, text, scn.pos - before], before)
         # Lex expression tokens until a closing (balanced) brace count is reached
         enqueue_until count
         break
@@ -41,13 +41,13 @@ module Puppet::Pops::Parser::InterpolationSupport
         varname = scn.scan(PATTERN_VARIABLE)
         if varname
           # The $ is counted towards the variable
-          enqueue_completed([:DQPRE, text, after-before-1], before)
+          enqueue_completed([:DQPRE, text, after - before - 1], before)
           enqueue_completed([:VARIABLE, varname, scn.pos - after + 1], after - 1)
           break
         else
           # false $ variable start
           text += terminator
-          value,terminator = slurp_dqstring()
+          value, terminator = slurp_dqstring()
           text += value
           after = scn.pos
         end
@@ -62,20 +62,20 @@ module Puppet::Pops::Parser::InterpolationSupport
     scn = @scanner
     ctx = @lexing_context
     before = scn.pos
-    value,terminator = slurp_dqstring
+    value, terminator = slurp_dqstring
     text = value
     after = scn.pos
     loop do
       case terminator
       when '"'
         # simple case, there was no further interpolation, return directly
-        enqueue_completed([:DQPOST, text, scn.pos-before], before)
+        enqueue_completed([:DQPOST, text, scn.pos - before], before)
         return
       when '${'
         count = ctx[:brace_count]
         ctx[:brace_count] += 1
         # The ${ terminator is counted towards the string part
-        enqueue_completed([:DQMID, text, scn.pos-before], before)
+        enqueue_completed([:DQMID, text, scn.pos - before], before)
         # Lex expression tokens until a closing (balanced) brace count is reached
         enqueue_until count
         break
@@ -83,13 +83,13 @@ module Puppet::Pops::Parser::InterpolationSupport
         varname = scn.scan(PATTERN_VARIABLE)
         if varname
           # The $ is counted towards the variable
-          enqueue_completed([:DQMID, text, after-before-1], before)
+          enqueue_completed([:DQMID, text, after - before - 1], before)
           enqueue_completed([:VARIABLE, varname, scn.pos - after + 1], after - 1)
           break
         else
           # false $ variable start
           text += terminator
-          value,terminator = slurp_dqstring
+          value, terminator = slurp_dqstring
           text += value
           after = scn.pos
         end
@@ -107,20 +107,20 @@ module Puppet::Pops::Parser::InterpolationSupport
     scn = @scanner
     ctx = @lexing_context
     before = scn.pos
-    value,terminator = slurp_uqstring()
+    value, terminator = slurp_uqstring()
     text = value
     after = scn.pos
     loop do
       case terminator
       when ''
         # simple case, there was no interpolation, return directly
-        enqueue_completed([:STRING, text, scn.pos-before], before)
+        enqueue_completed([:STRING, text, scn.pos - before], before)
         return
       when '${'
         count = ctx[:brace_count]
         ctx[:brace_count] += 1
         # The ${ terminator is counted towards the string part
-        enqueue_completed([:DQPRE, text, scn.pos-before], before)
+        enqueue_completed([:DQPRE, text, scn.pos - before], before)
         # Lex expression tokens until a closing (balanced) brace count is reached
         enqueue_until count
         break
@@ -128,13 +128,13 @@ module Puppet::Pops::Parser::InterpolationSupport
         varname = scn.scan(PATTERN_VARIABLE)
         if varname
           # The $ is counted towards the variable
-          enqueue_completed([:DQPRE, text, after-before-1], before)
+          enqueue_completed([:DQPRE, text, after - before - 1], before)
           enqueue_completed([:VARIABLE, varname, scn.pos - after + 1], after - 1)
           break
         else
           # false $ variable start
           text += terminator
-          value,terminator = slurp_uqstring()
+          value, terminator = slurp_uqstring()
           text += value
           after = scn.pos
         end
@@ -148,20 +148,20 @@ module Puppet::Pops::Parser::InterpolationSupport
     scn = @scanner
     ctx = @lexing_context
     before = scn.pos
-    value,terminator = slurp_uqstring
+    value, terminator = slurp_uqstring
     text = value
     after = scn.pos
     loop do
       case terminator
       when ''
         # simple case, there was no further interpolation, return directly
-        enqueue_completed([:DQPOST, text, scn.pos-before], before)
+        enqueue_completed([:DQPOST, text, scn.pos - before], before)
         return
       when '${'
         count = ctx[:brace_count]
         ctx[:brace_count] += 1
         # The ${ terminator is counted towards the string part
-        enqueue_completed([:DQMID, text, scn.pos-before], before)
+        enqueue_completed([:DQMID, text, scn.pos - before], before)
         # Lex expression tokens until a closing (balanced) brace count is reached
         enqueue_until count
         break
@@ -169,13 +169,13 @@ module Puppet::Pops::Parser::InterpolationSupport
         varname = scn.scan(PATTERN_VARIABLE)
         if varname
           # The $ is counted towards the variable
-          enqueue_completed([:DQMID, text, after-before-1], before)
+          enqueue_completed([:DQMID, text, after - before - 1], before)
           enqueue_completed([:VARIABLE, varname, scn.pos - after + 1], after - 1)
           break
         else
           # false $ variable start
           text += terminator
-          value,terminator = slurp_uqstring
+          value, terminator = slurp_uqstring
           text += value
           after = scn.pos
         end
@@ -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.
 #
@@ -71,6 +72,7 @@ class Lexer2
   TOKEN_TIMES        = [:TIMES,        '*',   1].freeze
   TOKEN_MODULO       = [:MODULO,       '%',   1].freeze
 
+  # rubocop:disable Layout/SpaceBeforeComma
   TOKEN_NOT          = [:NOT,          '!',   1].freeze
   TOKEN_DOT          = [:DOT,          '.',   1].freeze
   TOKEN_PIPE         = [:PIPE,         '|',   1].freeze
@@ -81,6 +83,7 @@ class Lexer2
   TOKEN_SEMIC        = [:SEMIC,        ';',   1].freeze
   TOKEN_QMARK        = [:QMARK,        '?',   1].freeze
   TOKEN_TILDE        = [:TILDE,        '~',   1].freeze # lexed but not an operator in Puppet
+  # rubocop:enable Layout/SpaceBeforeComma
 
   TOKEN_REGEXP       = [:REGEXP,       nil,   0].freeze
 
@@ -103,9 +106,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,34 +120,34 @@ 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
   KEYWORD_NAMES = {}
-  KEYWORDS.each {|k, v| KEYWORD_NAMES[v[0]] = k }
+  KEYWORDS.each { |k, v| KEYWORD_NAMES[v[0]] = k }
   KEYWORD_NAMES.freeze
 
   PATTERN_WS        = %r{[[:blank:]\r]+}
@@ -168,7 +173,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}
@@ -180,10 +185,10 @@ class Lexer2
 
   attr_reader :locator
 
-  def initialize()
+  def initialize
     @selector = {
-      '.' =>  lambda { emit(TOKEN_DOT, @scanner.pos) },
-      ',' => lambda {  emit(TOKEN_COMMA, @scanner.pos) },
+      '.' => -> { emit(TOKEN_DOT, @scanner.pos) },
+      ',' => -> { emit(TOKEN_COMMA, @scanner.pos) },
       '[' => lambda do
         before = @scanner.pos
         # Must check the preceding character to see if it is whitespace.
@@ -197,7 +202,7 @@ class Lexer2
           emit(TOKEN_LBRACK, before)
         end
       end,
-      ']' => lambda { emit(TOKEN_RBRACK, @scanner.pos) },
+      ']' => -> { emit(TOKEN_RBRACK, @scanner.pos) },
       '(' => lambda do
         before = @scanner.pos
         # If first on a line, or only whitespace between start of line and '('
@@ -209,10 +214,10 @@ class Lexer2
           emit(TOKEN_LPAREN, before)
         end
       end,
-      ')' => lambda { emit(TOKEN_RPAREN, @scanner.pos) },
-      ';' => lambda { emit(TOKEN_SEMIC, @scanner.pos) },
-      '?' => lambda { emit(TOKEN_QMARK, @scanner.pos) },
-      '*' => lambda { emit(TOKEN_TIMES, @scanner.pos) },
+      ')' => -> { emit(TOKEN_RPAREN, @scanner.pos) },
+      ';' => -> { emit(TOKEN_SEMIC, @scanner.pos) },
+      '?' => -> { emit(TOKEN_QMARK, @scanner.pos) },
+      '*' => -> { emit(TOKEN_TIMES, @scanner.pos) },
       '%' => lambda do
         scn = @scanner
         before = scn.pos
@@ -245,14 +250,14 @@ class Lexer2
         emit(TOKEN_RBRACE, @scanner.pos)
       end,
 
-
       # TOKENS @, @@, @(
       '@' => lambda do
         scn = @scanner
         la = scn.peek(2)
-        if la[1] == '@'
+        case la[1]
+        when '@'
           emit(TOKEN_ATAT, scn.pos) # TODO; Check if this is good for the grammar
-        elsif la[1] == '('
+        when '('
           heredoc
         else
           emit(TOKEN_AT, scn.pos)
@@ -340,7 +345,7 @@ class Lexer2
         emit(la[1] == '>' ? TOKEN_IN_EDGE_SUB : TOKEN_TILDE, scn.pos)
       end,
 
-      '#' => lambda { @scanner.skip(PATTERN_COMMENT); nil },
+      '#' => -> { @scanner.skip(PATTERN_COMMENT); nil },
 
       # TOKENS '/', '/*' and '/ regexp /'
       '/' => lambda do
@@ -358,10 +363,11 @@ 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, '/')
-            emit_completed([:REGEX, Regexp.new(regex), scn.pos-before], before)
+            emit_completed([:REGEX, Regexp.new(regex), scn.pos - before], before)
           else
             emit(TOKEN_DIV, before)
           end
@@ -422,7 +428,7 @@ class Lexer2
             value = scn.scan(PATTERN_CLASSREF)
             if value && scn.peek(2) != '::'
               after = scn.pos
-              emit_completed([:CLASSREF, value.freeze, after-before], before)
+              emit_completed([:CLASSREF, value.freeze, after - before], before)
             else
               # move to faulty position ('::<uc-letter>' was ok)
               scn.pos = scn.pos + 3
@@ -452,7 +458,7 @@ class Lexer2
         before = scn.pos
         value = scn.scan(PATTERN_DOLLAR_VAR)
         if value
-          emit_completed([:VARIABLE, value[1..-1].freeze, scn.pos - before], before)
+          emit_completed([:VARIABLE, value[1..].freeze, scn.pos - before], before)
         else
           # consume the $ and let higher layer complain about the error instead of getting a syntax error
           emit(TOKEN_VARIABLE_EMPTY, before)
@@ -485,12 +491,12 @@ class Lexer2
         ctx[:line_lexical_start] = @scanner.pos
         nil
       end,
-      '' => lambda { nil } # when the peek(1) returns empty
+      '' => -> { nil } # when the peek(1) returns empty
     }
 
-    [ ' ', "\t", "\r" ].each { |c| @selector[c] = lambda { @scanner.skip(PATTERN_WS); nil } }
+    [' ', "\t", "\r"].each { |c| @selector[c] = -> { @scanner.skip(PATTERN_WS); nil } }
 
-    [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].each do |c|
+    ('0'..'9').each do |c|
       @selector[c] = lambda do
         scn = @scanner
         before = scn.pos
@@ -511,6 +517,7 @@ class Lexer2
                 invalid_number = nil
                 before = scn.pos
                 break if before == 0
+
                 scn.pos = scn.pos - 1
               end
             end
@@ -519,12 +526,11 @@ class Lexer2
           end
           assert_numeric(invalid_number, before)
           scn.pos = before + 1
-          lex_error(Issues::ILLEGAL_NUMBER, {:value => invalid_number})
+          lex_error(Issues::ILLEGAL_NUMBER, { :value => invalid_number })
         end
       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|
+    ('a'..'z').to_a.push('_').each do |c|
       @selector[c] = lambda do
         scn = @scanner
         before = scn.pos
@@ -546,8 +552,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|
+    ('A'..'Z').each do |c|
       @selector[c] = lambda do
         scn = @scanner
         before = scn.pos
@@ -573,7 +578,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
 
@@ -595,7 +600,7 @@ class Lexer2
   # Clears the lexer state (it is not required to call this as it will be garbage collected
   # and the next lex call (lex_string, lex_file) will reset the internal state.
   #
-  def clear()
+  def clear
     # not really needed, but if someone wants to ensure garbage is collected as early as possible
     @scanner = nil
     @locator = nil
@@ -611,7 +616,7 @@ class Lexer2
     lex_string(string, nil)
   end
 
-  def lex_string(string, path=nil)
+  def lex_string(string, path = nil)
     initvars
     assert_not_bom(string)
     @scanner = StringScanner.new(string)
@@ -666,7 +671,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
@@ -674,7 +679,7 @@ class Lexer2
   #
   def fullscan
     result = []
-    scan {|token| result.push(token) }
+    scan { |token| result.push(token) }
     result
   end
 
@@ -691,7 +696,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 +776,6 @@ class Lexer2
       true
     end
   end
-
 end
 end
 end