vinter 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 319f22f198207f7d9d3b9e58c85327b20f7c873e905bc16a38acd6f9199d8b56
-  data.tar.gz: c5eeb2b1dd21094be8a901e570540b89a29619273b0c5fcb11b7edc278da9975
+  metadata.gz: 617e3da0fed64bcf718e3c1e3bd82a66e910e4a2099a27942a2390c93421779b
+  data.tar.gz: a54306cbf4b2e25921c3518985acb0d648096a66e1f24a86e59ac3aa53d56810
 SHA512:
-  metadata.gz: b1556c23fd42b7b7d9d3163a97ecd353902f12341c203a913a4dffec05cbd6ffe867815f223dbfe8f169fd99c514b8b39ac1fab87fd26f195d0622fff9e62966
-  data.tar.gz: 2204f688018212f0b5ec6b13a0906da8a24078fe874dc10c2b9b326668627fb985fdcc11b9682bdbb67f2a452838b8088286260de54bf8941b6501180a7a8704
+  metadata.gz: 614e2e7ef3f02f16a8888069c40244761a7c3afb142b84aafb410c39693e25d4e3d9afa9e4a8bafea24512dc9b339364bf8e0ace1a665d424d0f638428d4b7f9
+  data.tar.gz: 8ace7e570a66a113e66c411d5725f1a72fc3596faffcda899e3590b37b7893aaff21aeefc4d1e1e60fa2cc20f830377417c493b88af4ab90f126f72b843ee521

data/lib/vinter/cli.rb

@@ -6,7 +6,7 @@ module Vinter
 
     def run(args)
       if args.empty?
-        puts "Usage: vinter [file.vim|directory] [--print-ast]"
+        puts "Usage: vinter [file.vim|directory]"
         return 1
       end
 

data/lib/vinter/lexer.rb

@@ -2,9 +2,10 @@ module Vinter
   class Lexer
     TOKEN_TYPES = {
       # Vim9 specific keywords
-      keyword: /\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|endfunc|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|scriptencoding|abort|autocmd|echom|echoerr|echohl|echomsg|let|unlet|execute|exec|continue|break|try|catch|finally|endtry|throw|runtime|silent|delete|command|call|set|setlocal|syntax|highlight|sleep|source|nnoremap|nmap|inoremap|imap|vnoremap|vmap|xnoremap|xmap|cnoremap|cmap|noremap|map|var)\b/,
-      encodings: /\b(latin1|iso|koi8|macroman|cp437|cp737|cp775|cp850|cp852|cp855|cp857|cp860|cp861|cp862|cp863|cp865|cp866|cp869|cp874|cp1250|cp1251|cp1253|cp1254|cp1255|cp1256|cp1257|cp1258|cp932|euc\-jp|sjis|cp949|euc\-kr|cp936|euc\-cn|cp950|big5|euc\-tw|utf\-8|ucs\-2|ucs\-21e|utf\-16|utf\-16le|ucs\-4|ucs\-4le|ansi|japan|korea|prc|chinese|taiwan|utf8|unicode|ucs2be|ucs\-2be|ucs\-4be|utf\-32|utf\-32le|default)\b/,
-      vimfuncs: /\b(win_execute|win_findbuf|win_getid|win_gettype|win_gotoid|win_id2tabwin|win_id2win|win_move_separator|win_move_statusline|win_screenpos|win_splitmove)\b/,
+      keyword: /\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|endfunc|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|scriptencoding|abort|autocmd|echom|echoerr|echohl|echomsg|let|unlet|execute|exec|continue|break|try|catch|finally|endtry|throw|runtime|silent|delete|command|call|set|setlocal|syntax|sleep|source|nnoremap|nmap|inoremap|imap|vnoremap|vmap|xnoremap|xmap|cnoremap|cmap|noremap|map|var)\b/,
+      encodings: /\b(latin1|iso|koi8|macroman|cp437|cp737|cp775|cp850|cp852|cp855|cp857|cp860|cp861|cp862|cp863|cp865|cp866|cp869|cp874|cp1250|cp1251|cp1253|cp1254|cp1255|cp1256|cp1257|cp1258|cp932|euc\-jp|sjis|cp949|euc\-kr|cp936|euc\-cn|cp950|big5|euc\-tw|utf\-8|ucs\-2|ucs\-21e|utf\-16|utf\-16le|ucs\-4|ucs\-4le|ansi|japan|korea|prc|chinese|taiwan|utf8|unicode|ucs2be|ucs\-2be|ucs\-4be|utf\-32|utf\-32le)\b/,
+      vimfuncs: /\b(win_execute|win_findbuf|win_getid|win_gettype|win_gotoid|win_id2tabwin|win_id2win|win_move_separator|win_move_statusline|win_screenpos|win_splitmove|setbufline)\b/,
+      builtin_funcs: /\b(highlight|hi|exe|normal!|normal)\b/,
       # Identifiers can include # and special characters
       identifier: /\b[a-zA-Z_][a-zA-Z0-9_#]*\b/,
       # Single-character operators
@@ -146,44 +147,84 @@ module Vinter
           next
         end
 
+        # XXX: i dont like this not being combined with $' condition above
+        if chunk.start_with?('$"')
+          i = 2
+          string_value = '$"'
+          brace_depth = 0
+          escaped = false
+
+          while i < chunk.length
+            char = chunk[i]
+            string_value += char
+
+            if char == '\\' && !escaped
+              escaped = true
+            elsif char == '"' && !escaped && brace_depth == 0
+              # End of interpolated string
+              i += 1
+              break
+            elsif char == '{' && !escaped
+              brace_depth += 1
+            elsif char == '}' && !escaped && brace_depth > 0
+              brace_depth -= 1
+            elsif escaped
+              escaped = false
+            end
+
+            i += 1
+          end
+
+          @tokens << {
+            type: :interpolated_string,
+            value: string_value,
+            line: @line_num,
+            column: @column
+          }
+          @column += string_value.length
+          @position += string_value.length
+          @line_num += string_value.count("\n")
+          next
+        end
+
         # Handle string literals manually
         if chunk.start_with?("'") || chunk.start_with?('"')
           quote = chunk[0]
           i = 1
-          escaped = false
           string_value = quote
 
           # Keep going until we find an unescaped closing quote
           while i < chunk.length
             char = chunk[i]
+            next_char = chunk[i + 1] if i + 1 < chunk.length
+
             string_value += char
 
-            if char == '\\' && !escaped
-              escaped = true
-            elsif (char == "\n" or char == quote) && !escaped
+            if char == quote && next_char == quote
+              # Handle escaped single quote ('') or double quote ("")
+              string_value += next_char
+              i += 1
+            elsif char == quote
+              # End of string
               i += 1
               break
-            elsif escaped
-              escaped = false
             end
 
             i += 1
           end
 
           # Add the string token if we found a closing quote
-          if i < chunk.length || (i == chunk.length && chunk[-1] == quote)
-            @tokens << {
-              type: :string,
-              value: string_value,
-              line: @line_num,
-              column: @column
-            }
+          @tokens << {
+            type: :string,
+            value: string_value,
+            line: @line_num,
+            column: @column
+          }
 
-            @column += string_value.length
-            @position += string_value.length
-            @line_num += 1 if string_value.include?("\n")
-            next
-          end
+          @column += string_value.length
+          @position += string_value.length
+          @line_num += string_value.count("\n")
+          next
         end
 
         # Add special handling for command options in the tokenize method
@@ -373,7 +414,7 @@ module Vinter
         end
 
         # Add support for standalone namespace prefixes (like g:)
-        if match = chunk.match(/\A([sgbwtal]):/)
+        if match = chunk.match(/\A([gbwt]):/)
           @tokens << {
             type: :namespace_prefix,
             value: match[0],
@@ -485,8 +526,7 @@ module Vinter
         end
 
         # In the tokenize method, add special handling for common mapping components
-        if chunk.start_with?('<CR>', '<Esc>', '<Tab>', '<Space>', '<C-') ||
-           (chunk =~ /\A<[A-Za-z0-9\-_]+>/)
+        if chunk.start_with?('<CR>', '<Esc>', '<Tab>', '<Space>', '<C-')
           # Extract the special key notation
           match = chunk.match(/\A(<[^>]+>)/)
           if match
@@ -529,13 +569,24 @@ module Vinter
           @column += 1
           @position += 1
 
-          # If followed by a newline, advance to next line
+          # If followed by a newline, advance to the next line
           if @position < @input.length && @input[@position] == "\n"
             @line_num += 1
             @column = 1
             @position += 1
           end
 
+          # Skip whitespace after the continuation
+          while @position < @input.length && @input[@position] =~ /\s/
+            if @input[@position] == "\n"
+              @line_num += 1
+              @column = 1
+            else
+              @column += 1
+            end
+            @position += 1
+          end
+
           next
         end
 

data/lib/vinter/parser.rb

@@ -1,3 +1,4 @@
+require 'pry'
 module Vinter
   class Parser
     def initialize(tokens, source_text = nil)
@@ -244,7 +245,6 @@ module Vinter
       if !current_token
         return nil
       end
-      start_token = current_token
 
       # Handle pipe as command separator
       if current_token[:type] == :operator && current_token[:value] == '|'
@@ -378,7 +378,7 @@ module Vinter
           parse_set_command
         when 'syntax'
           parse_syntax_command
-        when 'highlight'
+        when 'highlight', 'hi'
           parse_highlight_command
         when 'sleep'
           parse_sleep_command
@@ -425,23 +425,23 @@ module Vinter
       elsif current_token[:type] == :percentage
         parse_range_command
       elsif current_token[:type] == :global_variable
-        name = current_token[:value]
-        #advance#skip value
-        #advance#operator
-        ##parse_expression_statement
-        #advance#value
-        while peek_token[:line] == current_token[:line]
-          advance
-        end
-        advance
-        {
-          type: :global_variable,
-          name: name
-        }
-
+        parse_global_variable
+      elsif current_token[:type] == :buffer_local
+        parse_buffer_var
       elsif current_token[:type] == :vimfuncs
         advance
         parse_function_call(current_token[:value], current_token[:line], current_token[:column])
+      elsif current_token[:type] == :builtin_funcs
+        parse_builtin_function_call
+      elsif current_token[:type] == :compound_operator
+        advance
+        parse_expression
+      elsif current_token[:type] == :string
+        parse_string
+      elsif current_token[:type] == :comma
+        advance
+      elsif current_token[:type] == :colon
+        parse_command_line_call
       else
         @warnings << {
           message: "Unexpected token type: #{current_token[:type]}",
@@ -454,6 +454,182 @@ module Vinter
       end
     end
 
+    def parse_command_line_call
+      token = advance # Skip the ':'
+      line = token[:line]
+      column = token[:column]
+
+      # Extract the command or range
+      command = token[:value][1..] # Remove the leading ':'
+
+      # Check if the command is a range (e.g., `:2`, `:$`)
+      if command.match?(/^\d+$/) || command == '$'
+        return {
+          type: :range_command,
+          range: command,
+          line: line,
+          column: column
+        }
+      end
+
+      # Otherwise, it's a regular command (e.g., `:exe`)
+      args = []
+      while current_token && current_token[:type] != :newline
+        args << current_token[:value]
+        advance
+      end
+
+      {
+        type: :command_line_call,
+        command: command,
+        arguments: args,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_buffer_var
+      token = current_token
+      line = token[:line]
+      column = token[:column]
+      name = token[:value]
+      advance
+
+      # Handle property access (e.g., b:foo.bar)
+      target = {
+        type: :buffer_variable,
+        name: name,
+        line: line,
+        column: column
+      }
+
+      # Property access (dot notation)
+      # shared with global (TODO)
+      # would almost just take an overly simple check to the = operator and call everything after b: name
+      if current_token && current_token[:type] == :operator && current_token[:value] == '.'
+        dot_token = advance
+        if current_token && (current_token[:type] == :identifier || current_token[:type] == :keyword)
+          property_token = advance
+          target = {
+            type: :property_access,
+            object: target,
+            property: property_token[:value],
+            line: dot_token[:line],
+            column: dot_token[:column]
+          }
+        else
+          add_error("Expected property name after '.' in variable")
+        end
+      end
+
+      # Indexed access (e.g., b:foo[bar])
+      while current_token && current_token[:type] == :bracket_open
+        bracket_token = advance
+        index_expr = parse_expression
+        expect(:bracket_close)
+        target = {
+          type: :indexed_access,
+          object: target,
+          index: index_expr,
+          line: bracket_token[:line],
+          column: bracket_token[:column]
+        }
+      end
+
+      # Assignment operator (= or compound)
+      operator = nil
+      if current_token && (
+          (current_token[:type] == :operator && current_token[:value] == '=') ||
+          current_token[:type] == :compound_operator)
+        operator = current_token[:value]
+        advance
+      else
+        add_error("Expected assignment operator after global variable")
+      end
+
+      # Value expression
+      value = parse_expression
+
+      {
+        type: :buffer_variable_assignment,
+        target: target,
+        operator: operator,
+        value: value,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_global_variable
+      token = current_token
+      line = token[:line]
+      column = token[:column]
+      name = token[:value]
+      advance # Skip the global variable token
+
+      # Handle property access (e.g., g:foo.bar)
+      target = {
+        type: :global_variable,
+        name: name,
+        line: line,
+        column: column
+      }
+
+      # Property access (dot notation)
+      if current_token && current_token[:type] == :operator && current_token[:value] == '.'
+        dot_token = advance
+        if current_token && (current_token[:type] == :identifier || current_token[:type] == :keyword)
+          property_token = advance
+          target = {
+            type: :property_access,
+            object: target,
+            property: property_token[:value],
+            line: dot_token[:line],
+            column: dot_token[:column]
+          }
+        else
+          add_error("Expected property name after '.' in global variable")
+        end
+      end
+
+      # Indexed access (e.g., g:foo[bar])
+      while current_token && current_token[:type] == :bracket_open
+        bracket_token = advance
+        index_expr = parse_expression
+        expect(:bracket_close)
+        target = {
+          type: :indexed_access,
+          object: target,
+          index: index_expr,
+          line: bracket_token[:line],
+          column: bracket_token[:column]
+        }
+      end
+
+      # Assignment operator (= or compound)
+      operator = nil
+      if current_token && (
+          (current_token[:type] == :operator && current_token[:value] == '=') ||
+          current_token[:type] == :compound_operator)
+        operator = current_token[:value]
+        advance
+      else
+        add_error("Expected assignment operator after global variable")
+      end
+
+      # Value expression
+      value = parse_expression
+
+      {
+        type: :global_variable_assignment,
+        target: target,
+        operator: operator,
+        value: value,
+        line: line,
+        column: column
+      }
+    end
+
     def parse_range_command
       token = advance # Skip '%'
       line = token[:line]
@@ -847,9 +1023,11 @@ module Vinter
       event = nil
       if current_token && current_token[:type] == :identifier
         event = advance[:value]
+      elsif current_token[:type] == :operator && current_token[:value] == "!"
+        advance
       else
         @errors << {
-          message: "Expected event name after 'autocmd'",
+          message: "Expected event name after 'autocmd' | #{current_token[:type]}",
           position: @position,
           line: current_token ? current_token[:line] : 0,
           column: current_token ? current_token[:column] : 0
@@ -1117,7 +1295,7 @@ module Vinter
 
       # Parse optional return type
       return_type = nil
-      if current_token && current_token[:type] == :colon
+      if current_token && current_token[:type] == :colon && current_token[:line] == line
         advance # Skip ':'
         return_type = parse_type
       end
@@ -1175,12 +1353,6 @@ module Vinter
           break
         end
 
-        # Get parameter name
-        if !current_token || current_token[:type] != :identifier
-          add_error("Expected parameter name")
-          break
-        end
-
         param_name = advance
 
         # Check for type annotation
@@ -1270,7 +1442,7 @@ module Vinter
 
       # Parse initializer if present
       initializer = nil
-      if current_token && current_token[:type] == :operator && current_token[:value] == '='
+      if current_token && (current_token[:type] == :operator && current_token[:value] == '=')
         advance # Skip '='
         initializer = parse_expression
       end
@@ -1563,7 +1735,7 @@ module Vinter
         # Special handling for map-related keywords when they appear in expressions
         if ['map', 'nmap', 'imap', 'vmap', 'xmap', 'noremap', 'nnoremap', 'inoremap', 'vnoremap', 'xnoremap', 'cnoremap', 'cmap'].include?(token[:value])
           if peek_token[:type] == :paren_open
-            parse_builtin_function_call(token[:value], line, column)
+            parse_builtin_function_call
           else
             # Treat map commands as identifiers when inside expressions
             advance
@@ -1576,7 +1748,7 @@ module Vinter
           end
         elsif token[:value] == 'type' && current_token && (current_token[:type] == :paren_open || peek_token && peek_token[:type] == :paren_open)
           # This is the type() function call
-          return parse_builtin_function_call(token[:value], line, column)
+          return parse_builtin_function_call
         elsif token[:value] == 'function'
           # Check if this is a function() call or just 'function' as property name
           if peek_token && peek_token[:type] == :paren_open
@@ -1662,6 +1834,8 @@ module Vinter
             line: line,
             column: column
           }
+        elsif token[:value] == 'command'
+          advance
         else
           @errors << {
             message: "Unexpected keyword in expression: #{token[:value]}",
@@ -1789,7 +1963,7 @@ module Vinter
       when :identifier
         # Special handling for Vim built-in functions
         if ['has', 'exists', 'empty', 'get', 'type', 'map', 'copy'].include?(token[:value])
-          expr = parse_builtin_function_call(token[:value], line, column)
+          expr = parse_builtin_function_call
         else
           advance
 
@@ -1865,7 +2039,8 @@ module Vinter
         advance
         expr = parse_expression
       when :interpolated_string
-        advance
+        token = advance
+        value = token[:value]
         expr = {
           type: :interpolated_string,
           value: token[:value],
@@ -1926,6 +2101,7 @@ module Vinter
         # Check for method call with arrow ->
         elsif current_token[:type] == :operator && current_token[:value] == '->'
           arrow_token = advance # Skip '->'
+          advance if current_token[:type] == :line_continuation
 
           # Next token should be an identifier (method name)
           if !current_token || current_token[:type] != :identifier
@@ -1990,6 +2166,12 @@ module Vinter
             else
               end_index = parse_expression
             end
+          # handles array assignment [a,b] = split(thing)
+          elsif current_token[:type] == :comma
+            while current_token[:type] == :comma
+              advance
+              parse_expression
+            end
           end
 
           expect(:bracket_close) # Skip ']'
@@ -2052,76 +2234,19 @@ module Vinter
       return expr
     end
 
-    def parse_builtin_function_call(name, line, column)
-      # Skip the function name (already consumed)
-      advance if current_token[:value] == name
-
-      # Check if there's an opening parenthesis
-      if current_token && current_token[:type] == :paren_open
-        advance # Skip '('
-
-        # Parse arguments
-        args = []
-
-        # Functions that take string expressions as code
-        special_functions = ['map', 'reduce', 'sort', 'call', 'eval', 'execute', 'exec']
-        is_special_function = special_functions.include?(name)
-
-        # Parse until closing parenthesis
-        while @position < @tokens.length && current_token && current_token[:type] != :paren_close
-          # Skip whitespace or comments
-          if current_token[:type] == :whitespace || current_token[:type] == :comment
-            advance
-            next
-          end
-
-          # Special handling for string arguments that contain code
-          if is_special_function &&
-             current_token && current_token[:type] == :string
-            string_token = parse_expression
-            args << {
-              type: :literal,
-              value: string_token[:value],
-              token_type: :string,
-              line: string_token[:line],
-              column: string_token[:column]
-            }
-          else
-            arg = parse_expression
-            args << arg if arg
-          end
-
-          if current_token && current_token[:type] == :comma
-            advance
-          elsif current_token && current_token[:type] != :paren_close
-            @errors << {
-              message: "Expected comma or closing parenthesis in #{name} function",
-              position: @position,
-              line: current_token[:line],
-              column: current_token[:column]
-            }
-            break
-          end
-        end
+    def parse_builtin_function_call
+      token = advance # Consume the `builtin_funcs` token
+      line = token[:line]
+      column = token[:column]
+      name = token[:value]
 
-        # Check for closing parenthesis
-        if current_token && current_token[:type] == :paren_close
-          advance # Skip ')'
-        else
-          @errors << {
-            message: "Expected ')' to close #{name} function call",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-        end
-      else
-        # Handle legacy Vim script where parentheses might be omitted
-        # Just parse one expression as the argument
-        args = [parse_expression]
+      # Collect arguments (if any) until the end of the line
+      args = []
+      while current_token && current_token[:type] != :comment && current_token[:value] != "\n"
+        args << current_token[:value]
+        advance
       end
 
-      # Return function call node
       {
         type: :builtin_function_call,
         name: name,
@@ -2680,42 +2805,30 @@ module Vinter
 
       args = []
 
-      # Special handling for Vim functions that take code strings as arguments
-      special_functions = ['map', 'reduce', 'sort', 'call', 'eval', 'execute', 'exec']
-      is_special_function = special_functions.include?(name)
-
       # Parse arguments until we find a closing parenthesis
       while @position < @tokens.length && current_token && current_token[:type] != :paren_close
-        # Skip comments inside parameter lists
-        if current_token && current_token[:type] == :comment
+        # Skip line continuations
+        if current_token[:type] == :line_continuation
           advance
           next
         end
-        if is_special_function && current_token && current_token[:type] == :string
-          # For functions like map(), filter(), directly add the string as an argument
-          string_token = parse_string
-          args << {
-            type: :literal,
-            value: string_token[:value],
-            token_type: :string,
-            line: string_token[:line],
-            column: string_token[:column]
-          }
-        else
-          # Parse the argument
-          arg = parse_expression
-          args << arg if arg
-        end
 
-        # Break if we hit the closing paren
+        # Parse the argument
+        arg = parse_expression
+        args << arg if arg
+
+        # Break if we hit the closing parenthesis
         if current_token && current_token[:type] == :paren_close
           break
         end
+
         # If we have a comma, advance past it and continue
         if current_token && current_token[:type] == :comma
           advance
+        elsif current_token[:type] == :line_continuation
+          advance
         # If we don't have a comma and we're not at the end, it's an error
-        elsif current_token && current_token[:type] != :paren_close && current_token[:type] != :comment
+        elsif current_token && current_token[:type] != :paren_close
           @errors << {
             message: "Expected comma or closing parenthesis after argument",
             position: @position,
@@ -2966,7 +3079,7 @@ module Vinter
           advance # Skip the '='
 
           # Get the value (number or identifier)
-          if current_token && (current_token[:type] == :number || current_token[:type] == :identifier)
+          if current_token && (current_token[:type] == :number || current_token[:type] == :identifier) || current_token[:type] == :operator
             attribute += "=#{current_token[:value]}"
             attributes << attribute
             advance
@@ -2976,6 +3089,7 @@ module Vinter
 
       # Parse the command name
       command_name = nil
+      advance if current_token[:type] == :line_continuation
       if current_token && current_token[:type] == :identifier
         command_name = current_token[:value]
         advance

data/lib/vinter.rb

@@ -5,5 +5,5 @@ require "vinter/cli"
 require "vinter/ast_printer"
 
 module Vinter
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: vinter
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Dan Bradbury
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A linter for the Vim9 script language, helping to identify issues and
   enforce best practices
@@ -31,7 +30,6 @@ homepage: https://github.com/DanBradbury/vinter
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -46,8 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A linter for leagacy + Vim9 script
 test_files: []