collie 0.1.0

data/lib/collie/ast.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Collie
+  module AST
+    # Location information for source code elements
+    class Location
+      attr_accessor :file, :line, :column, :length
+
+      def initialize(file:, line:, column:, length: 0)
+        @file = file
+        @line = line
+        @column = column
+        @length = length
+      end
+
+      def to_s
+        "#{file}:#{line}:#{column}"
+      end
+    end
+
+    # Root node representing the entire grammar file
+    class GrammarFile
+      attr_accessor :prologue, :declarations, :rules, :epilogue, :location
+
+      def initialize(prologue: nil, declarations: [], rules: [], epilogue: nil, location: nil)
+        @prologue = prologue
+        @declarations = declarations
+        @rules = rules
+        @epilogue = epilogue
+        @location = location
+      end
+    end
+
+    # Token declaration node (%token)
+    class TokenDeclaration
+      attr_accessor :names, :type_tag, :location
+
+      def initialize(names:, type_tag: nil, location: nil)
+        @names = names
+        @type_tag = type_tag
+        @location = location
+      end
+    end
+
+    # Type declaration node (%type)
+    class TypeDeclaration
+      attr_accessor :type_tag, :names, :location
+
+      def initialize(type_tag:, names:, location: nil)
+        @type_tag = type_tag
+        @names = names
+        @location = location
+      end
+    end
+
+    # Precedence declaration node (%left, %right, %nonassoc)
+    class PrecedenceDeclaration
+      attr_accessor :associativity, :tokens, :location
+
+      def initialize(associativity:, tokens:, location: nil)
+        @associativity = associativity # :left, :right, :nonassoc
+        @tokens = tokens
+        @location = location
+      end
+    end
+
+    # Start symbol declaration node (%start)
+    class StartDeclaration
+      attr_accessor :symbol, :location
+
+      def initialize(symbol:, location: nil)
+        @symbol = symbol
+        @location = location
+      end
+    end
+
+    # Union declaration node (%union)
+    class UnionDeclaration
+      attr_accessor :body, :location
+
+      def initialize(body:, location: nil)
+        @body = body
+        @location = location
+      end
+    end
+
+    # Grammar rule node
+    class Rule
+      attr_accessor :name, :alternatives, :location
+
+      def initialize(name:, alternatives: [], location: nil)
+        @name = name
+        @alternatives = alternatives
+        @location = location
+      end
+    end
+
+    # Alternative production for a rule
+    class Alternative
+      attr_accessor :symbols, :action, :prec, :location
+
+      def initialize(symbols: [], action: nil, prec: nil, location: nil)
+        @symbols = symbols
+        @action = action
+        @prec = prec
+        @location = location
+      end
+    end
+
+    # Symbol reference (terminal or nonterminal)
+    class Symbol
+      attr_accessor :name, :kind, :alias_name, :arguments, :location
+
+      def initialize(name:, kind:, alias_name: nil, arguments: nil, location: nil)
+        @name = name
+        @kind = kind # :terminal, :nonterminal
+        @alias_name = alias_name
+        @arguments = arguments # For parameterized rule calls like list(expr)
+        @location = location
+      end
+
+      def terminal?
+        kind == :terminal
+      end
+
+      def nonterminal?
+        kind == :nonterminal
+      end
+    end
+
+    # Action code block
+    class Action
+      attr_accessor :code, :location
+
+      def initialize(code:, location: nil)
+        @code = code
+        @location = location
+      end
+    end
+
+    # Lrama extension: Parameterized rule
+    class ParameterizedRule
+      attr_accessor :name, :parameters, :alternatives, :location
+
+      def initialize(name:, parameters:, alternatives:, location: nil)
+        @name = name
+        @parameters = parameters
+        @alternatives = alternatives
+        @location = location
+      end
+    end
+
+    # Lrama extension: Inline rule
+    class InlineRule
+      attr_accessor :rule, :location
+
+      def initialize(rule:, location: nil)
+        @rule = rule
+        @location = location
+      end
+    end
+
+    # Prologue section (code before first %%)
+    class Prologue
+      attr_accessor :code, :location
+
+      def initialize(code:, location: nil)
+        @code = code
+        @location = location
+      end
+    end
+
+    # Epilogue section (code after second %%)
+    class Epilogue
+      attr_accessor :code, :location
+
+      def initialize(code:, location: nil)
+        @code = code
+        @location = location
+      end
+    end
+  end
+end

data/lib/collie/cli.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Collie
+  # Command-line interface
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    map %w[--version -v] => :version
+
+    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 :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"
+    def lint(*files)
+      if files.empty?
+        say "No files specified", :red
+        exit 1
+      end
+
+      config = Config.new(options[:config])
+      Linter::Registry.load_rules
+
+      all_offenses = []
+
+      files.each do |file|
+        unless File.exist?(file)
+          say "File not found: #{file}", :red
+          next
+        end
+
+        offenses = lint_file(file, config)
+        all_offenses.concat(offenses)
+      end
+
+      reporter = create_reporter(options[:format])
+      puts reporter.report(all_offenses)
+
+      exit 1 if all_offenses.any? { |o| o.severity == :error }
+    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"
+    def fmt(*files)
+      if files.empty?
+        say "No files specified", :red
+        exit 1
+      end
+
+      config = Config.new(options[:config])
+      formatter = Formatter::Formatter.new(Formatter::Options.new(config.formatter_options))
+
+      files.each do |file|
+        unless File.exist?(file)
+          say "File not found: #{file}", :red
+          next
+        end
+
+        format_file(file, formatter, check: options[:check], diff: options[:diff])
+      end
+    end
+
+    desc "rules", "List all available rules"
+    option :format, type: :string, default: "text", enum: %w[text json]
+    def rules
+      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
+          }
+        end
+        puts JSON.pretty_generate(output)
+      else
+        say "Available lint rules:", :bold
+        Linter::Registry.all.each do |rule|
+          severity_color = severity_color(rule.severity)
+          autocorrect = rule.autocorrectable ? " [autocorrectable]" : ""
+          say "  #{rule.rule_name} (#{set_color(rule.severity, severity_color)})#{autocorrect}"
+          say "    #{rule.description}", :dim
+        end
+      end
+    end
+
+    desc "init", "Generate default .collie.yml"
+    def init
+      return if File.exist?(".collie.yml") && !yes?(".collie.yml already exists. Overwrite? (y/n)")
+
+      Config.generate_default
+      say "Generated .collie.yml", :green
+    end
+
+    desc "version", "Show version"
+    def version
+      puts "Collie version #{Collie::VERSION}"
+    end
+
+    private
+
+    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
+
+      symbol_table = build_symbol_table(ast)
+      context = { symbol_table: symbol_table, source: source, file: file }
+
+      offenses = run_lint_rules(ast, context, config)
+      apply_autocorrect(file, source, context, offenses) if options[:autocorrect]
+
+      offenses
+    rescue Error => e
+      say "Error parsing #{file}: #{e.message}", :red
+      []
+    end
+
+    def build_symbol_table(ast)
+      symbol_table = Analyzer::SymbolTable.new
+      ast.declarations.each do |decl|
+        case decl
+        when AST::TokenDeclaration
+          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
+          end
+        when AST::ParameterizedRule
+          symbol_table.add_nonterminal(decl.name, location: decl.location)
+        end
+      end
+
+      ast.rules.each do |rule|
+        symbol_table.add_nonterminal(rule.name, location: rule.location)
+      end
+
+      symbol_table
+    end
+
+    def run_lint_rules(ast, context, config)
+      enabled_rules = Linter::Registry.enabled_rules(config)
+      enabled_rules = filter_rules(enabled_rules) if options[:only] || options[:except]
+
+      offenses = []
+      enabled_rules.each do |rule_class|
+        rule = rule_class.new(config.rule_config(rule_class.rule_name))
+        offenses.concat(rule.check(ast, context))
+      end
+
+      offenses
+    end
+
+    def apply_autocorrect(file, source, context, offenses)
+      autocorrectable_offenses = offenses.select(&:autocorrectable?)
+      return if autocorrectable_offenses.empty?
+
+      autocorrectable_offenses.each do |offense|
+        offense.autocorrect&.call
+      end
+
+      return unless context[:source] != source
+
+      File.write(file, context[:source])
+      say "Auto-corrected #{autocorrectable_offenses.size} offense(s) in #{file}", :green
+    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)
+
+      if check
+        if source == formatted
+          say "#{file}: OK", :green
+        else
+          say "#{file}: needs formatting", :yellow
+          show_diff(source, formatted) if diff
+        end
+      else
+        File.write(file, formatted)
+        say "Formatted #{file}", :green
+      end
+    rescue Error => e
+      say "Error formatting #{file}: #{e.message}", :red
+    end
+
+    def filter_rules(rules)
+      filtered = rules
+
+      filtered = filtered.select { |r| options[:only].include?(r.rule_name) } if options[:only]
+
+      filtered = filtered.reject { |r| options[:except].include?(r.rule_name) } if options[:except]
+
+      filtered
+    end
+
+    def create_reporter(format)
+      case format
+      when "json"
+        Reporter::Json.new
+      when "github"
+        Reporter::Github.new
+      else
+        Reporter::Text.new
+      end
+    end
+
+    def severity_color(severity)
+      case severity
+      when :error then :red
+      when :warning then :yellow
+      when :convention then :blue
+      when :info then :cyan
+      else :white
+      end
+    end
+
+    def show_diff(original, formatted)
+      require "tempfile"
+
+      Tempfile.create(["original", ".y"]) do |orig|
+        Tempfile.create(["formatted", ".y"]) do |fmt|
+          orig.write(original)
+          orig.flush
+          fmt.write(formatted)
+          fmt.flush
+
+          system("diff", "-u", orig.path, fmt.path)
+        end
+      end
+    end
+  end
+end

data/lib/collie/config.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Collie
+  # Configuration management
+  class Config
+    DEFAULT_CONFIG = {
+      "rules" => {},
+      "formatter" => {
+        "indent_size" => 2,
+        "align_tokens" => true,
+        "align_alternatives" => true,
+        "blank_lines_around_sections" => 1,
+        "max_line_length" => 120
+      },
+      "include" => ["**/*.y"],
+      "exclude" => ["vendor/**/*", "tmp/**/*"]
+    }.freeze
+
+    attr_reader :config
+
+    def initialize(config_path = nil)
+      @config = load_config(config_path)
+    end
+
+    def rule_enabled?(rule_name)
+      rule_config = @config.dig("rules", rule_name)
+      return true if rule_config.nil? # Enabled by default
+
+      rule_config.is_a?(Hash) ? rule_config.fetch("enabled", true) : rule_config
+    end
+
+    def rule_config(rule_name)
+      @config.dig("rules", rule_name) || {}
+    end
+
+    def formatter_options
+      @config["formatter"] || DEFAULT_CONFIG["formatter"]
+    end
+
+    def included_patterns
+      @config["include"] || DEFAULT_CONFIG["include"]
+    end
+
+    def excluded_patterns
+      @config["exclude"] || DEFAULT_CONFIG["exclude"]
+    end
+
+    def self.default
+      new
+    end
+
+    def self.generate_default(path = ".collie.yml")
+      File.write(path, DEFAULT_CONFIG.to_yaml)
+    end
+
+    private
+
+    def load_config(config_path)
+      config = DEFAULT_CONFIG.dup
+
+      if config_path && File.exist?(config_path)
+        user_config = YAML.load_file(config_path)
+        config = deep_merge(config, user_config)
+
+        # Handle inheritance
+        if user_config["inherit_from"]
+          parent_path = File.expand_path(user_config["inherit_from"], File.dirname(config_path))
+          parent_config = YAML.load_file(parent_path) if File.exist?(parent_path)
+          config = deep_merge(parent_config, config) if parent_config
+        end
+      elsif File.exist?(".collie.yml")
+        user_config = YAML.load_file(".collie.yml")
+        config = deep_merge(config, user_config)
+      end
+
+      config
+    end
+
+    def deep_merge(hash1, hash2)
+      hash1.merge(hash2) do |_key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
+  end
+end

data/lib/collie/formatter/formatter.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Collie
+  module Formatter
+    # Formatter for .y grammar files
+    class Formatter
+      def initialize(options = Options.new)
+        @options = options
+      end
+
+      def format(ast)
+        output = []
+
+        # Prologue
+        output << format_prologue(ast.prologue) if ast.prologue
+
+        # Declarations
+        output << format_declarations(ast.declarations) unless ast.declarations.empty?
+
+        # Section separator
+        output << ""
+        output << "%%"
+        output << ""
+
+        # Rules
+        output << format_rules(ast.rules)
+
+        # Epilogue
+        if ast.epilogue
+          output << ""
+          output << "%%"
+          output << ""
+          output << ast.epilogue.code
+        end
+
+        output.join("\n")
+      end
+
+      private
+
+      def format_prologue(prologue)
+        ["%{", prologue.code, "%}"].join("\n")
+      end
+
+      def format_declarations(declarations)
+        grouped = declarations.group_by(&:class)
+        output = []
+
+        # Format token declarations
+        if grouped[AST::TokenDeclaration]
+          output << format_token_declarations(grouped[AST::TokenDeclaration])
+          output << ""
+        end
+
+        # Format type declarations
+        if grouped[AST::TypeDeclaration]
+          output << format_type_declarations(grouped[AST::TypeDeclaration])
+          output << ""
+        end
+
+        # Format precedence declarations
+        if grouped[AST::PrecedenceDeclaration]
+          output << format_precedence_declarations(grouped[AST::PrecedenceDeclaration])
+          output << ""
+        end
+
+        # Format start declaration
+        if grouped[AST::StartDeclaration]
+          start_decl = grouped[AST::StartDeclaration].first
+          output << "%start #{start_decl.symbol}"
+          output << ""
+        end
+
+        # Format %rule declarations (Lrama extension)
+        if grouped[AST::ParameterizedRule]
+          output << format_parameterized_rule_declarations(grouped[AST::ParameterizedRule])
+          output << ""
+        end
+
+        # Format %inline declarations (Lrama extension)
+        if grouped[AST::InlineRule]
+          output << format_inline_rule_declarations(grouped[AST::InlineRule])
+          output << ""
+        end
+
+        output.join("\n")
+      end
+
+      def format_token_declarations(declarations)
+        if @options.align_tokens
+          format_aligned_tokens(declarations)
+        else
+          declarations.map { |decl| format_token_declaration(decl) }.join("\n")
+        end
+      end
+
+      def format_aligned_tokens(declarations)
+        max_tag_length = declarations.map { |d| d.type_tag ? d.type_tag.length + 2 : 0 }.max || 0
+        declarations.map do |decl|
+          tag = decl.type_tag ? "<#{decl.type_tag}>" : ""
+          "%token #{tag.ljust(max_tag_length)} #{decl.names.join(' ')}"
+        end.join("\n")
+      end
+
+      def format_token_declaration(decl)
+        tag = decl.type_tag ? " <#{decl.type_tag}>" : ""
+        "%token#{tag} #{decl.names.join(' ')}"
+      end
+
+      def format_type_declarations(declarations)
+        declarations.map do |decl|
+          tag = decl.type_tag ? " <#{decl.type_tag}>" : ""
+          "%type#{tag} #{decl.names.join(' ')}"
+        end.join("\n")
+      end
+
+      def format_precedence_declarations(declarations)
+        directive_names = {
+          left: "%left",
+          right: "%right",
+          nonassoc: "%nonassoc"
+        }
+
+        max_directive_length = directive_names.values.map(&:length).max
+
+        declarations.map do |decl|
+          directive = directive_names[decl.associativity]
+          if @options.align_tokens
+            "#{directive.ljust(max_directive_length)} #{decl.tokens.join(' ')}"
+          else
+            "#{directive} #{decl.tokens.join(' ')}"
+          end
+        end.join("\n")
+      end
+
+      def format_parameterized_rule_declarations(declarations)
+        declarations.map do |decl|
+          params = "(#{decl.parameters.join(', ')})"
+          alternatives = decl.alternatives.map { |alt| format_alternative(alt) }.join(" | ")
+          "%rule #{decl.name}#{params}: #{alternatives} ;"
+        end.join("\n")
+      end
+
+      def format_inline_rule_declarations(declarations)
+        declarations.map do |decl|
+          "%inline #{decl.rule}"
+        end.join("\n")
+      end
+
+      def format_rules(rules)
+        rules.map { |rule| format_rule(rule) }.join("\n\n")
+      end
+
+      def format_rule(rule)
+        # Handle parameterized rules: rule_name(X, Y)
+        rule_header = rule.name.to_s
+        if rule.is_a?(AST::ParameterizedRule) && rule.parameters && !rule.parameters.empty?
+          rule_header += "(#{rule.parameters.join(', ')})"
+        end
+
+        output = [rule_header]
+
+        rule.alternatives.each_with_index do |alt, index|
+          prefix = index.zero? ? "    :" : "    |"
+          output << "#{prefix} #{format_alternative(alt)}"
+        end
+
+        output << "    ;"
+        output.join("\n")
+      end
+
+      def format_alternative(alt)
+        symbols_str = alt.symbols.map { |sym| format_symbol(sym) }.join(" ")
+        action_str = alt.action ? " #{alt.action.code}" : ""
+        prec_str = alt.prec ? " %prec #{alt.prec}" : ""
+
+        "#{symbols_str}#{prec_str}#{action_str}"
+      end
+
+      def format_symbol(symbol)
+        result = symbol.name
+
+        # Add named reference: symbol[name]
+        result += "[#{symbol.alias_name}]" if symbol.alias_name
+
+        # Add parameterized call arguments: symbol(arg1, arg2)
+        if symbol.arguments && !symbol.arguments.empty?
+          args_str = symbol.arguments.map { |arg| format_symbol(arg) }.join(", ")
+          result += "(#{args_str})"
+        end
+
+        result
+      end
+    end
+  end
+end