puppet 8.5.0-x86-mingw32 → 8.6.0-x86-mingw32

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]

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

@@ -200,7 +200,7 @@ module LexerSupport
     lex_error_without_pos(
       Puppet::Pops::Issues::ILLEGAL_BOM,
       { :format_name => name,
-        :bytes => "[#{bom.values[0, size].map { |b| "%X" % b }.join(" ")}]" }
+        :bytes => "[#{bom.values[0, size].map { |b| '%X' % b }.join(' ')}]" }
     )
   end
 

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

@@ -141,7 +141,7 @@ class Locator
       satisfied = false
       v = nil
 
-      while low < high do
+      while low < high
         mid = low + ((high - low) / 2)
         v = (ary[mid] > value)
         if v == true
@@ -161,9 +161,9 @@ class Locator
       end
 
       return nil if low == ary.length
-      return nil if !satisfied
+      return nil unless satisfied
 
-      return low
+      low
     end
 
     def hash
@@ -192,7 +192,7 @@ class Locator
       # If not found it is after last
       # clear cache
       @prev_offset = @prev_line = nil
-      return line_index.size
+      line_index.size
     end
   end
 

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

@@ -77,7 +77,7 @@ class Parser
   def parse_file(file)
     unless Puppet::FileSystem.exist?(file)
       unless file =~ /\.pp$/
-        file = file + ".pp"
+        file += ".pp"
       end
     end
     @lexer.file = file
@@ -193,16 +193,15 @@ class Parser
     # where the "10, notice" forms an argument list. The parser builds an Array with the expressions and includes
     # the comma tokens to enable the error to be reported against the first comma.
     #
-    begin
-      Factory.transform_calls(expressions)
-    rescue Factory::ArgsToNonCallError => e
-      # e.args[1] is the first comma token in the list
-      # e.name_expr is the function name expression
-      if e.name_expr.is_a?(Factory) && e.name_expr.model_class <= Model::QualifiedName
-        error(e.args[1], _("attempt to pass argument list to the function '%{name}' which cannot be called without parentheses") % { name: e.name_expr['value'] })
-      else
-        error(e.args[1], _("illegal comma separated argument list"))
-      end
+
+    Factory.transform_calls(expressions)
+  rescue Factory::ArgsToNonCallError => e
+    # e.args[1] is the first comma token in the list
+    # e.name_expr is the function name expression
+    if e.name_expr.is_a?(Factory) && e.name_expr.model_class <= Model::QualifiedName
+      error(e.args[1], _("attempt to pass argument list to the function '%{name}' which cannot be called without parentheses") % { name: e.name_expr['value'] })
+    else
+      error(e.args[1], _("illegal comma separated argument list"))
     end
   end
 
@@ -229,8 +228,7 @@ class Parser
     _, token = @lexer.emit_completed([:NOOP, '', 0], locator.string.bytesize)
     loc(no_op, token)
     # Program with a Noop
-    program = Factory.PROGRAM(no_op, [], locator)
-    program
+    Factory.PROGRAM(no_op, [], locator)
   end
 
   # Performs the parsing and returns the resulting model.
@@ -243,7 +241,7 @@ class Parser
       @yydebug = false
       main = yyparse(@lexer, :scan)
     end
-    return main
+    main
   ensure
     @lexer.clear
     @namestack = []

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

@@ -196,7 +196,7 @@ class PNParser
   end
 
   def consume_identifier(s)
-    while @char_types[peek_cp] >= TYPE_IDENTIFIER do
+    while @char_types[peek_cp] >= TYPE_IDENTIFIER
       @pos += 1
     end
     id = @text[s...@pos]
@@ -287,7 +287,7 @@ class PNParser
       c = peek_cp
     end
 
-    while @char_types[c] == TYPE_DIGIT do
+    while @char_types[c] == TYPE_DIGIT
       @pos += 1
       c = peek_cp
       count += 1
@@ -296,7 +296,7 @@ class PNParser
   end
 
   def skip_white
-    while @char_types[peek_cp] == TYPE_WS do
+    while @char_types[peek_cp] == TYPE_WS
       @pos += 1
     end
   end

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

@@ -13,15 +13,15 @@ module Parser
 module SlurpSupport
   include LexerSupport
 
-  SLURP_SQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*[']/
-  SLURP_DQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*(["]|[$]\{?)/
-  SLURP_UQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*([$]\{?|\z)/
+  SLURP_SQ_PATTERN  = /(?:[^\\]|^)(?:\\{2})*'/
+  SLURP_DQ_PATTERN  = /(?:[^\\]|^)(?:\\{2})*("|[$]\{?)/
+  SLURP_UQ_PATTERN  = /(?:[^\\]|^)(?:\\{2})*([$]\{?|\z)/
   # unquoted, no escapes
   SLURP_UQNE_PATTERN = /(\$\{?|\z)/m
   SLURP_ALL_PATTERN = /.*(\z)/m
-  SQ_ESCAPES = %w{\\ '}
-  DQ_ESCAPES = %w{\\  $ ' " r n t s u} + ["\r\n", "\n"]
-  UQ_ESCAPES = %w{\\  $ r n t s u} + ["\r\n", "\n"]
+  SQ_ESCAPES = %w[\\ ']
+  DQ_ESCAPES = %w[\\  $ ' " r n t s u] + ["\r\n", "\n"]
+  UQ_ESCAPES = %w[\\  $ r n t s u] + ["\r\n", "\n"]
 
   def slurp_sqstring
     # skip the leading '
@@ -76,14 +76,14 @@ module SlurpSupport
     # If later a \u is found it is warned not to be a unicode escape
     if escapes.include?('u')
       # gsub must be repeated to cater for adjacent escapes
-      while (str.gsub!(/((?:[^\\]|^)(?:[\\]{2})*)\\u(?:([\da-fA-F]{4})|\{([\da-fA-F]{1,6})\})/m) { $1 + [($2 || $3).hex].pack("U") })
+      while str.gsub!(/((?:[^\\]|^)(?:\\{2})*)\\u(?:([\da-fA-F]{4})|\{([\da-fA-F]{1,6})\})/m) { ::Regexp.last_match(1) + [(::Regexp.last_match(2) || ::Regexp.last_match(3)).hex].pack("U") }
         # empty block. Everything happens in the gsub block
       end
     end
 
     begin
       str.gsub!(/\\([^\r\n]|(?:\r?\n))/m) {
-        ch = $1
+        ch = ::Regexp.last_match(1)
         if escapes.include? ch
           case ch
           when 'r'; "\r"

data/lib/puppet/pops/patterns.rb

@@ -13,48 +13,48 @@ module Puppet::Pops::Patterns
   # Thus, a hex number has group 3 value, an octal value has group 4 (if it starts with 0), and no group 3
   # and a floating point value has group 4 and group 5.
   #
-  NUMERIC = %r{\A[[:blank:]]*([-+]?)[[:blank:]]*((0[xX][0-9A-Fa-f]+)|(0?\d+)((?:\.\d+)?(?:[eE]-?\d+)?))[[:blank:]]*\z}
+  NUMERIC = /\A[[:blank:]]*([-+]?)[[:blank:]]*((0[xX][0-9A-Fa-f]+)|(0?\d+)((?:\.\d+)?(?:[eE]-?\d+)?))[[:blank:]]*\z/
 
   # Special expression that tests if there is whitespace between sign and number. The expression is used
   # to strip such whitespace when normal Float or Integer conversion fails.
-  WS_BETWEEN_SIGN_AND_NUMBER = %r{\A([+-])[[:blank:]]+(.*)\z}
+  WS_BETWEEN_SIGN_AND_NUMBER = /\A([+-])[[:blank:]]+(.*)\z/
 
   # ILLEGAL_P3_1_HOSTNAME matches if a hostname contains illegal characters.
   # This check does not prevent pathological names like 'a....b', '.....', "---". etc.
-  ILLEGAL_HOSTNAME_CHARS = %r{[^-\w.]}
+  ILLEGAL_HOSTNAME_CHARS = /[^-\w.]/
 
   # NAME matches a name the same way as the lexer.
-  NAME = %r{\A((::)?[a-z]\w*)(::[a-z]\w*)*\z}
+  NAME = /\A((::)?[a-z]\w*)(::[a-z]\w*)*\z/
 
   # CLASSREF_EXT matches a class reference the same way as the lexer - i.e. the external source form
   # where each part must start with a capital letter A-Z.
   #
-  CLASSREF_EXT = %r{\A((::){0,1}[A-Z][\w]*)+\z}
+  CLASSREF_EXT = /\A((::){0,1}[A-Z]\w*)+\z/
 
   # Same as CLASSREF_EXT but cannot start with '::'
   #
-  CLASSREF_EXT_DECL = %r{\A[A-Z][\w]*(?:::[A-Z][\w]*)*\z}
+  CLASSREF_EXT_DECL = /\A[A-Z]\w*(?:::[A-Z]\w*)*\z/
 
   # CLASSREF matches a class reference the way it is represented internally in the
   # model (i.e. in lower case).
   #
-  CLASSREF = %r{\A((::){0,1}[a-z][\w]*)+\z}
+  CLASSREF = /\A((::){0,1}[a-z]\w*)+\z/
 
   # Same as CLASSREF but cannot start with '::'
   #
-  CLASSREF_DECL = %r{\A[a-z][\w]*(?:::[a-z][\w]*)*\z}
+  CLASSREF_DECL = /\A[a-z]\w*(?:::[a-z]\w*)*\z/
 
   # DOLLAR_VAR matches a variable name including the initial $ character
-  DOLLAR_VAR = %r{\$(::)?(\w+::)*\w+}
+  DOLLAR_VAR = /\$(::)?(\w+::)*\w+/
 
   # VAR_NAME matches the name part of a variable (The $ character is not included)
   # Note, that only the final segment may start with an underscore.
   # Note, regexp sensitive to backtracking
-  VAR_NAME = %r{\A(?:::)?(?:[a-z]\w*::)*[a-z_]\w*\z}
+  VAR_NAME = /\A(?:::)?(?:[a-z]\w*::)*[a-z_]\w*\z/
 
   # PARAM_NAME matches the name part of a parameter (The $ character is not included)
-  PARAM_NAME = %r{\A[a-z_]\w*\z}
+  PARAM_NAME = /\A[a-z_]\w*\z/
 
   # A Numeric var name must be the decimal number 0, or a decimal number not starting with 0
-  NUMERIC_VAR_NAME = %r{\A(?:0|(?:[1-9][0-9]*))\z}
+  NUMERIC_VAR_NAME = /\A(?:0|(?:[1-9][0-9]*))\z/
 end

data/lib/puppet/pops/pcore.rb

@@ -10,7 +10,7 @@ module Pcore
   TYPE_URI = Types::TypeFactory.pattern(TYPE_URI_RX)
   TYPE_URI_ALIAS = Types::PTypeAliasType.new('Pcore::URI', nil, TYPE_URI)
   TYPE_SIMPLE_TYPE_NAME = Types::TypeFactory.pattern(/\A[A-Z]\w*\z/)
-  TYPE_QUALIFIED_REFERENCE = Types::TypeFactory.pattern(/\A[A-Z][\w]*(?:::[A-Z][\w]*)*\z/)
+  TYPE_QUALIFIED_REFERENCE = Types::TypeFactory.pattern(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/)
   TYPE_MEMBER_NAME = Types::PPatternType.new([Types::PRegexpType.new(Patterns::PARAM_NAME)])
 
   KEY_PCORE_URI = 'pcore_uri'

data/lib/puppet/pops/pn.rb

@@ -116,7 +116,7 @@ module PN
     end
 
     def to_data
-      { '^' => [@name] + @elements.map { |e| e.to_data } }
+      { '^' => [@name] + @elements.map(&:to_data) }
     end
   end
 
@@ -166,7 +166,7 @@ module PN
     end
 
     def to_data
-      @elements.map { |e| e.to_data }
+      @elements.map(&:to_data)
     end
   end
 

data/lib/puppet/pops/puppet_stack.rb

@@ -32,7 +32,7 @@ module Puppet
       @stack = Puppet::ThreadLocal.new { Array.new }
 
       def self.stack(file, line, obj, message, args, &block)
-        file = 'unknown' if (file.nil? || file == '')
+        file = 'unknown' if file.nil? || file == ''
         line = 0 if line.nil?
 
         result = nil

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

@@ -75,7 +75,7 @@ class ResourceTypeImpl
     return nil unless other.is_a?(Puppet::CompilableResourceType)
 
     # against other type instances.
-    self.ref <=> other.ref
+    ref <=> other.ref
   end
 
   METAPARAMS = [

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

@@ -143,7 +143,7 @@ class AbstractReader
       read_payload(data) do |ep|
         sec = ep.read
         nsec = ep.read
-        Time::Timestamp.new(sec * 1000000000 + nsec)
+        Time::Timestamp.new(sec * 1_000_000_000 + nsec)
       end
     end
 
@@ -151,7 +151,7 @@ class AbstractReader
       read_payload(data) do |ep|
         sec = ep.read
         nsec = ep.read
-        Time::Timespan.new(sec * 1000000000 + nsec)
+        Time::Timespan.new(sec * 1_000_000_000 + nsec)
       end
     end
 

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

@@ -178,11 +178,11 @@ class AbstractWriter
     end
 
     register_type(Extension::TIME, Time::Timestamp) do |o|
-      build_payload { |ep| nsecs = o.nsecs; ep.write(nsecs / 1000000000); ep.write(nsecs % 1000000000) }
+      build_payload { |ep| nsecs = o.nsecs; ep.write(nsecs / 1_000_000_000); ep.write(nsecs % 1_000_000_000) }
     end
 
     register_type(Extension::TIMESPAN, Time::Timespan) do |o|
-      build_payload { |ep| nsecs = o.nsecs; ep.write(nsecs / 1000000000); ep.write(nsecs % 1000000000) }
+      build_payload { |ep| nsecs = o.nsecs; ep.write(nsecs / 1_000_000_000); ep.write(nsecs % 1_000_000_000) }
     end
 
     register_type(Extension::VERSION, SemanticPuppet::Version) do |o|
@@ -213,7 +213,7 @@ class AbstractWriter
   end
 
   def to_s
-    "#{self.class.name}"
+    self.class.name.to_s
   end
 
   def inspect

data/lib/puppet/pops/time/timestamp.rb

@@ -107,7 +107,7 @@ class Timestamp < TimeData
     fraction = parsed[:sec_fraction]
 
     # Convert msec rational found in _strptime hash to usec
-    fraction = fraction * 1000000 unless fraction.nil?
+    fraction *= 1_000_000 unless fraction.nil?
 
     # Create the Time instance and adjust for timezone
     parsed_time = ::Time.utc(parsed[:year], parsed[:mon], parsed[:mday], parsed[:hour], parsed[:min], parsed[:sec], fraction)

data/lib/puppet/pops/types/class_loader.rb

@@ -37,7 +37,7 @@ class ClassLoader
   def self.provide_from_type(type)
     case type
     when PRuntimeType
-      raise ArgumentError.new("Only Runtime type 'ruby' is supported, got #{type.runtime}") unless type.runtime == :ruby
+      raise ArgumentError, "Only Runtime type 'ruby' is supported, got #{type.runtime}" unless type.runtime == :ruby
 
       provide_from_string(type.runtime_type_name)
 
@@ -105,11 +105,9 @@ class ClassLoader
 
   def self.find_class(name_path)
     name_path.reduce(Object) do |ns, name|
-      begin
-        ns.const_get(name, false) # don't search ancestors
-      rescue NameError
-        return nil
-      end
+      ns.const_get(name, false) # don't search ancestors
+    rescue NameError
+      return nil
     end
   end
   private_class_method :find_class

data/lib/puppet/pops/types/iterable.rb

@@ -32,7 +32,7 @@ module Puppet::Pops::Types
     # @raise [ArgumentError] In case an `Iterable` cannot be produced
     # @api public
     def self.asserted_iterable(my_caller, obj, infer_elements = false)
-      iter = self.on(obj, nil, infer_elements)
+      iter = on(obj, nil, infer_elements)
       raise ArgumentError, "#{my_caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
 
       iter

data/lib/puppet/pops/types/p_binary_type.rb

@@ -122,7 +122,7 @@ class PBinaryType < PAnyType
     end
 
     def ==(o)
-      self.eql?(o)
+      eql?(o)
     end
 
     def length

data/lib/puppet/pops/types/p_init_type.rb

@@ -152,7 +152,7 @@ class PInitType < PTypeWithContainedType
       # The Optional is the same as Variant[T,Undef].
       # The NotUndef is not meaningful to create instances of
       if @type.instance_of?(PInitType) || @type.instance_of?(POptionalType) || @type.instance_of?(PNotUndefType)
-        raise ArgumentError.new
+        raise ArgumentError
       end
 
       new_func = @type.new_function