collie 0.1.0

data/lib/collie/formatter/options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Collie
+  module Formatter
+    # Formatting options
+    class Options
+      attr_accessor :indent_size, :align_tokens, :align_alternatives,
+                    :blank_lines_around_sections, :max_line_length
+
+      def initialize(config = {})
+        @indent_size = config[:indent_size] || 2
+        @align_tokens = config[:align_tokens] != false
+        @align_alternatives = config[:align_alternatives] != false
+        @blank_lines_around_sections = config[:blank_lines_around_sections] || 1
+        @max_line_length = config[:max_line_length] || 120
+      end
+
+      def indent(level = 1)
+        " " * (indent_size * level)
+      end
+    end
+  end
+end

data/lib/collie/linter/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+require_relative "registry"
+
+module Collie
+  module Linter
+    # Offense representation
+    class Offense
+      attr_reader :rule, :location, :message, :severity, :autocorrect
+
+      def initialize(rule:, location:, message:, severity: nil, autocorrect: nil)
+        @rule = rule
+        @location = location
+        @message = message
+        @severity = severity || rule.severity
+        @autocorrect = autocorrect
+      end
+
+      def autocorrectable?
+        !@autocorrect.nil?
+      end
+
+      def to_s
+        "#{location}: #{severity}: [#{rule.rule_name}] #{message}"
+      end
+    end
+
+    # Base class for all lint rules
+    class Base
+      class << self
+        attr_accessor :rule_name, :description, :severity, :autocorrectable
+      end
+
+      def initialize(config = {})
+        @config = config
+        @offenses = []
+      end
+
+      def check(_ast, _context = {})
+        raise NotImplementedError, "#{self.class} must implement #check"
+      end
+
+      def autocorrectable?
+        self.class.autocorrectable
+      end
+
+      protected
+
+      def add_offense(node, message:, autocorrect: nil)
+        @offenses << Offense.new(
+          rule: self.class,
+          location: node.location,
+          message: message,
+          autocorrect: autocorrect
+        )
+      end
+
+      attr_reader :offenses
+    end
+  end
+end

data/lib/collie/linter/registry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    # Registry for lint rules
+    class Registry
+      @rules = {}
+
+      class << self
+        def register(rule_class)
+          @rules[rule_class.rule_name] = rule_class if rule_class.rule_name
+        end
+
+        def all
+          @rules.values
+        end
+
+        def find(name)
+          @rules[name]
+        end
+
+        def enabled_rules(config)
+          all.select { |rule| config.rule_enabled?(rule.rule_name) }
+        end
+
+        # Auto-load all rules from rules/ directory
+        def load_rules
+          rules_path = File.join(__dir__, "rules", "*.rb")
+          Dir[rules_path].each { |f| require f }
+        end
+      end
+    end
+  end
+end

data/lib/collie/linter/rules/ambiguous_precedence.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects operators without explicit precedence declarations
+      class AmbiguousPrecedence < Base
+        self.rule_name = "AmbiguousPrecedence"
+        self.description = "Detects operators without explicit precedence declarations"
+        self.severity = :warning
+        self.autocorrectable = false
+
+        # Common operator patterns (may be quoted or unquoted)
+        OPERATOR_PATTERNS = [
+          %r{^'[+\-*/%^&|<>=!]+'$}, # Quoted single-character operators
+          %r{^"[+\-*/%^&|<>=!]+"$}, # Double-quoted single-character operators
+          %r{^[+\-*/%^&|<>=!]+$}, # Unquoted symbolic operators
+          /^'(==|!=|<=|>=|<<|>>|\|\||&&)'$/, # Quoted multi-character operators
+          /^"(==|!=|<=|>=|<<|>>|\|\||&&)"$/, # Double-quoted multi-character operators
+          /^(==|!=|<=|>=|<<|>>|\|\||&&)$/ # Unquoted multi-character operators
+        ].freeze
+
+        def check(ast, _context = {})
+          precedence_tokens = collect_precedence_tokens(ast)
+          operators = collect_operators(ast)
+
+          operators.each do |operator, locations|
+            next if precedence_tokens.include?(operator)
+
+            locations.each do |location|
+              add_offense_at(
+                location,
+                message: "Operator '#{operator}' does not have an explicit precedence declaration"
+              )
+            end
+          end
+
+          @offenses
+        end
+
+        private
+
+        def collect_precedence_tokens(ast)
+          tokens = []
+          ast.declarations.each do |decl|
+            next unless decl.is_a?(AST::PrecedenceDeclaration)
+
+            tokens.concat(decl.tokens)
+          end
+          tokens
+        end
+
+        def collect_operators(ast)
+          operators = Hash.new { |h, k| h[k] = [] }
+
+          ast.rules.each do |rule|
+            rule.alternatives.each do |alt|
+              alt.symbols.each do |symbol|
+                next unless symbol.terminal?
+                next unless looks_like_operator?(symbol.name)
+
+                operators[symbol.name] << (symbol.location || rule.location)
+              end
+            end
+          end
+
+          operators
+        end
+
+        def looks_like_operator?(name)
+          OPERATOR_PATTERNS.any? { |pattern| name.match?(pattern) }
+        end
+
+        def add_offense_at(location, message:)
+          offense = Offense.new(
+            rule: self.class,
+            location: location,
+            message: message
+          )
+          @offenses << offense
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::AmbiguousPrecedence)

data/lib/collie/linter/rules/circular_reference.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects circular references that lead to infinite recursion
+      class CircularReference < Base
+        self.rule_name = "CircularReference"
+        self.description = "Detects infinite recursion in grammar rules"
+        self.severity = :error
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          @rules_map = build_rules_map(ast)
+          @visited = Set.new
+          @rec_stack = Set.new
+
+          ast.rules.each do |rule|
+            next if @visited.include?(rule.name)
+
+            if has_cycle?(rule.name, [])
+              add_offense(rule, message: "Rule '#{rule.name}' is part of a circular reference")
+            end
+          end
+
+          @offenses
+        end
+
+        private
+
+        def build_rules_map(ast)
+          ast.rules.each_with_object({}) do |rule, map|
+            map[rule.name] = rule
+          end
+        end
+
+        def has_cycle?(rule_name, path)
+          return false if @visited.include?(rule_name)
+
+          if @rec_stack.include?(rule_name)
+            # Found a cycle - check if it's truly circular (no terminals in alternatives)
+            return true if pure_nonterminal_cycle?(rule_name)
+
+            return false
+          end
+
+          @rec_stack.add(rule_name)
+          current_path = path + [rule_name]
+
+          rule = @rules_map[rule_name]
+          # Check each alternative - only follow nonterminals
+          rule&.alternatives&.each do |alt|
+            # Skip alternatives with terminals or empty alternatives
+            next if has_terminal_or_empty?(alt)
+
+            # Only check the first symbol for cycles
+            first_symbol = alt.symbols.first
+            next unless first_symbol&.nonterminal?
+
+            return true if has_cycle?(first_symbol.name, current_path)
+          end
+
+          @rec_stack.delete(rule_name)
+          @visited.add(rule_name)
+
+          false
+        end
+
+        def has_terminal_or_empty?(alternative)
+          return true if alternative.symbols.empty?
+
+          alternative.symbols.any?(&:terminal?)
+        end
+
+        def pure_nonterminal_cycle?(rule_name)
+          rule = @rules_map[rule_name]
+          return false unless rule
+
+          # Check if all alternatives contain only nonterminals
+          rule.alternatives.all? do |alt|
+            !has_terminal_or_empty?(alt)
+          end
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::CircularReference)

data/lib/collie/linter/rules/consistent_tag_naming.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects inconsistent type tag naming
+      class ConsistentTagNaming < Base
+        self.rule_name = "ConsistentTagNaming"
+        self.description = "Ensures consistent naming style for type tags"
+        self.severity = :convention
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          tags = collect_type_tags(ast)
+          return @offenses if tags.size < 2
+
+          styles = tags.group_by { |tag, _| detect_style(tag) }
+
+          # If we have multiple styles, report inconsistency
+          add_inconsistency_offense(ast, styles) if styles.size > 1
+
+          @offenses
+        end
+
+        private
+
+        def collect_type_tags(ast)
+          tags = []
+
+          ast.declarations.each do |decl|
+            if (decl.is_a?(AST::TokenDeclaration) || decl.is_a?(AST::TypeDeclaration)) && decl.type_tag
+              tags << [decl.type_tag, decl.location]
+            end
+          end
+
+          tags
+        end
+
+        def detect_style(tag)
+          return :snake_case if tag.match?(/^[a-z][a-z0-9_]*$/)
+          return :camel_case if tag.match?(/^[a-z][a-zA-Z0-9]*$/)
+          return :pascal_case if tag.match?(/^[A-Z][a-zA-Z0-9]*$/)
+          return :upper_snake_case if tag.match?(/^[A-Z][A-Z0-9_]*$/)
+
+          :other
+        end
+
+        def add_inconsistency_offense(ast, styles)
+          style_names = styles.keys.map(&:to_s).join(", ")
+          most_common_style = styles.max_by { |_, tags| tags.size }[0]
+
+          # Add offense at the first declaration
+          first_decl = ast.declarations.first
+          location = first_decl&.location || AST::Location.new(file: "grammar", line: 1, column: 1)
+
+          offense = Offense.new(
+            rule: self.class,
+            location: location,
+            message: "Inconsistent type tag naming styles detected (#{style_names}). " \
+                     "Consider using #{most_common_style} throughout."
+          )
+          @offenses << offense
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::ConsistentTagNaming)

data/lib/collie/linter/rules/duplicate_token.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Detects tokens defined multiple times
+      class DuplicateToken < Base
+        self.rule_name = "DuplicateToken"
+        self.description = "Detects tokens defined multiple times"
+        self.severity = :error
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          seen = {}
+
+          ast.declarations.each do |decl|
+            next unless decl.is_a?(AST::TokenDeclaration)
+
+            decl.names.each do |name|
+              if seen[name]
+                add_offense(decl,
+                            message: "Token '#{name}' already defined at #{seen[name]}")
+              else
+                seen[name] = decl.location
+              end
+            end
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::DuplicateToken)

data/lib/collie/linter/rules/empty_action.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects empty action blocks
+      class EmptyAction < Base
+        self.rule_name = "EmptyAction"
+        self.description = "Detects empty action blocks { }"
+        self.severity = :convention
+        self.autocorrectable = true
+
+        def check(ast, _context = {})
+          ast.rules.each do |rule|
+            check_rule(rule)
+          end
+
+          @offenses
+        end
+
+        private
+
+        def check_rule(rule)
+          rule.alternatives.each do |alt|
+            next unless alt.action
+            next unless empty_action?(alt.action)
+
+            add_offense(
+              alt,
+              message: "Empty action block can be removed",
+              autocorrect: -> { remove_action(alt) }
+            )
+          end
+        end
+
+        def empty_action?(action)
+          # Check if action code is empty or contains only whitespace
+          return true unless action.code
+          return true if action.code.strip.empty?
+
+          false
+        end
+
+        def remove_action(alternative)
+          alternative.action = nil
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::EmptyAction)

data/lib/collie/linter/rules/factorizable_rules.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects rules with common prefixes that could be factored
+      class FactorizableRules < Base
+        self.rule_name = "FactorizableRules"
+        self.description = "Suggests factoring rules with common prefixes"
+        self.severity = :info
+        self.autocorrectable = false
+
+        MIN_PREFIX_LENGTH = 2
+
+        def check(ast, _context = {})
+          ast.rules.each do |rule|
+            check_rule(rule)
+          end
+
+          @offenses
+        end
+
+        private
+
+        def check_rule(rule)
+          return if rule.alternatives.size < 2
+
+          # Group alternatives by first symbol
+          groups = rule.alternatives.group_by { |alt| alt.symbols.first&.name }
+
+          groups.each do |first_symbol, alternatives|
+            next if alternatives.size < 2
+            next unless first_symbol # Skip epsilon alternatives
+
+            prefix_length = find_common_prefix_length(alternatives)
+            next if prefix_length < MIN_PREFIX_LENGTH
+
+            add_offense(
+              rule,
+              message: "Rule '#{rule.name}' has #{alternatives.size} alternatives with common prefix " \
+                       "(#{prefix_length} symbols). Consider factoring."
+            )
+            break # Only report once per rule
+          end
+        end
+
+        def find_common_prefix_length(alternatives)
+          return 0 if alternatives.empty?
+
+          min_length = alternatives.map { |alt| alt.symbols.size }.min
+          prefix_length = 0
+
+          (0...min_length).each do |i|
+            symbol_names = alternatives.map { |alt| alt.symbols[i].name }
+            break unless symbol_names.uniq.size == 1
+
+            prefix_length += 1
+          end
+
+          prefix_length
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::FactorizableRules)

data/lib/collie/linter/rules/left_recursion.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects left recursion in grammar rules
+      class LeftRecursion < Base
+        self.rule_name = "LeftRecursion"
+        self.description = "Detects left recursion (may cause issues with some parsers)"
+        self.severity = :warning
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          analyzer = Analyzer::Recursion.new(ast)
+          result = analyzer.analyze
+
+          result[:left_recursive].each do |rule_name|
+            rule = ast.rules.find { |r| r.name == rule_name }
+            next unless rule
+
+            add_offense(
+              rule,
+              message: "Rule '#{rule_name}' uses left recursion (consider using right recursion for LL parsers)"
+            )
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::LeftRecursion)

data/lib/collie/linter/rules/long_rule.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects rules with too many alternatives
+      class LongRule < Base
+        self.rule_name = "LongRule"
+        self.description = "Detects rules with too many alternatives"
+        self.severity = :convention
+        self.autocorrectable = false
+
+        DEFAULT_MAX_ALTERNATIVES = 10
+
+        def check(ast, _context = {})
+          max_alternatives = @config.dig("rules", "LongRule", "max_alternatives") || DEFAULT_MAX_ALTERNATIVES
+
+          ast.rules.each do |rule|
+            alternatives_count = rule.alternatives.size
+
+            next unless alternatives_count > max_alternatives
+
+            add_offense(
+              rule,
+              message: "Rule '#{rule.name}' has #{alternatives_count} alternatives " \
+                       "(max: #{max_alternatives}). Consider refactoring."
+            )
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::LongRule)

data/lib/collie/linter/rules/missing_start_symbol.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects missing %start declaration when it's ambiguous
+      class MissingStartSymbol < Base
+        self.rule_name = "MissingStartSymbol"
+        self.description = "Detects missing %start declaration with ambiguous default"
+        self.severity = :error
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          has_start = ast.declarations.any? { |decl| decl.is_a?(AST::StartDeclaration) }
+
+          # If %start is declared, no problem
+          return @offenses if has_start
+
+          # If no rules defined, it's ambiguous
+          if ast.rules.empty?
+            # Create a pseudo-location since we don't have a specific node
+            location = AST::Location.new(file: "grammar", line: 1, column: 1)
+            offense = Offense.new(
+              rule: self.class,
+              location: location,
+              message: "No %start declaration and no rules defined"
+            )
+            @offenses << offense
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::MissingStartSymbol)

data/lib/collie/linter/rules/nonterminal_naming.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Checks nonterminal naming conventions
+      class NonterminalNaming < Base
+        self.rule_name = "NonterminalNaming"
+        self.description = "Nonterminals should follow snake_case naming convention"
+        self.severity = :convention
+        self.autocorrectable = false
+
+        DEFAULT_PATTERN = /^[a-z][a-z0-9_]*$/
+
+        def check(ast, _context = {})
+          pattern = @config[:pattern] ? Regexp.new(@config[:pattern]) : DEFAULT_PATTERN
+
+          ast.rules.each do |rule|
+            next if rule.name.match?(pattern)
+
+            add_offense(rule,
+                        message: "Nonterminal '#{rule.name}' should match pattern #{pattern.inspect}")
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::NonterminalNaming)