vinter 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a7797098bc2eb7d9b046c4aa38d9d485fbee3016a709bda2f29ad0664b9d0de
-  data.tar.gz: 807321a96f56c648922fc2b5923d8ccdfea6f6d8c8faa5fc3b844ddd4b6840ac
+  metadata.gz: e6f99b1ca16b7bbca35229a549ceed21f3cdf9b8bc86a3fedff9b978b18717de
+  data.tar.gz: 2aa4e1df5ae4fc08e78c06cf2107c7192099326b073bf45e45a9532b3fb5d0c3
 SHA512:
-  metadata.gz: 4eb35205f6802d60d1c3070d7e8ff705d556367b4afc9c969cdfad3e560af3be646dcf13b4f7d59eaba0b0ed6cc61b130ce4cd952a529b5a4d5adfcae8339d6b
-  data.tar.gz: '09ace9f8871da9f426f7efcf77e37962b466dcafbbc053725b2ffda42d51d47bd9c98a57dcaa191d51f7dface73ee2a8885fff5f30619c8c67636ff1e5218113'
+  metadata.gz: d739b01780f6ce12654b09b701f343e850bd2eb750e705ca608f793e7e9cfef26b226927157ff595dcbb3f62ddbbd4f530439074ef9fdbc9a2cfd075dd78a3da
+  data.tar.gz: 7ec3181349383a4b9667aab046f56099d25f830a07aaa6a6135b8640a25d59e85c2191b3ffbecd263afe703f1f17a986f40f769e458bab532e70f837f9c9a029

data/README.md

@@ -2,13 +2,6 @@
 
 A Ruby gem that provides linting capabilities for Vim9 script files. This linter helps identify syntax errors and enforce best practices for for Vim9 script.
 
-## Features
-
-- Lexical analysis of Vim9 script syntax
-- Parsing of Vim9 script constructs
-- Detection of common errors and code smells
-- Command-line interface for easy integration with editors
-
 ## Installation
 
 Install the gem:
@@ -17,11 +10,22 @@ Install the gem:
 gem install vinter
 ```
 
+## Configure
+Vinter will read config files on the following priority order
+- User config (`~/.vinter`)
+- Project config (`path/to/proj/.vinter`)
+
+```yaml
+ignore_rules:
+  - missing-vim9script-declaration
+  - prefer-def-over-function
+```
+
 ## Usage
 
 ### Command Line
 
-Lint a Vim9 script file:
+Updated vim linter for legacy and vim9script
 
 ```bash
 vinter path/to/your/script.vim
@@ -88,4 +92,4 @@ issues = linter.lint(content)
 2. Create a feature branch: `git checkout -b my-new-feature`
 3. Commit your changes: `git commit -am 'Add some feature'`
 4. Push to the branch: `git push origin my-new-feature`
-5. Submit a pull request
+5. Submit a pull request

data/lib/vinter/cli.rb

@@ -6,42 +6,70 @@ module Vinter
 
     def run(args)
       if args.empty?
-        puts "Usage: vim9-lint [file.vim]"
+        puts "Usage: vinter [file.vim|directory]"
         return 1
       end
 
-      file_path = args[0]
+      target_path = args[0]
 
-      unless File.exist?(file_path)
-        puts "Error: File not found: #{file_path}"
+      unless File.exist?(target_path)
+        puts "Error: File or directory not found: #{target_path}"
         return 1
       end
 
-      content = File.read(file_path)
-      issues = @linter.lint(content)
+      vim_files = if File.directory?(target_path)
+                    find_vim_files(target_path)
+                  else
+                    [target_path]
+                  end
 
-      if issues.empty?
-        puts "No issues found in #{file_path}"
+      if vim_files.empty?
+        puts "No .vim files found in #{target_path}"
         return 0
-      else
-        puts "Found #{issues.length} issues in #{file_path}:"
+      end
+
+      total_issues = 0
+      error_count = 0
+
+      vim_files.each do |file_path|
+        content = File.read(file_path)
+        issues = @linter.lint(content)
+        total_issues += issues.length
+
+        if issues.empty?
+          puts "No issues found in #{file_path}" if vim_files.length == 1
+        else
+          puts "Found #{issues.length} issues in #{file_path}:" if vim_files.length > 1
+
+          issues.each do |issue|
+            type_str = case issue[:type]
+                       when :error then "ERROR"
+                       when :warning then "WARNING"
+                       when :rule then "RULE(#{issue[:rule]})"
+                       else "UNKNOWN"
+                       end
 
-        issues.each do |issue|
-          type_str = case issue[:type]
-                     when :error then "ERROR"
-                     when :warning then "WARNING"
-                     when :rule then "RULE(#{issue[:rule]})"
-                     else "UNKNOWN"
-                     end
+            line = issue[:line] || 1
+            column = issue[:column] || 1
 
-          line = issue[:line] || 1
-          column = issue[:column] || 1
+            puts "#{file_path}:#{line}:#{column}: #{type_str}: #{issue[:message]}"
+          end
 
-          puts "#{file_path}:#{line}:#{column}: #{type_str}: #{issue[:message]}"
+          error_count += 1 if issues.any? { |i| i[:type] == :error }
         end
+      end
 
-        return issues.any? { |i| i[:type] == :error } ? 1 : 0
+      if vim_files.length > 1
+        puts "\nProcessed #{vim_files.length} files, found #{total_issues} total issues"
       end
+
+      return error_count > 0 ? 1 : 0
+    end
+
+    private
+
+    def find_vim_files(directory)
+      Dir.glob(File.join(directory, "**", "*.vim")).sort
     end
   end
 end

data/lib/vinter/lexer.rb

@@ -2,17 +2,18 @@ module Vinter
   class Lexer
     TOKEN_TYPES = {
       # Vim9 specific keywords
-      keyword: /\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|abort|autocmd|echohl|echomsg|let|execute)\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|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)\b/,
       # Identifiers can include # and special characters
       identifier: /\b[a-zA-Z_][a-zA-Z0-9_#]*\b/,
       # Single-character operators
-      operator: /[\+\-\*\/=<>!&\|\.]/,
+      operator: /[\+\-\*\/=%<>!&\|\.]/,
       # Multi-character operators handled separately
-      number: /\b\d+(\.\d+)?\b/,
+      number: /\b(0[xX][0-9A-Fa-f]+|0[oO][0-7]+|0[bB][01]+|\d+(\.\d+)?([eE][+-]?\d+)?[smh]?)\b/,
       # Handle both single and double quoted strings
-      string: /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,
+      # string: /"(\\"|[^"])*"|'(\\'|[^'])*'/,
+      register_access: /@[a-zA-Z0-9":.%#=*+~_\/\-]/,
       # Vim9 comments use #
-      comment: /#.*/,
+      comment: /(#|").*/,
       whitespace: /\s+/,
       brace_open: /\{/,
       brace_close: /\}/,
@@ -24,9 +25,11 @@ module Vinter
       semicolon: /;/,
       comma: /,/,
       backslash: /\\/,
+      question_mark: /\?/,
+      command_separator: /\|/,
     }
 
-    CONTINUATION_OPERATORS = %w(. .. + - * / = == != > < >= <= && || ? : -> =>)
+    CONTINUATION_OPERATORS = %w(. .. + - * / = == ==# ==? != > < >= <= && || ? : -> =>)
     def initialize(input)
       @input = input
       @tokens = []
@@ -35,9 +38,178 @@ module Vinter
       @column = 1
     end
 
+    def should_parse_as_regex
+      # Look at recent tokens to determine if we're in a regex context
+      recent_tokens = @tokens.last(3)
+      
+      # Check for contexts where regex is expected
+      return true if recent_tokens.any? { |t| 
+        t && t[:type] == :keyword && ['syntax'].include?(t[:value]) 
+      }
+      
+      return true if recent_tokens.any? { |t|
+        t && t[:type] == :identifier && ['match', 'region', 'keyword'].include?(t[:value])
+      }
+      
+      # Check for comparison operators that often use regex
+      return true if recent_tokens.any? { |t|
+        t && t[:type] == :operator && ['=~', '!~', '=~#', '!~#', '=~?', '!~?'].include?(t[:value])
+      }
+      
+      false
+    end
+
+    def find_unescaped_newline(chunk)
+      i = 0
+      while i < chunk.length
+        if chunk[i] == "\n" && (i == 0 || chunk[i - 1] != '\\')
+          return i
+        end
+        i += 1
+      end
+      nil # Return nil if no unescaped newline is found
+    end
+
     def tokenize
       until @position >= @input.length
         chunk = @input[@position..-1]
+
+        # First check if the line starts with a quote (comment in Vim)
+        # Check if we're at the beginning of a line (optionally after whitespace)
+        line_start = @position == 0 || @input[@position - 1] == "\n"
+        if !line_start
+          # Check if we're after whitespace at the start of a line
+          temp_pos = @position - 1
+          while temp_pos >= 0 && @input[temp_pos] =~ /[ \t]/
+            temp_pos -= 1
+          end
+          line_start = temp_pos < 0 || @input[temp_pos] == "\n"
+        end
+        
+        # If we're at the start of a line and it begins with a quote
+        if line_start && chunk.start_with?('"')
+          # Find the end of the line
+          line_end = find_unescaped_newline(chunk) || chunk.length
+          comment_text = chunk[0...line_end]
+
+          @tokens << {
+            type: :comment,
+            value: comment_text,
+            line: @line_num,
+            column: @column
+          }
+
+          @position += comment_text.length
+          @column += comment_text.length
+          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]
+            string_value += char
+
+            if char == '\\' && !escaped
+              escaped = true
+            elsif (char == "\n" or char == quote) && !escaped
+              # Found closing quote
+              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
+            }
+
+            @column += string_value.length
+            @position += string_value.length
+            @line_num += 1 if string_value.include?("\n")
+            next
+          end
+        end
+
+        # Add special handling for command options in the tokenize method
+        if chunk.start_with?('<q-args>', '<f-args>', '<args>')
+          arg_token = chunk.match(/\A(<q-args>|<f-args>|<args>)/)[0]
+          @tokens << {
+            type: :command_arg_placeholder,
+            value: arg_token,
+            line: @line_num,
+            column: @column
+          }
+          @column += arg_token.length
+          @position += arg_token.length
+          next
+        end
+
+        # Special handling for a:000 variable arguments array
+        if chunk =~ /\Aa:0+/
+          varargs_token = chunk.match(/\Aa:0+/)[0]
+          @tokens << {
+            type: :arg_variable,
+            value: varargs_token,
+            line: @line_num,
+            column: @column
+          }
+          @column += varargs_token.length
+          @position += varargs_token.length
+          next
+        end
+
+        # Also add special handling for 'silent!' keyword
+        # Add this after the keyword check in tokenize method
+        if chunk.start_with?('silent!')
+          @tokens << {
+            type: :silent_bang,
+            value: 'silent!',
+            line: @line_num,
+            column: @column
+          }
+          @column += 7
+          @position += 7
+          next
+        end
+
+        # Check for keywords first, before other token types
+        if match = chunk.match(/\A\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|abort|autocmd|echoerr|echohl|echomsg|let|unlet|execute|setlocal|syntax|highlight|sleep|source)\b/)
+          @tokens << {
+            type: :keyword,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+
+        # Handle Vim scoped option variables with &l: or &g: prefix
+        if match = chunk.match(/\A&[lg]:[a-zA-Z_][a-zA-Z0-9_]*/)
+          @tokens << {
+            type: :scoped_option_variable,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
         
         # Handle Vim option variables with & prefix
         if match = chunk.match(/\A&[a-zA-Z_][a-zA-Z0-9_]*/)
@@ -51,7 +223,7 @@ module Vinter
           @position += match[0].length
           next
         end
-        
+
         # Handle Vim special variables with v: prefix
         if match = chunk.match(/\Av:[a-zA-Z_][a-zA-Z0-9_]*/)
           @tokens << {
@@ -64,7 +236,7 @@ module Vinter
           @position += match[0].length
           next
         end
-        
+
         # Handle script-local identifiers with s: prefix
         if match = chunk.match(/\As:[a-zA-Z_][a-zA-Z0-9_]*/)
           @tokens << {
@@ -77,7 +249,47 @@ module Vinter
           @position += match[0].length
           next
         end
-        
+
+        # Handle buffer-local identifiers with b: prefix
+        if match = chunk.match(/\Ab:[a-zA-Z_][a-zA-Z0-9_]*/)
+          @tokens << {
+            type: :buffer_local,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+
+        # Handle window-local identifiers with w: prefix
+        if match = chunk.match(/\Aw:[a-zA-Z_][a-zA-Z0-9_]*/)
+          @tokens << {
+            type: :window_local,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+
+        # Handle tab-local identifiers with t: prefix
+        if match = chunk.match(/\At:[a-zA-Z_][a-zA-Z0-9_]*/)
+          @tokens << {
+            type: :tab_local,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+
+
         # Handle global variables with g: prefix
         if match = chunk.match(/\Ag:[a-zA-Z_][a-zA-Z0-9_]*/)
           @tokens << {
@@ -90,9 +302,9 @@ module Vinter
           @position += match[0].length
           next
         end
-        
+
         # Handle argument variables with a: prefix
-        if match = chunk.match(/\Aa:[a-zA-Z_][a-zA-Z0-9_]*/)
+        if match = chunk.match(/\Aa:[a-zA-Z_][a-zA-Z0-9_]*/) || match = chunk.match(/\Aa:[A-Z0-9]/)
           @tokens << {
             type: :arg_variable,
             value: match[0],
@@ -103,11 +315,11 @@ module Vinter
           @position += match[0].length
           next
         end
-        
-        # Handle compound assignment operators
-        if match = chunk.match(/\A(\+=|-=|\*=|\/=|\.\.=)/)
+
+        # Handle argument variables with a: prefix
+        if match = chunk.match(/\Al:[a-zA-Z_][a-zA-Z0-9_]*/)
           @tokens << {
-            type: :compound_operator,
+            type: :local_variable,
             value: match[0],
             line: @line_num,
             column: @column
@@ -117,10 +329,23 @@ module Vinter
           next
         end
 
-        # Handle multi-character operators explicitly
-        if match = chunk.match(/\A(==|!=|=>|->|\.\.|\|\||&&)/)
+        # Add support for standalone namespace prefixes (like g:)
+        if match = chunk.match(/\A([sgbwtal]):/)
           @tokens << {
-            type: :operator,
+            type: :namespace_prefix,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+
+        # Handle compound assignment operators
+        if match = chunk.match(/\A(\+=|-=|\*=|\/=|\.\.=|\.=)/)
+          @tokens << {
+            type: :compound_operator,
             value: match[0],
             line: @line_num,
             column: @column
@@ -143,6 +368,98 @@ module Vinter
           next
         end
 
+        # Handle multi-character operators explicitly
+        if match = chunk.match(/\A(=~#|=~\?|=~|!~#|!~\?|!~|==#|==\?|==|!=#|!=\?|!=|=>\?|=>|>=#|>=\?|>=|<=#|<=\?|<=|->#|->\?|->|\.\.|\|\||&&)/)
+          @tokens << {
+            type: :operator,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+
+        # Handle regex patterns /pattern/ - only in specific contexts
+        if chunk.start_with?('/') && should_parse_as_regex
+          i = 1
+          regex_value = '/'
+          
+          # Keep going until we find the closing slash
+          while i < chunk.length
+            char = chunk[i]
+            regex_value += char
+            
+            if char == '/' && (i == 1 || chunk[i-1] != '\\')
+              # Found closing slash
+              i += 1
+              break
+            end
+            
+            i += 1
+          end
+          
+          # Add the regex token if we found a closing slash
+          if regex_value.end_with?('/')
+            @tokens << {
+              type: :regex,
+              value: regex_value,
+              line: @line_num,
+              column: @column
+            }
+            @column += regex_value.length
+            @position += regex_value.length
+            next
+          end
+        end
+
+        # Handle hex colors like #33FF33
+        if match = chunk.match(/\A#[0-9A-Fa-f]{6}/)
+          @tokens << {
+            type: :hex_color,
+            value: match[0],
+            line: @line_num,
+            column: @column
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+
+        # Handle register access (@a, @", etc.)
+        if chunk =~ /\A@[a-zA-Z0-9":.%#=*+~_\/\-]/
+          register_token = chunk.match(/\A@[a-zA-Z0-9":.%#=*+~_\/\-]/)[0]
+          @tokens << {
+            type: :register_access,
+            value: register_token,
+            line: @line_num,
+            column: @column
+          }
+          @column += register_token.length
+          @position += register_token.length
+          next
+        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\-_]+>/)
+          # Extract the special key notation
+          match = chunk.match(/\A(<[^>]+>)/)
+          if match
+            special_key = match[1]
+            @tokens << {
+              type: :special_key,
+              value: special_key,
+              line: @line_num,
+              column: @column
+            }
+            @position += special_key.length
+            @column += special_key.length
+            next
+          end
+        end
+
         # Skip whitespace but track position
         if match = chunk.match(/\A(\s+)/)
           whitespace = match[0]
@@ -161,13 +478,35 @@ module Vinter
         # Handle backslash for line continuation
         if chunk.start_with?('\\')
           @tokens << {
-            type: :backslash,
+            type: :line_continuation,
             value: '\\',
             line: @line_num,
             column: @column
           }
           @column += 1
           @position += 1
+
+          # If followed by a newline, advance to next line
+          if @position < @input.length && @input[@position] == "\n"
+            @line_num += 1
+            @column = 1
+            @position += 1
+          end
+
+          next
+        end
+
+        # Check for special case where 'function' is followed by '('
+        # which likely means it's used as a built-in function
+        if chunk =~ /\Afunction\s*\(/
+          @tokens << {
+            type: :identifier,  # Treat as identifier, not keyword
+            value: 'function',
+            line: @line_num,
+            column: @column
+          }
+          @column += 'function'.length
+          @position += 'function'.length
           next
         end
 

data/lib/vinter/linter.rb

@@ -1,7 +1,12 @@
+require "yaml"
+
 module Vinter
   class Linter
-    def initialize
+    def initialize(config_path: nil)
       @rules = []
+      @ignored_rules = []
+      @config_path = config_path || find_config_path
+      load_config
       register_default_rules
     end
 
@@ -94,7 +99,7 @@ module Vinter
       lexer = Lexer.new(content)
       tokens = lexer.tokenize
 
-      parser = Parser.new(tokens)
+      parser = Parser.new(tokens, content)
       result = parser.parse
 
       issues = []
@@ -121,8 +126,9 @@ module Vinter
         }
       end
 
-      # Apply rules
+      # Apply rules, ignoring those specified in config
       @rules.each do |rule|
+        next if @ignored_rules.include?(rule.id)
         rule_issues = rule.apply(result[:ast])
         issues.concat(rule_issues.map { |i| {
           type: :rule,
@@ -135,6 +141,25 @@ module Vinter
 
       issues
     end
+
+    private
+
+    def find_config_path
+      # check for project level config
+      project_config = Dir.glob(".vinter{.yaml,.yml,}").first
+      project_config if project_config
+
+      # check for user-level config
+      user_config = File.expand_path("~/.vinter")
+      user_config if File.exist?(user_config)
+    end
+
+    def load_config
+      return unless @config_path && File.exist?(@config_path)
+
+      config = YAML.load_file(@config_path)
+      @ignored_rules = config["ignore_rules"] || []
+    end
   end
 
   class Rule