puppet 8.5.1-x86-mingw32 → 8.7.0-x86-mingw32

data/lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb

@@ -120,7 +120,11 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
   # Returns an Array; a tuple with method name and line number or "<unknown>" if either is missing, or format is not the expected
   #
   def self.extract_name_line(x)
-    (x.is_a?(Array) ? [x[1], x[2].is_a?(Array) ? x[2][1] : nil] : [nil, nil]).map { |v| v.nil? ? UNKNOWN : v }
+    (if x.is_a?(Array)
+       [x[1], x[2].is_a?(Array) ? x[2][1] : nil]
+     else
+       [nil, nil]
+     end).map { |v| v.nil? ? UNKNOWN : v }
   end
   private_class_method :extract_name_line
 end

data/lib/puppet/pops/loader/static_loader.rb

@@ -6,7 +6,7 @@
 module Puppet::Pops
 module Loader
 class StaticLoader < Loader
-  BUILTIN_TYPE_NAMES = %w{
+  BUILTIN_TYPE_NAMES = %w[
     Component
     Exec
     File
@@ -22,9 +22,9 @@ class StaticLoader < Loader
     Tidy
     User
     Whit
-  }.freeze
+  ].freeze
 
-  BUILTIN_TYPE_NAMES_LC = Set.new(BUILTIN_TYPE_NAMES.map { |n| n.downcase }).freeze
+  BUILTIN_TYPE_NAMES_LC = Set.new(BUILTIN_TYPE_NAMES.map(&:downcase)).freeze
 
   BUILTIN_ALIASES = {
     'Data' => 'Variant[ScalarData,Undef,Hash[String,Data],Array[Data]]',
@@ -46,9 +46,9 @@ class StaticLoader < Loader
 
   def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
     # Static loader only contains runtime types
-    return EMPTY_ARRAY unless type == :type && name_authority == name_authority = Pcore::RUNTIME_NAME_AUTHORITY
+    return EMPTY_ARRAY unless type == :type && name_authority == Pcore::RUNTIME_NAME_AUTHORITY
 
-    typed_names = type == :type && name_authority == Pcore::RUNTIME_NAME_AUTHORITY ? @loaded.keys : EMPTY_ARRAY
+    typed_names = @loaded.keys
     block_given? ? typed_names.select { |tn| yield(tn) } : typed_names
   end
 

data/lib/puppet/pops/loaders.rb

@@ -28,7 +28,7 @@ class Loaders
     environment.lock.synchronize do
       obj = environment.loaders
       if obj.nil?
-        obj = self.allocate
+        obj = allocate
         obj.send(:initialize, environment, for_agent, load_from_pcore)
       end
       obj
@@ -37,7 +37,7 @@ class Loaders
 
   def initialize(environment, for_agent, load_from_pcore = true)
     # Protect against environment havoc
-    raise ArgumentError.new(_("Attempt to redefine already initialized loaders for environment")) unless environment.loaders.nil?
+    raise ArgumentError, _("Attempt to redefine already initialized loaders for environment") unless environment.loaders.nil?
 
     environment.loaders = self
     @environment = environment
@@ -518,7 +518,7 @@ class Loaders
     end
 
     def all_module_loaders
-      @all_module_loaders ||= @index.values.map { |md| md.public_loader }
+      @all_module_loaders ||= @index.values.map(&:public_loader)
     end
 
     def resolve(module_data)

data/lib/puppet/pops/lookup/data_dig_function_provider.rb

@@ -92,7 +92,7 @@ class V3BackendFunctionProvider < DataDigFunctionProvider
       require 'hiera/backend'
       require "hiera/backend/#{backend_name.downcase}_backend"
       backend = Hiera::Backend.const_get("#{backend_name.capitalize}_backend").new
-      return backend.method(:lookup).arity == 4 ? Hiera::Backend::Backend1xWrapper.new(backend) : backend
+      backend.method(:lookup).arity == 4 ? Hiera::Backend::Backend1xWrapper.new(backend) : backend
     rescue LoadError => e
       lookup_invocation.report_text { "Unable to load backend '#{backend_name}': #{e.message}" }
       throw :no_such_key

data/lib/puppet/pops/lookup/explainer.rb

@@ -15,7 +15,7 @@ module Lookup
 
     def to_hash
       hash = {}
-      hash[:branches] = @branches.map { |b| b.to_hash } unless @branches.nil? || @branches.empty?
+      hash[:branches] = @branches.map(&:to_hash) unless @branches.nil? || @branches.empty?
       hash
     end
 
@@ -469,7 +469,7 @@ module Lookup
     end
 
     def push(qualifier_type, qualifier)
-      node = case (qualifier_type)
+      node = case qualifier_type
              when :global
                ExplainGlobal.new(@current, qualifier)
              when :location

data/lib/puppet/pops/lookup/global_data_provider.rb

@@ -13,7 +13,7 @@ class GlobalDataProvider < ConfiguredDataProvider
 
   def unchecked_key_lookup(key, lookup_invocation, merge)
     config = config(lookup_invocation)
-    if (config.version == 3)
+    if config.version == 3
       # Hiera version 3 needs access to special scope variables
       scope = lookup_invocation.scope
       unless scope.is_a?(Hiera::Scope)

data/lib/puppet/pops/lookup/hiera_config.rb

@@ -105,7 +105,7 @@ class HieraConfig
   end
 
   def self.symkeys_to_string(struct)
-    case (struct)
+    case struct
     when Hash
       map = {}
       struct.each_pair { |k, v| map[k.is_a?(Symbol) ? k.to_s : k] = symkeys_to_string(v) }
@@ -212,7 +212,7 @@ class HieraConfig
         # Raise a LookupError with a RUNTIME_ERROR issue to prevent this being translated to an evaluation error triggered in the pp file
         # where the lookup started
         if e.message =~ /^Undefined variable '([^']+)'/
-          var = $1
+          var = ::Regexp.last_match(1)
           fail(Issues::HIERA_UNDEFINED_VARIABLE, { :name => var }, find_line_matching(/%\{['"]?#{var}['"]?}/))
         end
         raise e
@@ -287,7 +287,7 @@ class HieraConfig
 
   def create_hiera3_backend_provider(name, backend, parent_data_provider, datadir, paths, hiera3_config)
     # Custom backend. Hiera 3 must be installed, its logger configured, and it must be made aware of the loaded config
-    raise Puppet::DataBinding::LookupError, 'Hiera 3 is not installed' if !Puppet.features.hiera?
+    raise Puppet::DataBinding::LookupError, 'Hiera 3 is not installed' unless Puppet.features.hiera?
 
     if Hiera::Config.instance_variable_defined?(:@config) && (current_config = Hiera::Config.instance_variable_get(:@config)).is_a?(Hash)
       current_config.each_pair do |key, val|
@@ -308,7 +308,7 @@ class HieraConfig
       # Replace the class methods 'hiera_interpolate' and 'alias_interpolate' with a method that wires back and performs global
       # lookups using the lookup framework. This is necessary since the classic Hiera is made aware only of custom backends.
       class << Hiera::Interpolate
-        hiera_interpolate = Proc.new do |_data, key, scope, _extra_data, context|
+        hiera_interpolate = proc do |_data, key, scope, _extra_data, context|
           override = context[:order_override]
           invocation = Puppet::Pops::Lookup::Invocation.current
           unless override.nil? && invocation.global_only?
@@ -431,8 +431,8 @@ class HieraConfigV3 < HieraConfig
   end
 
   DEFAULT_CONFIG_HASH = {
-    KEY_BACKENDS => %w(yaml),
-    KEY_HIERARCHY => %w(nodes/%{::trusted.certname} common),
+    KEY_BACKENDS => %w[yaml],
+    KEY_HIERARCHY => %w[nodes/%{::trusted.certname} common],
     KEY_MERGE_BEHAVIOR => 'native'
   }
 
@@ -689,7 +689,7 @@ class HieraConfigV5 < HieraConfig
 
       options = he[KEY_OPTIONS] || defaults[KEY_OPTIONS]
       options = options.nil? ? EMPTY_HASH : interpolate(options, lookup_invocation, false)
-      if (function_kind == KEY_V3_BACKEND)
+      if function_kind == KEY_V3_BACKEND
         v3options = { :datadir => entry_datadir.to_s }
         options.each_pair { |k, v| v3options[k.to_sym] = v }
         data_providers[name] =
@@ -700,9 +700,13 @@ class HieraConfigV5 < HieraConfig
                                          locations,
                                          {
                                            :hierarchy =>
-                                             locations.nil? ? [] : locations.map do |loc|
-                                               path = loc.original_location
-                                               path.end_with?(".#{function_name}") ? path[0..-(function_name.length + 2)] : path
+                                             if locations.nil?
+                                               []
+                                             else
+                                               locations.map do |loc|
+                                                 path = loc.original_location
+                                                 path.end_with?(".#{function_name}") ? path[0..-(function_name.length + 2)] : path
+                                               end
                                              end,
                                            function_name.to_sym => v3options,
                                            :backends => [function_name],
@@ -719,7 +723,7 @@ class HieraConfigV5 < HieraConfig
     @config.include?(KEY_DEFAULT_HIERARCHY)
   end
 
-  RESERVED_OPTION_KEYS = ['path', 'uri'].freeze
+  RESERVED_OPTION_KEYS = %w[path uri].freeze
 
   DEFAULT_CONFIG_HASH = {
     KEY_VERSION => 5,

data/lib/puppet/pops/lookup/interpolation.rb

@@ -48,8 +48,8 @@ module Interpolation
   def interpolate_string(subject, context, allow_methods)
     lookup_invocation = context.is_a?(Invocation) ? context : context.invocation
     lookup_invocation.with(:interpolate, subject) do
-      subject.gsub(/%\{([^\}]*)\}/) do |match|
-        expr = $1
+      subject.gsub(/%\{([^}]*)\}/) do |match|
+        expr = ::Regexp.last_match(1)
         # Leading and trailing spaces inside an interpolation expression are insignificant
         expr.strip!
         value = nil
@@ -144,7 +144,7 @@ module Interpolation
   end
 
   def get_method_and_data(data, allow_methods)
-    match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
+    match = data.match(/^(\w+)\((?:"([^"]+)"|'([^']+)')\)$/)
     if match
       fail(Issues::HIERA_INTERPOLATION_METHOD_SYNTAX_NOT_ALLOWED) unless allow_methods
 

data/lib/puppet/pops/lookup/key_recorder.rb

@@ -9,7 +9,7 @@ class Puppet::Pops::Lookup::KeyRecorder
 
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def self.singleton
-    @null_recorder ||= self.new
+    @null_recorder ||= new
   end
   # rubocop:enable Naming/MemoizedInstanceVariableName
 

data/lib/puppet/pops/lookup/location_resolver.rb

@@ -43,7 +43,7 @@ module Lookup
     def expand_globs(datadir, declared_globs, lookup_invocation)
       declared_globs.map do |declared_glob|
         glob = datadir + interpolate(declared_glob, lookup_invocation, false)
-        Pathname.glob(glob).reject { |path| path.directory? }.map { |path| ResolvedLocation.new(glob.to_s, path, true) }
+        Pathname.glob(glob).reject(&:directory?).map { |path| ResolvedLocation.new(glob.to_s, path, true) }
       end.flatten
     end
 

data/lib/puppet/pops/lookup/lookup_adapter.rb

@@ -297,18 +297,18 @@ class LookupAdapter < DataAdapter
 
   def validate_lookup_options(options, module_name)
     return nil if options.nil?
-    raise Puppet::DataBinding::LookupError.new(_("value of %{opts} must be a hash") % { opts: LOOKUP_OPTIONS }) unless options.is_a?(Hash)
+    raise Puppet::DataBinding::LookupError, _("value of %{opts} must be a hash") % { opts: LOOKUP_OPTIONS } unless options.is_a?(Hash)
     return options if module_name.nil?
 
     pfx = "#{module_name}::"
     options.each_pair do |key, _value|
       if key.start_with?(LOOKUP_OPTIONS_PATTERN_START)
         unless key[1..pfx.length] == pfx
-          raise Puppet::DataBinding::LookupError.new(_("all %{opts} patterns must match a key starting with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name })
+          raise Puppet::DataBinding::LookupError, _("all %{opts} patterns must match a key starting with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name }
         end
       else
         unless key.start_with?(pfx)
-          raise Puppet::DataBinding::LookupError.new(_("all %{opts} keys must start with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name })
+          raise Puppet::DataBinding::LookupError, _("all %{opts} keys must start with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name }
         end
       end
     end
@@ -373,7 +373,7 @@ class LookupAdapter < DataAdapter
 
   # Retrieve and cache the global lookup options
   def global_lookup_options(lookup_invocation, merge_strategy)
-    if !instance_variable_defined?(:@global_lookup_options)
+    unless instance_variable_defined?(:@global_lookup_options)
       @global_lookup_options = nil
       catch(:no_such_key) { @global_lookup_options = validate_lookup_options(lookup_global(LookupKey::LOOKUP_OPTIONS, lookup_invocation, merge_strategy), nil) }
     end
@@ -383,7 +383,7 @@ class LookupAdapter < DataAdapter
   # Retrieve and cache lookup options specific to the environment of the compiler that this adapter is attached to (i.e. a merge
   # of global and environment lookup options).
   def env_lookup_options(lookup_invocation, merge_strategy)
-    if !instance_variable_defined?(:@env_lookup_options)
+    unless instance_variable_defined?(:@env_lookup_options)
       global_options = global_lookup_options(lookup_invocation, merge_strategy)
       @env_only_lookup_options = nil
       catch(:no_such_key) { @env_only_lookup_options = validate_lookup_options(lookup_in_environment(LookupKey::LOOKUP_OPTIONS, lookup_invocation, merge_strategy), nil) }
@@ -411,7 +411,7 @@ class LookupAdapter < DataAdapter
   def module_provider(lookup_invocation, module_name)
     # Test if the key is present for the given module_name. It might be there even if the
     # value is nil (which indicates that no module provider is configured for the given name)
-    unless self.include?(module_name)
+    unless include?(module_name)
       self[module_name] = initialize_module_provider(lookup_invocation, module_name)
     end
     self[module_name]
@@ -514,7 +514,7 @@ class LookupAdapter < DataAdapter
         ep.config = HieraConfigV5.v4_function_config(env_path, 'environment::data', ep)
         ep
       else
-        raise Puppet::Error.new(_("Environment '%{env}', cannot find environment_data_provider '%{provider}'") % { env: environment.name, provider: provider_name })
+        raise Puppet::Error, _("Environment '%{env}', cannot find environment_data_provider '%{provider}'") % { env: environment.name, provider: provider_name }
       end
     end
   end

data/lib/puppet/pops/lookup/module_data_provider.rb

@@ -47,16 +47,16 @@ class ModuleDataProvider < ConfiguredDataProvider
   def validate_data_hash(data_hash)
     super
     module_prefix = "#{module_name}::"
-    data_hash.each_key.reduce(data_hash) do |memo, k|
-      next memo if k == LOOKUP_OPTIONS || k.start_with?(module_prefix)
-
-      msg = "#{yield} must use keys qualified with the name of the module"
-      memo = memo.clone if memo.equal?(data_hash)
-      memo.delete(k)
-      Puppet.warning("Module '#{module_name}': #{msg}")
-      memo
+    data_hash_to_return = {}
+    data_hash.keys.each do |k|
+      if k == LOOKUP_OPTIONS || k.start_with?(module_prefix)
+        data_hash_to_return[k] = data_hash[k]
+      else
+        msg = "#{yield} must use keys qualified with the name of the module"
+        Puppet.warning("Module '#{module_name}': #{msg}; got #{k}")
+      end
     end
-    data_hash
+    data_hash_to_return
   end
 
   protected

data/lib/puppet/pops/lookup/sub_lookup.rb

@@ -3,7 +3,7 @@
 module Puppet::Pops
 module Lookup
 module SubLookup
-  SPECIAL = /['"\.]/
+  SPECIAL = /['".]/
 
   # Split key into segments. A segment may be a quoted string (both single and double quotes can
   # be used) and the segment separator is the '.' character. Whitespace will be trimmed off on

data/lib/puppet/pops/merge_strategy.rb

@@ -208,7 +208,7 @@ module Puppet::Pops
   # Simple strategy that returns the first value found. It never merges any values.
   #
   class FirstFoundStrategy < MergeStrategy
-    INSTANCE = self.new(EMPTY_HASH)
+    INSTANCE = new(EMPTY_HASH)
 
     def self.key
       :first
@@ -238,7 +238,7 @@ module Puppet::Pops
 
   # Same as {FirstFoundStrategy} but used when no strategy has been explicitly given
   class DefaultMergeStrategy < FirstFoundStrategy
-    INSTANCE = self.new(EMPTY_HASH)
+    INSTANCE = new(EMPTY_HASH)
 
     def self.key
       :default
@@ -251,7 +251,7 @@ module Puppet::Pops
   # will be those of e1
   #
   class HashMergeStrategy < MergeStrategy
-    INSTANCE = self.new(EMPTY_HASH)
+    INSTANCE = new(EMPTY_HASH)
 
     def self.key
       :hash
@@ -281,7 +281,7 @@ module Puppet::Pops
   # first contributor of elements and e2 the second.
   #
   class UniqueMergeStrategy < MergeStrategy
-    INSTANCE = self.new(EMPTY_HASH)
+    INSTANCE = new(EMPTY_HASH)
 
     def self.key
       :unique
@@ -363,7 +363,7 @@ module Puppet::Pops
   #   Results: {:x => [{:y => 1, :z => 2}]}
   #
   class DeepMergeStrategy < MergeStrategy
-    INSTANCE = self.new(EMPTY_HASH)
+    INSTANCE = new(EMPTY_HASH)
 
     def self.key
       :deep
@@ -432,7 +432,7 @@ module Puppet::Pops
   # Same as {UnconstrainedDeepMergeStrategy} but with reverse priority of merged elements.
   # (needed for backward compatibility with Hiera v3)
   class ReverseDeepMergeStrategy < UnconstrainedDeepMergeStrategy
-    INSTANCE = self.new(EMPTY_HASH)
+    INSTANCE = new(EMPTY_HASH)
 
     def self.key
       :reverse_deep

data/lib/puppet/pops/migration/migration_checker.rb

@@ -9,7 +9,7 @@ class Puppet::Pops::Migration::MigrationChecker
 
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def self.singleton
-    @null_checker ||= self.new
+    @null_checker ||= new
   end
   # rubocop:enable Naming/MemoizedInstanceVariableName
 

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

@@ -61,14 +61,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)
-    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)
-    end
+    @@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)
   end
 
   # Transforms pops expressions into AST 3.1 query expressions
@@ -93,11 +91,11 @@ class Puppet::Pops::Model::AstTransformer
   end
 
   def hostname_LiteralValue(o)
-    return o.value
+    o.value
   end
 
   def hostname_QualifiedName(o)
-    return o.value
+    o.value
   end
 
   def hostname_LiteralNumber(o)
@@ -105,7 +103,7 @@ class Puppet::Pops::Model::AstTransformer
   end
 
   def hostname_LiteralDefault(o)
-    return 'default'
+    'default'
   end
 
   def hostname_LiteralRegularExpression(o)

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

@@ -648,7 +648,7 @@ class Factory
     return false unless expr.instance_of?(self) && expr.model_class <= AbstractResource
 
     expr['form'] = form
-    return true
+    true
   end
 
   # Returns symbolic information about an expected shape of a resource expression given the LHS of a resource expr.
@@ -1052,8 +1052,7 @@ class Factory
     end
     a_hash = HASH(keyed_entries)
     a_hash.record_position(left[KEY_LOCATOR], lbrace_token, rbrace_token)
-    result = block_or_expression(transform_calls([left, a_hash]))
-    result
+    block_or_expression(transform_calls([left, a_hash]))
   end
 
   def interpolate_Factory(c)
@@ -1062,7 +1061,7 @@ class Factory
 
   def interpolate_LiteralInteger(c)
     # convert number to a variable
-    self.var
+    var
   end
 
   def interpolate_Object(c)
@@ -1070,7 +1069,7 @@ class Factory
   end
 
   def interpolate_QualifiedName(c)
-    self.var
+    var
   end
 
   # rewrite left expression to variable if it is name, number, and recurse if it is an access expression

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

@@ -14,7 +14,7 @@ class Puppet::Pops::Parser::EppParser < Puppet::Pops::Parser::Parser
   def parse_file(file)
     unless FileTest.exist?(file)
       unless file =~ /\.epp$/
-        file = file + ".epp"
+        file += ".epp"
       end
     end
     @lexer.file = file
@@ -43,7 +43,7 @@ class Puppet::Pops::Parser::EppParser < Puppet::Pops::Parser::Parser
       #      rescue => except
       #        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, @lexer.pos, except)
     end
-    return main
+    main
   ensure
     @lexer.clear
     @namestack = []

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

@@ -44,7 +44,7 @@ module EppSupport
     interpolate_epp
 
     # This is the lexer's main loop
-    until queue.empty? && scn.eos? do
+    until queue.empty? && scn.eos?
       token = queue.shift || lex_token
       if token
         yield [ctx[:after] = token[0], token[1]]

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

@@ -71,7 +71,7 @@ class EvaluatingParser
 
   def evaluator
     # Do not use the cached evaluator if this is a migration run
-    if (Puppet.lookup(:migration_checker) { nil })
+    if Puppet.lookup(:migration_checker) { nil }
       return Evaluator::EvaluatorImpl.new()
     end
 
@@ -146,7 +146,7 @@ class EvaluatingParser
       when '"'
         escaped << '\\"'
       when '\\'
-        escaped << if c == '$' || c == 's'; p; else '\\\\'; end # don't escape \ when followed by s or $
+        escaped << ((c == '$' || c == 's') ? p : '\\\\') # don't escape \ when followed by s or $
       else
         escaped << p
       end

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

@@ -8,7 +8,7 @@ module HeredocSupport
   # Pattern for heredoc `@(endtag[:syntax][/escapes])
   # Produces groups for endtag (group 1), syntax (group 2), and escapes (group 3)
   #
-  PATTERN_HEREDOC = %r{@\(([^:/\r\n\)]+)(?::[[:blank:]]*([a-z][a-zA-Z0-9_+]+)[[:blank:]]*)?(?:/((?:\w|[$])*)[[:blank:]]*)?\)}
+  PATTERN_HEREDOC = %r{@\(([^:/\r\n)]+)(?::[[:blank:]]*([a-z][a-zA-Z0-9_+]+)[[:blank:]]*)?(?:/((?:\w|[$])*)[[:blank:]]*)?\)}
 
   def heredoc
     scn = @scanner
@@ -32,7 +32,7 @@ module HeredocSupport
     # Is this a dq string style heredoc? (endtag enclosed in "")
     if endtag =~ /^"(.*)"$/
       dqstring_style = true
-      endtag = $1.strip
+      endtag = ::Regexp.last_match(1).strip
     end
 
     lex_error(Issues::HEREDOC_EMPTY_ENDTAG) unless endtag.length >= 1
@@ -81,9 +81,9 @@ module HeredocSupport
     # that terminates the heredoc is found.
 
     # (Endline in EBNF form): WS* ('|' WS*)? ('-' WS*)? endtag WS* \r? (\n|$)
-    endline_pattern = /([[:blank:]]*)(?:([|])[[:blank:]]*)?(?:(\-)[[:blank:]]*)?#{Regexp.escape(endtag)}[[:blank:]]*\r?(?:\n|\z)/
+    endline_pattern = /([[:blank:]]*)(?:([|])[[:blank:]]*)?(?:(-)[[:blank:]]*)?#{Regexp.escape(endtag)}[[:blank:]]*\r?(?:\n|\z)/
     lines = []
-    while !scn.eos? do
+    until scn.eos?
       one_line = scn.scan_until(/(?:\n|\z)/)
       raise eof_error unless one_line
 

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

@@ -7,7 +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 = /(::)?(\w+::)*\w+/
 
   # This is the starting point for a double quoted string with possible interpolation
   # The structure mimics that of the grammar.
@@ -194,7 +194,7 @@ module Puppet::Pops::Parser::InterpolationSupport
 
     scn.skip(self.class::PATTERN_WS)
     queue_size = queue.size
-    until scn.eos? do
+    until scn.eos?
       token = lex_token
       if token
         if token.equal?(queue_base)
@@ -242,7 +242,7 @@ module Puppet::Pops::Parser::InterpolationSupport
   def interpolate_uq_to(lexer)
     interpolate_uq
     queue = @token_queue
-    until queue.empty? do
+    until queue.empty?
       lexer.enqueue(queue.shift)
     end
   end

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

@@ -150,11 +150,11 @@ class Lexer2
   KEYWORDS.each { |k, v| KEYWORD_NAMES[v[0]] = k }
   KEYWORD_NAMES.freeze
 
-  PATTERN_WS        = %r{[[:blank:]\r]+}
-  PATTERN_NON_WS    = %r{\w+\b?}
+  PATTERN_WS        = /[[:blank:]\r]+/
+  PATTERN_NON_WS    = /\w+\b?/
 
   # The single line comment includes the line ending.
-  PATTERN_COMMENT   = %r{#.*\r?}
+  PATTERN_COMMENT   = /#.*\r?/
   PATTERN_MLCOMMENT = %r{/\*(.*?)\*/}m
 
   PATTERN_REGEX     = %r{/[^/]*/}
@@ -170,13 +170,13 @@ class Lexer2
   # The NAME and CLASSREF in 4x are strict. Each segment must start with
   # a letter a-z and may not contain dashes (\w includes letters, digits and _).
   #
-  PATTERN_CLASSREF       = %r{((::){0,1}[A-Z][\w]*)+}
-  PATTERN_NAME           = %r{^((::)?[a-z][\w]*)(::[a-z][\w]*)*$}
+  PATTERN_CLASSREF       = /((::){0,1}[A-Z]\w*)+/
+  PATTERN_NAME           = /^((::)?[a-z]\w*)(::[a-z]\w*)*$/
 
-  PATTERN_BARE_WORD      = %r{((?:::){0,1}(?:[a-z_](?:[\w-]*[\w])?))+}
+  PATTERN_BARE_WORD      = /((?:::){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}
+  PATTERN_DOLLAR_VAR     = /\$(::)?(\w+::)*\w+/
+  PATTERN_NUMBER         = /\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b/
 
   # PERFORMANCE NOTE:
   # Comparison against a frozen string is faster (than unfrozen).
@@ -268,7 +268,11 @@ class Lexer2
       '|' => lambda do
         scn = @scanner
         la = scn.peek(3)
-        emit(la[1] == '>' ? (la[2] == '>' ? TOKEN_RRCOLLECT : TOKEN_RCOLLECT) : TOKEN_PIPE, scn.pos)
+        emit(if la[1] == '>'
+               la[2] == '>' ? TOKEN_RRCOLLECT : TOKEN_RCOLLECT
+             else
+               TOKEN_PIPE
+             end, scn.pos)
       end,
 
       # TOKENS =, =>, ==, =~
@@ -522,7 +526,7 @@ class Lexer2
               end
             end
             scn.pos = before
-            invalid_number = scn.peek(after - before) unless invalid_number
+            invalid_number ||= scn.peek(after - before)
           end
           assert_numeric(invalid_number, before)
           scn.pos = before + 1
@@ -635,7 +639,11 @@ class Lexer2
     @scanner = StringScanner.new(string)
     @locator = locator || Locator.locator(string, '')
     @lexing_context[:escapes] = escapes || UQ_ESCAPES
-    @lexing_context[:uq_slurp_pattern] = interpolate ? (escapes.include?('$') ? SLURP_UQ_PATTERN : SLURP_UQNE_PATTERN) : SLURP_ALL_PATTERN
+    @lexing_context[:uq_slurp_pattern] = if interpolate
+                                           escapes.include?('$') ? SLURP_UQ_PATTERN : SLURP_UQNE_PATTERN
+                                         else
+                                           SLURP_ALL_PATTERN
+                                         end
   end
 
   # Convenience method, and for compatibility with older lexer. Use the lex_file instead.
@@ -706,7 +714,7 @@ class Lexer2
     scn.skip(PATTERN_WS)
 
     # This is the lexer's main loop
-    until queue.empty? && scn.eos? do
+    until queue.empty? && scn.eos?
       token = queue.shift || selector[scn.peek(1)].call
       if token
         ctx[:after] = token[0]