puppet 8.4.0-universal-darwin → 8.5.0-universal-darwin

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

@@ -72,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
@@ -82,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
 
@@ -123,7 +125,7 @@ class Lexer2
     'default' => [:DEFAULT, 'default', 7],
     'define' => [:DEFINE, 'define', 6],
     'if' => [:IF, 'if', 2],
-    'elsif' => [:ELSIF,    'elsif', 5],
+    'elsif' => [:ELSIF, 'elsif', 5],
     'else' => [:ELSE, 'else', 4],
     'inherits' => [:INHERITS, 'inherits', 8],
     'node' => [:NODE, 'node', 4],
@@ -140,12 +142,12 @@ class Lexer2
     '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]+}
@@ -183,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.
@@ -200,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 '('
@@ -212,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
@@ -252,9 +254,10 @@ class Lexer2
       '@' => 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)
@@ -342,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
@@ -364,7 +367,7 @@ class Lexer2
               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
@@ -425,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
@@ -455,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)
@@ -488,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
@@ -523,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
@@ -550,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
@@ -577,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
 
@@ -599,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
@@ -615,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)
@@ -678,7 +679,7 @@ class Lexer2
   #
   def fullscan
     result = []
-    scan {|token| result.push(token) }
+    scan { |token| result.push(token) }
     result
   end
 

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

@@ -12,7 +12,7 @@ module LexerSupport
   def followed_by
     return "<eof>" if @scanner.eos?
 
-    result = @scanner.rest[0,5] + "..."
+    result = @scanner.rest[0, 5] + "..."
     result.gsub!("\t", '\t')
     result.gsub!("\n", '\n')
     result.gsub!("\r", '\r')
@@ -34,7 +34,7 @@ module LexerSupport
   end
 
   # Raises a Puppet::ParserErrorWithIssue with the given issue and arguments
-  def lex_error(issue, args = {}, pos=nil)
+  def lex_error(issue, args = {}, pos = nil)
     raise create_lex_error(issue, args, pos)
   end
 
@@ -51,7 +51,7 @@ module LexerSupport
     @locator.pos_on_line(pos || @scanner.pos)
   end
 
-  def lex_warning(issue, args = {}, pos=nil)
+  def lex_warning(issue, args = {}, pos = nil)
     Puppet::Util::Log.create({
                                :level => :warning,
                                :message => issue.format(args),
@@ -74,24 +74,26 @@ module LexerSupport
       position(pos),
       nil,
       issue.issue_code,
-      args)
+      args
+    )
   end
 
   # Asserts that the given string value is a float, or an integer in decimal, octal or hex form.
   # An error is raised if the given value does not comply.
   #
   def assert_numeric(value, pos)
-    if value =~ /^0[xX]/
-      lex_error(Issues::INVALID_HEX_NUMBER, {:value => value}, pos)     unless value =~ /^0[xX][0-9A-Fa-f]+$/
+    case value
+    when /^0[xX]/
+      lex_error(Issues::INVALID_HEX_NUMBER, { :value => value }, pos)     unless value =~ /^0[xX][0-9A-Fa-f]+$/
 
-    elsif value =~ /^0[^.]/
-      lex_error(Issues::INVALID_OCTAL_NUMBER, {:value => value}, pos)   unless value =~ /^0[0-7]+$/
+    when /^0[^.]/
+      lex_error(Issues::INVALID_OCTAL_NUMBER, { :value => value }, pos)   unless value =~ /^0[0-7]+$/
 
-    elsif value =~ /^\d+[eE.]/
-      lex_error(Issues::INVALID_DECIMAL_NUMBER, {:value => value}, pos) unless value =~ /^\d+(?:\.\d+)?(?:[eE]-?\d+)?$/
+    when /^\d+[eE.]/
+      lex_error(Issues::INVALID_DECIMAL_NUMBER, { :value => value }, pos) unless value =~ /^\d+(?:\.\d+)?(?:[eE]-?\d+)?$/
 
     else
-      lex_error(Issues::ILLEGAL_NUMBER, {:value => value}, pos) unless value =~ /^\d+$/
+      lex_error(Issues::ILLEGAL_NUMBER, { :value => value }, pos) unless value =~ /^\d+$/
     end
   end
 
@@ -152,14 +154,14 @@ module LexerSupport
   BOM_UTF_8      = MM.new(0xEF, 0xBB, 0xBF,        MM_ANY)
   BOM_UTF_16_1   = MM.new(0xFE, 0xFF,              MM_ANY, MM_ANY)
   BOM_UTF_16_2   = MM.new(0xFF, 0xFE,              MM_ANY, MM_ANY)
-  BOM_UTF_32_1   = MM.new(0x00, 0x00, 0xFE, 0xFF   )
-  BOM_UTF_32_2   = MM.new(0xFF, 0xFE, 0x00, 0x00   )
+  BOM_UTF_32_1   = MM.new(0x00, 0x00, 0xFE, 0xFF)
+  BOM_UTF_32_2   = MM.new(0xFF, 0xFE, 0x00, 0x00)
 
-  BOM_UTF_1      = MM.new(0xF7, 0x64, 0x4C,        MM_ANY)
-  BOM_UTF_EBCDIC = MM.new(0xDD, 0x73, 0x66, 0x73   )
+  BOM_UTF_1      = MM.new(0xF7, 0x64, 0x4C, MM_ANY)
+  BOM_UTF_EBCDIC = MM.new(0xDD, 0x73, 0x66, 0x73)
   BOM_SCSU       = MM.new(0x0E, 0xFE, 0xFF,        MM_ANY)
   BOM_BOCU       = MM.new(0xFB, 0xEE, 0x28,        MM_ANY)
-  BOM_GB_18030   = MM.new(0x84, 0x31, 0x95, 0x33   )
+  BOM_GB_18030   = MM.new(0x84, 0x31, 0x95, 0x33)
 
   LONGEST_BOM    = 4
 
@@ -198,8 +200,8 @@ 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
 
   def get_bom(content)

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

@@ -71,7 +71,7 @@ class Locator
   # Returns the line index - an array of line offsets for the start position of each line, starting at 0 for
   # the first line.
   #
-  def line_index()
+  def line_index
   end
 
   # Common byte based impl that works for all rubies (stringscanner is byte based
@@ -114,7 +114,7 @@ class Locator
 
     # Returns the position on line (first position on a line is 1)
     def pos_on_line(offset)
-      offset_on_line(offset) +1
+      offset_on_line(offset) + 1
     end
 
     def to_location_hash(reported_offset, end_offset)
@@ -122,7 +122,7 @@ class Locator
       offset     = char_offset(reported_offset)
       length     = char_length(reported_offset, end_offset)
       start_line = line_for_offset(reported_offset)
-      { :line => start_line, :pos => pos, :offset => offset, :length => length}
+      { :line => start_line, :pos => pos, :offset => offset, :length => length }
     end
 
     # Returns the index of the smallest item for which the item > the given value
@@ -240,7 +240,7 @@ class Locator
       # The last entry is duplicated since there will be  the line "after last line" that would otherwise require
       # conditional logic.
       #
-      @accumulated_margin = margin_per_line.reduce([0]) {|memo, val| memo << memo[-1] + val; memo }
+      @accumulated_margin = margin_per_line.each_with_object([0]) { |val, memo| memo << memo[-1] + val; }
       @accumulated_margin << @accumulated_margin[-1]
     end
 
@@ -250,7 +250,7 @@ class Locator
 
     # Returns array with transposed (local) offset and (local) length. The transposed values
     # take the margin into account such that it is added to the content to the right
-    # 
+    #
     # Using X to denote margin and where end of line is explicitly shown as \n:
     # ```
     # XXXXabc\n
@@ -268,13 +268,13 @@ class Locator
 
       # compute local start and end line
       start_line = line_for_offset(offset)
-      end_line = line_for_offset(offset+length)
+      end_line = line_for_offset(offset + length)
 
       # complex case when there is a margin
       transposed_offset = offset == 0 ? @leading_offset : offset + @leading_offset + @accumulated_margin[start_line]
       transposed_length = length +
-        @accumulated_margin[end_line] - @accumulated_margin[start_line] +    # the margins between start and end (0 is line 1)
-        (offset_on_line(offset) == 0 ? margin_per_line[start_line - 1] : 0)  # include start's margin in position 0
+                          @accumulated_margin[end_line] - @accumulated_margin[start_line] +    # the margins between start and end (0 is line 1)
+                          (offset_on_line(offset) == 0 ? margin_per_line[start_line - 1] : 0)  # include start's margin in position 0
       [transposed_offset, transposed_length]
     end
 
@@ -291,7 +291,7 @@ class Locator
 
   class LocatorForChars < AbstractLocator
     def offset_on_line(offset)
-      line_offset = line_index[ line_for_offset(offset)-1 ]
+      line_offset = line_index[line_for_offset(offset) - 1]
       offset - line_offset
     end
 
@@ -335,8 +335,8 @@ class Locator
     # Returns the offset on line (first offset on a line is 0).
     # Ruby 19 is multibyte but has no character position methods, must use byteslice
     def offset_on_line(offset)
-      line_offset = line_index[ line_for_offset(offset)-1 ]
-      @string.byteslice(line_offset, offset-line_offset).length
+      line_offset = line_index[line_for_offset(offset) - 1]
+      @string.byteslice(line_offset, offset - line_offset).length
     end
 
     # Returns the character offset for a given byte offset

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

@@ -84,7 +84,7 @@ class Parser
     _parse
   end
 
-  def initialize()
+  def initialize
     @lexer = Lexer2.new
     @namestack = []
     @definitions = []
@@ -92,7 +92,7 @@ class Parser
 
   # This is a callback from the generated parser (when an error occurs while parsing)
   #
-  def on_error(token,value,stack)
+  def on_error(token, value, stack)
     if token == 0 # denotes end of file
       value_at = 'end of input'
     else
@@ -172,7 +172,7 @@ class Parser
     @namestack << name
   end
 
-  def namepop()
+  def namepop
     @namestack.pop
   end
 
@@ -220,13 +220,13 @@ class Parser
 
   # Creates an empty program with a single No-op at the input's EOF offset with 0 length.
   #
-  def create_empty_program()
+  def create_empty_program
     locator = @lexer.locator
     no_op = Factory.literal(nil)
     # Create a synthetic NOOP token at EOF offset with 0 size. The lexer does not produce an EOF token that is
     # visible to the grammar rules. Creating this token is mainly to reuse the positioning logic as it
     # expects a token decorated with location information.
-    _, token = @lexer.emit_completed([:NOOP,'',0], locator.string.bytesize)
+    _, token = @lexer.emit_completed([:NOOP, '', 0], locator.string.bytesize)
     loc(no_op, token)
     # Program with a Noop
     program = Factory.PROGRAM(no_op, [], locator)
@@ -238,10 +238,10 @@ class Parser
   #
   # @api private
   #
-  def _parse()
+  def _parse
     begin
       @yydebug = false
-      main = yyparse(@lexer,:scan)
+      main = yyparse(@lexer, :scan)
     end
     return main
   ensure

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

@@ -140,7 +140,7 @@ class PNParser
     while @token != end_token && @token != TOKEN_END
       elements << parse_next
     end
-    parse_error(_("missing '%{token}' to end list") % { token: end_token.chr(Encoding::UTF_8) } ) unless @token == end_token
+    parse_error(_("missing '%{token}' to end list") % { token: end_token.chr(Encoding::UTF_8) }) unless @token == end_token
     next_token
     elements
   end

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

@@ -17,11 +17,11 @@ module SlurpSupport
   SLURP_DQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*(["]|[$]\{?)/
   SLURP_UQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*([$]\{?|\z)/
   # unquoted, no escapes
-  SLURP_UQNE_PATTERN  = /(\$\{?|\z)/m
+  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,7 +76,7 @@ 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) { $1 + [($2 || $3).hex].pack("U") })
         # empty block. Everything happens in the gsub block
       end
     end
@@ -86,14 +86,14 @@ module SlurpSupport
         ch = $1
         if escapes.include? ch
           case ch
-          when 'r'   ; "\r"
-          when 'n'   ; "\n"
-          when 't'   ; "\t"
-          when 's'   ; ' '
+          when 'r'; "\r"
+          when 'n'; "\n"
+          when 't'; "\t"
+          when 's'; ' '
           when 'u'
             lex_warning(Issues::ILLEGAL_UNICODE_ESCAPE)
             "\\u"
-          when "\n"  ; ''
+          when "\n"; ''
           when "\r\n"; ''
           else ch
           end

data/lib/puppet/pops/pcore.rb

@@ -17,7 +17,7 @@ module Pcore
   KEY_PCORE_VERSION = 'pcore_version'
 
   PCORE_URI = 'http://puppet.com/2016.1/pcore'
-  PCORE_VERSION = SemanticPuppet::Version.new(1,0,0)
+  PCORE_VERSION = SemanticPuppet::Version.new(1, 0, 0)
   PARSABLE_PCORE_VERSIONS = SemanticPuppet::VersionRange.parse('1.x')
 
   RUNTIME_NAME_AUTHORITY = 'http://puppet.com/2016.1/runtime'

data/lib/puppet/pops/pn.rb

@@ -213,7 +213,7 @@ module PN
     def format(indent, b)
       local_indent = indent ? indent.increase : nil
       b << '{'
-      @entries.each_with_index do |e,i|
+      @entries.each_with_index do |e, i|
         if indent
           b << "\n" << local_indent.current
         elsif i > 0
@@ -237,4 +237,3 @@ end
 
 require_relative 'model/pn_transformer'
 require_relative 'parser/pn_parser'
-

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

@@ -21,18 +21,17 @@ class Param
   include Puppet::Pops::Types::PuppetObject
 
   def self.register_ptype(loader, ir)
-    @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::Param', nil,
-                                       {
-                                         Types::KEY_TYPE => Types::PTypeType::DEFAULT,
-                                         Types::KEY_NAME => Types::PStringType::NON_EMPTY,
-                                         'name_var' => {
-                                           Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
-                                           Types::KEY_VALUE => false
-                                         }
-                                       },
-                                       EMPTY_HASH,
-                                       [Types::KEY_NAME]
-    )
+    @ptype = Pcore.create_object_type(loader, ir, self, 'Puppet::Resource::Param', nil,
+                                      {
+                                        Types::KEY_TYPE => Types::PTypeType::DEFAULT,
+                                        Types::KEY_NAME => Types::PStringType::NON_EMPTY,
+                                        'name_var' => {
+                                          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+                                          Types::KEY_VALUE => false
+                                        }
+                                      },
+                                      EMPTY_HASH,
+                                      [Types::KEY_NAME])
   end
 
   attr_reader :name

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

@@ -8,7 +8,7 @@ def self.register_ptypes(loader, ir)
   types = [Param, ResourceTypeImpl].map do |c|
     c.register_ptype(loader, ir)
   end
-  types.each {|t| t.resolve(loader) }
+  types.each { |t| t.resolve(loader) }
 end
 
 class ResourceTypeImpl
@@ -28,34 +28,34 @@ class ResourceTypeImpl
 
   def self.register_ptype(loader, ir)
     param_ref = Types::PTypeReferenceType.new('Puppet::Resource::Param')
-    @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::ResourceType3', nil,
-                                       {
-                                         Types::KEY_NAME => Types::PStringType::NON_EMPTY,
-                                         'properties' => {
-                                           Types::KEY_TYPE => Types::PArrayType.new(param_ref),
-                                           Types::KEY_VALUE => EMPTY_ARRAY
-                                         },
-                                         'parameters' => {
-                                           Types::KEY_TYPE => Types::PArrayType.new(param_ref),
-                                           Types::KEY_VALUE => EMPTY_ARRAY
-                                         },
-                                         'title_patterns_hash' => {
-                                           Types::KEY_TYPE => Types::POptionalType.new(
-                                             Types::PHashType.new(Types::PRegexpType::DEFAULT, Types::PArrayType.new(Types::PStringType::NON_EMPTY))),
-                                           Types::KEY_VALUE => nil
-                                         },
-                                         'isomorphic' => {
-                                           Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
-                                           Types::KEY_VALUE => true
-                                         },
-                                         'capability' => {
-                                           Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
-                                           Types::KEY_VALUE => false
-                                         },
-                                       },
-                                       EMPTY_HASH,
-                                       [Types::KEY_NAME]
-    )
+    @ptype = Pcore.create_object_type(loader, ir, self, 'Puppet::Resource::ResourceType3', nil,
+                                      {
+                                        Types::KEY_NAME => Types::PStringType::NON_EMPTY,
+                                        'properties' => {
+                                          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
+                                          Types::KEY_VALUE => EMPTY_ARRAY
+                                        },
+                                        'parameters' => {
+                                          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
+                                          Types::KEY_VALUE => EMPTY_ARRAY
+                                        },
+                                        'title_patterns_hash' => {
+                                          Types::KEY_TYPE => Types::POptionalType.new(
+                                            Types::PHashType.new(Types::PRegexpType::DEFAULT, Types::PArrayType.new(Types::PStringType::NON_EMPTY))
+                                          ),
+                                          Types::KEY_VALUE => nil
+                                        },
+                                        'isomorphic' => {
+                                          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+                                          Types::KEY_VALUE => true
+                                        },
+                                        'capability' => {
+                                          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+                                          Types::KEY_VALUE => false
+                                        },
+                                      },
+                                      EMPTY_HASH,
+                                      [Types::KEY_NAME])
   end
 
   def eql?(other)
@@ -118,7 +118,7 @@ class ResourceTypeImpl
     @attr_types = {}
 
     # Add all meta params
-    METAPARAMS.each {|p| @attr_types[p] = :meta }
+    METAPARAMS.each { |p| @attr_types[p] = :meta }
 
     @property_set = Set.new(properties.map do |p|
       symname = p.name.to_sym
@@ -150,12 +150,12 @@ class ResourceTypeImpl
         nil
       when 1
         if @title_patterns_hash.nil?
-          [ [ /(.*)/m, [ [@key_attributes.first] ] ] ]
+          [[/(.*)/m, [[@key_attributes.first]]]]
         else
           # TechDebt: The case of having one namevar and an empty title patterns is unspecified behavior in puppet.
           # Here, it may lead to an empty map which may or may not trigger the wanted/expected behavior.
           #
-          @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym ] } ] }
+          @title_patterns_hash.map { |k, v| [k, v.map { |n| [n.to_sym] }] }
         end
       else
         if @title_patterns_hash.nil? || @title_patterns_hash.empty?
@@ -167,7 +167,7 @@ class ResourceTypeImpl
           raise Puppet::DevError, _("you must specify title patterns when there are two or more key attributes")
         end
 
-        @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym] } ] }
+        @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k, v| [k, v.map { |n| [n.to_sym] }] }
       end
   end
 
@@ -190,7 +190,7 @@ class ResourceTypeImpl
   #
   # This implementation does nothing - it is assumed that the catalog is already validated
   # via the relationship validator (done late in the game).
-  def finish()
+  def finish
     # Do nothing.
   end
 

data/lib/puppet/pops/semantic_error.rb

@@ -11,7 +11,7 @@ class Puppet::Pops::SemanticError < RuntimeError
   # @param semantic [Puppet::Pops::Model::Locatable, nil] the expression causing the failure, or nil if unknown
   # @param options [Hash] an options hash with Symbol to value mapping - these are the arguments to the issue
   #
-  def initialize(issue, semantic=nil, options = {})
+  def initialize(issue, semantic = nil, options = {})
     @issue = issue
     @semantic = semantic
     @options = options