collie 0.1.0 → 1.0.0

data/lib/collie/cli.rb

@@ -1,10 +1,23 @@
 # frozen_string_literal: true
 
 require "thor"
+require "json"
+require_relative "config"
+require_relative "formatter/signature"
+require_relative "parser/debug_serializer"
 
 module Collie
   # Command-line interface
   class CLI < Thor
+    PARSE_ERROR_RULE = Class.new do
+      class << self
+        def rule_name = "ParseError"
+        def description = "Reports grammar parse errors"
+        def severity = :error
+        def autocorrectable = false
+      end
+    end
+
     def self.exit_on_failure?
       true
     end
@@ -13,24 +26,34 @@ module Collie
 
     desc "lint FILES", "Lint grammar files"
     option :config, type: :string, desc: "Config file path"
-    option :format, type: :string, default: "text", enum: %w[text json github], desc: "Output format"
+    option :format, type: :string, default: "text", enum: %w[text json github sarif], desc: "Output format"
     option :autocorrect, type: :boolean, aliases: "-a", desc: "Auto-fix offenses"
-    option :only, type: :array, desc: "Run only specified rules"
-    option :except, type: :array, desc: "Exclude specified rules"
+    option :only, type: :string, repeatable: true, desc: "Run only specified rules"
+    option :except, type: :string, repeatable: true, desc: "Exclude specified rules"
+    option :fail_level, type: :string, default: "error", enum: %w[error warning convention info],
+                        desc: "Minimum severity that exits with failure"
+    option :stdin, type: :boolean, desc: "Read source from standard input"
+    option :stdin_filename, type: :string, default: "<stdin>", desc: "Filename to use for standard input"
     def lint(*files)
+      config = load_config
+      Linter::Registry.load_rules
+      validate_rule_filters!
+
+      return lint_stdin(config) if options[:stdin]
+
+      files = resolve_files(files, config)
       if files.empty?
-        say "No files specified", :red
+        say "No files matched", :red
         exit 1
       end
 
-      config = Config.new(options[:config])
-      Linter::Registry.load_rules
-
       all_offenses = []
+      failed = false
 
       files.each do |file|
         unless File.exist?(file)
           say "File not found: #{file}", :red
+          failed = true
           next
         end
 
@@ -41,64 +64,146 @@ module Collie
       reporter = create_reporter(options[:format])
       puts reporter.report(all_offenses)
 
-      exit 1 if all_offenses.any? { |o| o.severity == :error }
+      exit 1 if failed || fail_level_reached?(all_offenses)
     end
 
     desc "fmt FILES", "Format grammar files"
     option :check, type: :boolean, desc: "Check only, don't modify"
     option :diff, type: :boolean, desc: "Show diff"
     option :config, type: :string, desc: "Config file path"
+    option :stdin, type: :boolean, desc: "Read source from standard input"
+    option :stdin_filename, type: :string, default: "<stdin>", desc: "Filename to use for standard input"
     def fmt(*files)
+      config = load_config
+      formatter = Formatter::Formatter.new(Formatter::Options.new(config.formatter_options))
+
+      return fmt_stdin(formatter) if options[:stdin]
+
+      files = resolve_files(files, config)
       if files.empty?
-        say "No files specified", :red
+        say "No files matched", :red
         exit 1
       end
 
-      config = Config.new(options[:config])
-      formatter = Formatter::Formatter.new(Formatter::Options.new(config.formatter_options))
+      failed = false
+      changed = false
 
       files.each do |file|
         unless File.exist?(file)
           say "File not found: #{file}", :red
+          failed = true
           next
         end
 
-        format_file(file, formatter, check: options[:check], diff: options[:diff])
+        result = format_file(file, formatter, check: options[:check], diff: options[:diff])
+        failed = true if result == :failed
+        changed = true if result == :changed
       end
+
+      exit 1 if failed || changed
     end
 
     desc "rules", "List all available rules"
+    option :config, type: :string, desc: "Config file path"
     option :format, type: :string, default: "text", enum: %w[text json]
     def rules
+      config = load_config
       Linter::Registry.load_rules
 
       if options[:format] == "json"
         output = Linter::Registry.all.map do |rule|
-          {
-            name: rule.rule_name,
-            description: rule.description,
-            severity: rule.severity,
-            autocorrectable: rule.autocorrectable
-          }
+          rule_config = config.rule_config(rule.rule_name)
+          rule_metadata(rule, config, rule_config)
         end
         puts JSON.pretty_generate(output)
       else
         say "Available lint rules:", :bold
         Linter::Registry.all.each do |rule|
-          severity_color = severity_color(rule.severity)
+          rule_config = config.rule_config(rule.rule_name)
+          severity = configured_rule_severity(rule, rule_config)
+          severity_color = severity_color(severity)
           autocorrect = rule.autocorrectable ? " [autocorrectable]" : ""
-          say "  #{rule.rule_name} (#{set_color(rule.severity, severity_color)})#{autocorrect}"
+          enabled = config.rule_enabled?(rule.rule_name) ? "" : " [disabled]"
+          say "  #{rule.rule_name} (#{set_color(severity, severity_color)})#{autocorrect}#{enabled}"
           say "    #{rule.description}", :dim
         end
       end
     end
 
-    desc "init", "Generate default .collie.yml"
+    desc "explain RULE", "Explain a lint rule"
+    option :config, type: :string, desc: "Config file path"
+    option :format, type: :string, default: "text", enum: %w[text json]
+    def explain(rule_name)
+      config = load_config
+      Linter::Registry.load_rules
+
+      rule = Linter::Registry.find(rule_name)
+      unless rule
+        say "Unknown rule: #{rule_name}", :red
+        exit 1
+      end
+
+      rule_config = config.rule_config(rule.rule_name)
+      metadata = rule_metadata(rule, config, rule_config)
+
+      if options[:format] == "json"
+        puts JSON.pretty_generate(metadata)
+      else
+        say metadata[:name], :bold
+        say "  Description: #{metadata[:description]}"
+        say "  Enabled: #{metadata[:enabled]}"
+        say "  Severity: #{metadata[:severity]}"
+        say "  Autocorrectable: #{metadata[:autocorrectable]}"
+      end
+    end
+
+    desc "tokens FILE", "Print lexer tokens for debugging"
+    option :stdin, type: :boolean, desc: "Read source from standard input"
+    option :stdin_filename, type: :string, default: "<stdin>", desc: "Filename to use for standard input"
+    def tokens(file = nil)
+      source, filename = debug_source(file)
+      lexer = Parser::Lexer.new(source, filename: filename)
+      output = lexer.tokenize.map { |token| Parser::DebugSerializer.token(token) }
+
+      puts JSON.pretty_generate(output)
+    rescue Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    desc "ast FILE", "Print parsed AST for debugging"
+    option :stdin, type: :boolean, desc: "Read source from standard input"
+    option :stdin_filename, type: :string, default: "<stdin>", desc: "Filename to use for standard input"
+    def ast(file = nil)
+      source, filename = debug_source(file)
+      tree = parse_source(source, filename: filename)
+
+      puts JSON.pretty_generate(Parser::DebugSerializer.ast(tree))
+    rescue Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    map "config-schema" => :config_schema
+
+    desc "init", "Generate .collie.yml"
+    option :profile, type: :string, default: "default", enum: Config::PROFILE_NAMES,
+                     desc: "Configuration profile"
+    option :path, type: :string, default: ".collie.yml", desc: "Path to write"
     def init
-      return if File.exist?(".collie.yml") && !yes?(".collie.yml already exists. Overwrite? (y/n)")
+      path = options[:path]
+      return if File.exist?(path) && !yes?("#{path} already exists. Overwrite? (y/n)")
+
+      Config.generate_default(path, profile: options[:profile])
+      say "Generated #{path}", :green
+    rescue Error => e
+      say e.message, :red
+      exit 1
+    end
 
-      Config.generate_default
-      say "Generated .collie.yml", :green
+    desc "config-schema", "Print JSON Schema for .collie.yml"
+    def config_schema
+      puts JSON.pretty_generate(Config.schema)
     end
 
     desc "version", "Show version"
@@ -108,23 +213,41 @@ module Collie
 
     private
 
+    def load_config
+      Config.new(options[:config])
+    rescue Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    def lint_stdin(config)
+      source = $stdin.read
+      offenses = lint_source(source, filename: options[:stdin_filename], config: config)
+
+      reporter = create_reporter(options[:format])
+      puts reporter.report(offenses)
+
+      exit 1 if fail_level_reached?(offenses)
+    end
+
     def lint_file(file, config)
       source = File.read(file)
-      lexer = Parser::Lexer.new(source, filename: file)
-      tokens = lexer.tokenize
-      parser = Parser::Parser.new(tokens)
-      ast = parser.parse
+      lint_source(source, filename: file, config: config, autocorrect_path: file)
+    end
+
+    def lint_source(source, filename:, config:, autocorrect_path: nil)
+      ast = parse_source(source, filename: filename)
 
       symbol_table = build_symbol_table(ast)
-      context = { symbol_table: symbol_table, source: source, file: file }
+      Analyzer::SymbolResolver.resolve(ast, symbol_table)
+      context = { symbol_table: symbol_table, source: source, file: filename }
 
       offenses = run_lint_rules(ast, context, config)
-      apply_autocorrect(file, source, context, offenses) if options[:autocorrect]
+      apply_autocorrect(autocorrect_path, source, context, offenses) if autocorrect_path && options[:autocorrect]
 
       offenses
     rescue Error => e
-      say "Error parsing #{file}: #{e.message}", :red
-      []
+      [parse_error_offense(filename, e.message)]
     end
 
     def build_symbol_table(ast)
@@ -135,10 +258,18 @@ module Collie
           decl.names.each do |name|
             symbol_table.add_token(name, type_tag: decl.type_tag, location: decl.location)
           rescue Error
-            # Ignore duplicate declarations here, they'll be caught by lint rules
+            # Ignore duplicates while building the resolver table.
+          end
+        when AST::PrecedenceDeclaration
+          decl.tokens.each do |name|
+            symbol_table.add_token(name, location: decl.location)
+          rescue Error
+            # Ignore duplicates while building the resolver table.
           end
         when AST::ParameterizedRule
           symbol_table.add_nonterminal(decl.name, location: decl.location)
+        when AST::InlineRule
+          symbol_table.add_nonterminal(decl.rule, location: decl.location)
         end
       end
 
@@ -176,51 +307,219 @@ module Collie
       say "Auto-corrected #{autocorrectable_offenses.size} offense(s) in #{file}", :green
     end
 
+    def fmt_stdin(formatter)
+      source = $stdin.read
+      formatted = format_source(source, formatter, filename: options[:stdin_filename])
+      exit 1 unless formatted
+
+      if options[:check]
+        if source == formatted
+          say "#{options[:stdin_filename]}: OK", :green
+        else
+          say "#{options[:stdin_filename]}: needs formatting", :yellow
+          show_diff(source, formatted) if options[:diff]
+          exit 1
+        end
+      elsif options[:diff]
+        if source == formatted
+          say "#{options[:stdin_filename]}: OK", :green
+        else
+          say "#{options[:stdin_filename]}: needs formatting", :yellow
+          show_diff(source, formatted)
+          exit 1
+        end
+      else
+        puts formatted
+      end
+    end
+
     def format_file(file, formatter, check: false, diff: false)
       source = File.read(file)
-      lexer = Parser::Lexer.new(source, filename: file)
-      tokens = lexer.tokenize
-      parser = Parser::Parser.new(tokens)
-      ast = parser.parse
-
-      formatted = formatter.format(ast)
+      formatted = format_source(source, formatter, filename: file)
+      return :failed unless formatted
 
       if check
         if source == formatted
           say "#{file}: OK", :green
+          :ok
         else
           say "#{file}: needs formatting", :yellow
           show_diff(source, formatted) if diff
+          :changed
+        end
+      elsif diff
+        if source == formatted
+          say "#{file}: OK", :green
+          :ok
+        else
+          say "#{file}: needs formatting", :yellow
+          show_diff(source, formatted)
+          :changed
         end
       else
         File.write(file, formatted)
         say "Formatted #{file}", :green
+        :ok
       end
     rescue Error => e
       say "Error formatting #{file}: #{e.message}", :red
+      :failed
+    end
+
+    def format_source(source, formatter, filename:)
+      ast = parse_source(source, filename: filename)
+      formatted = formatter.format(ast)
+      formatted_ast = parse_source(formatted, filename: filename)
+      unless Formatter::Signature.build(ast) == Formatter::Signature.build(formatted_ast)
+        raise Error, "Formatted output changed grammar structure"
+      end
+
+      formatted
+    rescue Error => e
+      say "Error formatting #{filename}: #{e.message}", :red
+      nil
+    end
+
+    def parse_source(source, filename:)
+      lexer = Parser::Lexer.new(source, filename: filename)
+      tokens = lexer.tokenize
+      parser = Parser::Parser.new(tokens)
+      parser.parse
+    end
+
+    def debug_source(file)
+      return [$stdin.read, options[:stdin_filename]] if options[:stdin]
+
+      unless file
+        say "No file specified", :red
+        exit 1
+      end
+
+      unless File.exist?(file)
+        say "File not found: #{file}", :red
+        exit 1
+      end
+
+      [File.read(file), file]
+    end
+
+    def parse_error_offense(file, message)
+      Linter::Offense.new(
+        rule: PARSE_ERROR_RULE,
+        location: parse_error_location(file, message),
+        message: message,
+        severity: :error
+      )
+    end
+
+    def parse_error_location(file, message)
+      match = message.match(/:(\d+):(\d+)\b/)
+      line = match ? match[1].to_i : 1
+      column = match ? match[2].to_i : 1
+
+      AST::Location.new(file: file, line: line, column: column)
     end
 
     def filter_rules(rules)
       filtered = rules
 
-      filtered = filtered.select { |r| options[:only].include?(r.rule_name) } if options[:only]
+      only = rule_filter(:only)
+      except = rule_filter(:except)
+
+      filtered = filtered.select { |r| only.include?(r.rule_name) } if only.any?
 
-      filtered = filtered.reject { |r| options[:except].include?(r.rule_name) } if options[:except]
+      filtered = filtered.reject { |r| except.include?(r.rule_name) } if except.any?
 
       filtered
     end
 
+    def rule_filter(option_name)
+      Array(options[option_name]).flat_map { |value| value.split(",") }.map(&:strip).reject(&:empty?)
+    end
+
+    def validate_rule_filters!
+      unknown_rules = (rule_filter(:only) + rule_filter(:except)).uniq.reject do |rule_name|
+        Linter::Registry.find(rule_name)
+      end
+      return if unknown_rules.empty?
+
+      say "Unknown rule(s): #{unknown_rules.join(', ')}", :red
+      exit 1
+    end
+
+    def resolve_files(files, config)
+      targets = files.empty? ? config.included_patterns : files
+      resolved = targets.flat_map { |target| expand_target(target) }.uniq
+      return resolved unless files.empty?
+
+      resolved.reject { |file| excluded?(file, config.excluded_patterns) }
+    end
+
+    def expand_target(target)
+      if glob_pattern?(target)
+        return Dir.glob(target).select { |path| File.file?(path) }.sort
+      end
+
+      if File.directory?(target)
+        return Dir.glob(File.join(target, "**", "*.y")).select { |path| File.file?(path) }.sort
+      end
+
+      [target]
+    end
+
+    def glob_pattern?(target)
+      target.match?(/[*?\[\]{}]/)
+    end
+
+    def excluded?(file, patterns)
+      patterns.any? { |pattern| File.fnmatch?(pattern, file, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+    end
+
+    def fail_level_reached?(offenses)
+      threshold = severity_rank(options[:fail_level].to_sym)
+      offenses.any? { |offense| severity_rank(offense.severity) >= threshold }
+    end
+
+    def severity_rank(severity)
+      {
+        info: 0,
+        convention: 1,
+        warning: 2,
+        error: 3
+      }.fetch(severity, 3)
+    end
+
     def create_reporter(format)
       case format
       when "json"
         Reporter::Json.new
       when "github"
         Reporter::Github.new
+      when "sarif"
+        Reporter::Sarif.new
       else
         Reporter::Text.new
       end
     end
 
+    def configured_rule_severity(rule, rule_config)
+      configured = rule_config["severity"] || rule_config[:severity]
+      return rule.severity unless configured
+
+      normalized = configured.to_sym
+      Linter::Base::VALID_SEVERITIES.include?(normalized) ? normalized : rule.severity
+    end
+
+    def rule_metadata(rule, config, rule_config)
+      {
+        name: rule.rule_name,
+        description: rule.description,
+        enabled: config.rule_enabled?(rule.rule_name),
+        severity: configured_rule_severity(rule, rule_config),
+        autocorrectable: rule.autocorrectable
+      }
+    end
+
     def severity_color(severity)
       case severity
       when :error then :red
@@ -232,18 +531,57 @@ module Collie
     end
 
     def show_diff(original, formatted)
-      require "tempfile"
+      puts unified_diff(original, formatted)
+    end
 
-      Tempfile.create(["original", ".y"]) do |orig|
-        Tempfile.create(["formatted", ".y"]) do |fmt|
-          orig.write(original)
-          orig.flush
-          fmt.write(formatted)
-          fmt.flush
+    def unified_diff(original, formatted)
+      original_lines = original.lines
+      formatted_lines = formatted.lines
+      prefix = common_prefix_length(original_lines, formatted_lines)
+      suffix = common_suffix_length(original_lines, formatted_lines, prefix)
+
+      original_start = [prefix - 3, 0].max
+      formatted_start = [prefix - 3, 0].max
+      original_end = [original_lines.length - suffix + 3, original_lines.length].min
+      formatted_end = [formatted_lines.length - suffix + 3, formatted_lines.length].min
+
+      output = [
+        "--- original",
+        "+++ formatted",
+        "@@ -#{hunk_range(original_start, original_end)} +#{hunk_range(formatted_start, formatted_end)} @@"
+      ]
+
+      original_lines[original_start...prefix].each { |line| output << " #{line.chomp}" }
+      original_lines[prefix...(original_lines.length - suffix)].each { |line| output << "-#{line.chomp}" }
+      formatted_lines[prefix...(formatted_lines.length - suffix)].each { |line| output << "+#{line.chomp}" }
+      formatted_lines[(formatted_lines.length - suffix)...formatted_end].each { |line| output << " #{line.chomp}" }
+
+      output.join("\n")
+    end
 
-          system("diff", "-u", orig.path, fmt.path)
-        end
+    def common_prefix_length(left, right)
+      index = 0
+      index += 1 while index < left.length && index < right.length && left[index] == right[index]
+      index
+    end
+
+    def common_suffix_length(left, right, prefix_length)
+      left_index = left.length - 1
+      right_index = right.length - 1
+      count = 0
+
+      while left_index >= prefix_length && right_index >= prefix_length && left[left_index] == right[right_index]
+        count += 1
+        left_index -= 1
+        right_index -= 1
       end
+
+      count
+    end
+
+    def hunk_range(start_index, end_index)
+      length = end_index - start_index
+      length == 1 ? (start_index + 1).to_s : "#{start_index + 1},#{length}"
     end
   end
 end