collie 0.1.0

data/lib/collie/parser/parser.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+
+module Collie
+  module Parser
+    # Parser for .y grammar files
+    class Parser
+      def initialize(tokens)
+        @tokens = tokens
+        @pos = 0
+      end
+
+      def parse
+        prologue = parse_prologue
+        declarations = parse_declarations
+        expect(:SECTION_SEPARATOR)
+        rules = parse_rules
+        epilogue = parse_epilogue
+
+        AST::GrammarFile.new(
+          prologue: prologue,
+          declarations: declarations,
+          rules: rules,
+          epilogue: epilogue,
+          location: current_token.location
+        )
+      end
+
+      private
+
+      def current_token
+        @tokens[@pos] || @tokens.last
+      end
+
+      def peek_token(offset = 1)
+        @tokens[@pos + offset] || @tokens.last
+      end
+
+      def advance
+        @pos += 1 unless @pos >= @tokens.length
+      end
+
+      def expect(type)
+        unless current_token.type == type
+          raise Error, "Expected #{type} but got #{current_token.type} at #{current_token.location}"
+        end
+
+        token = current_token
+        advance
+        token
+      end
+
+      def match?(type)
+        current_token.type == type
+      end
+
+      def parse_prologue
+        return nil unless match?(:PROLOGUE_START)
+
+        token = current_token
+        advance
+        AST::Prologue.new(code: token.value, location: token.location)
+      end
+
+      def parse_declarations
+        declarations = []
+
+        while !match?(:SECTION_SEPARATOR) && !match?(:EOF)
+          case current_token.type
+          when :TOKEN
+            declarations << parse_token_declaration
+          when :TYPE
+            declarations << parse_type_declaration
+          when :LEFT, :RIGHT, :NONASSOC
+            declarations << parse_precedence_declaration
+          when :START
+            declarations << parse_start_declaration
+          when :UNION
+            declarations << parse_union_declaration
+          when :RULE
+            # %rule for Lrama extensions (handled inline)
+            advance
+            declarations << parse_lrama_rule_declaration
+          when :INLINE
+            # %inline for Lrama extensions
+            advance
+            declarations << parse_inline_declaration
+          else
+            advance # Skip unknown declarations for now
+          end
+        end
+
+        declarations
+      end
+
+      def parse_lrama_rule_declaration
+        # %rule followed by rule definition
+        # This is similar to parse_rule but in declaration section
+        name_token = expect(:IDENTIFIER)
+
+        parameters = []
+        if match?(:LPAREN)
+          advance
+          parameters = parse_parameter_list
+          expect(:RPAREN)
+        end
+
+        expect(:COLON)
+
+        alternatives = []
+        alternatives << parse_alternative
+
+        while match?(:PIPE)
+          advance
+          alternatives << parse_alternative
+        end
+
+        expect(:SEMICOLON) if match?(:SEMICOLON)
+
+        AST::ParameterizedRule.new(
+          name: name_token.value,
+          parameters: parameters,
+          alternatives: alternatives,
+          location: name_token.location
+        )
+      end
+
+      def parse_inline_declaration
+        # %inline followed by rule name
+        rule_name = expect(:IDENTIFIER).value
+
+        AST::InlineRule.new(
+          rule: rule_name,
+          location: current_token.location
+        )
+      end
+
+      def parse_token_declaration
+        token = expect(:TOKEN)
+        type_tag = nil
+        names = []
+
+        if match?(:TYPE_TAG)
+          type_tag = current_token.value
+          advance
+        end
+
+        while match?(:IDENTIFIER) || match?(:STRING) || match?(:CHAR)
+          names << current_token.value
+          advance
+        end
+
+        AST::TokenDeclaration.new(
+          names: names,
+          type_tag: type_tag,
+          location: token.location
+        )
+      end
+
+      def parse_type_declaration
+        token = expect(:TYPE)
+        type_tag = nil
+
+        if match?(:TYPE_TAG)
+          type_tag = current_token.value
+          advance
+        end
+
+        names = []
+        while match?(:IDENTIFIER)
+          names << current_token.value
+          advance
+        end
+
+        AST::TypeDeclaration.new(
+          type_tag: type_tag,
+          names: names,
+          location: token.location
+        )
+      end
+
+      def parse_precedence_declaration
+        token = current_token
+        associativity = case token.type
+                        when :LEFT then :left
+                        when :RIGHT then :right
+                        when :NONASSOC then :nonassoc
+                        end
+        advance
+
+        tokens = []
+        while match?(:IDENTIFIER) || match?(:STRING) || match?(:CHAR)
+          tokens << current_token.value
+          advance
+        end
+
+        AST::PrecedenceDeclaration.new(
+          associativity: associativity,
+          tokens: tokens,
+          location: token.location
+        )
+      end
+
+      def parse_start_declaration
+        token = expect(:START)
+        symbol = expect(:IDENTIFIER).value
+
+        AST::StartDeclaration.new(
+          symbol: symbol,
+          location: token.location
+        )
+      end
+
+      def parse_union_declaration
+        token = expect(:UNION)
+        body = +""
+
+        if match?(:ACTION)
+          body = current_token.value
+          advance
+        end
+
+        AST::UnionDeclaration.new(
+          body: body,
+          location: token.location
+        )
+      end
+
+      def parse_rules
+        rules = []
+
+        until match?(:SECTION_SEPARATOR) || match?(:EOF)
+          if match?(:IDENTIFIER)
+            rules << parse_rule
+          else
+            advance
+          end
+        end
+
+        rules
+      end
+
+      def parse_rule
+        name_token = expect(:IDENTIFIER)
+
+        # Check for parameterized rule: rule_name(param1, param2)
+        parameters = []
+        if match?(:LPAREN)
+          advance
+          parameters = parse_parameter_list
+          expect(:RPAREN)
+        end
+
+        expect(:COLON)
+
+        alternatives = []
+        alternatives << parse_alternative
+
+        while match?(:PIPE)
+          advance
+          alternatives << parse_alternative
+        end
+
+        expect(:SEMICOLON) if match?(:SEMICOLON)
+
+        # Return ParameterizedRule if parameters exist
+        if parameters.empty?
+          AST::Rule.new(
+            name: name_token.value,
+            alternatives: alternatives,
+            location: name_token.location
+          )
+        else
+          AST::ParameterizedRule.new(
+            name: name_token.value,
+            parameters: parameters,
+            alternatives: alternatives,
+            location: name_token.location
+          )
+        end
+      end
+
+      def parse_parameter_list
+        params = []
+        params << expect(:IDENTIFIER).value
+
+        while match?(:COMMA)
+          advance
+          params << expect(:IDENTIFIER).value
+        end
+
+        params
+      end
+
+      def parse_argument_list
+        # Parse arguments for parameterized rule calls
+        # Arguments are symbols (terminals or nonterminals)
+        args = []
+
+        if match?(:IDENTIFIER) || match?(:STRING) || match?(:CHAR)
+          symbol_token = current_token
+          kind = if symbol_token.value.match?(/^[A-Z]/) || match?(:STRING) || match?(:CHAR)
+                   :terminal
+                 else
+                   :nonterminal
+                 end
+          advance
+
+          args << AST::Symbol.new(
+            name: symbol_token.value,
+            kind: kind,
+            location: symbol_token.location
+          )
+
+          while match?(:COMMA)
+            advance
+            symbol_token = current_token
+            kind = if symbol_token.value.match?(/^[A-Z]/) || match?(:STRING) || match?(:CHAR)
+                     :terminal
+                   else
+                     :nonterminal
+                   end
+            advance
+
+            args << AST::Symbol.new(
+              name: symbol_token.value,
+              kind: kind,
+              location: symbol_token.location
+            )
+          end
+        end
+
+        args
+      end
+
+      def parse_alternative
+        symbols = []
+        action = nil
+        prec = nil
+        start_location = current_token.location
+
+        until match?(:PIPE) || match?(:SEMICOLON) || match?(:ACTION) ||
+              match?(:SECTION_SEPARATOR) || match?(:EOF)
+          if match?(:PREC)
+            advance
+            prec = current_token.value
+            advance
+          elsif match?(:IDENTIFIER) || match?(:STRING) || match?(:CHAR)
+            symbol_token = current_token
+            kind = if symbol_token.value.match?(/^[A-Z]/) || match?(:STRING) || match?(:CHAR)
+                     :terminal
+                   else
+                     :nonterminal
+                   end
+            advance
+
+            # Check for named reference: symbol[name] or parameterized call: symbol(args)
+            alias_name = nil
+            arguments = nil
+
+            if match?(:LBRACKET)
+              advance
+              alias_name = expect(:IDENTIFIER).value
+              expect(:RBRACKET)
+            elsif match?(:LPAREN)
+              # Parameterized rule call: list(expr)
+              advance
+              arguments = parse_argument_list
+              expect(:RPAREN)
+            end
+
+            symbols << AST::Symbol.new(
+              name: symbol_token.value,
+              kind: kind,
+              alias_name: alias_name,
+              arguments: arguments,
+              location: symbol_token.location
+            )
+          else
+            break
+          end
+        end
+
+        if match?(:ACTION)
+          action = AST::Action.new(
+            code: current_token.value,
+            location: current_token.location
+          )
+          advance
+        end
+
+        AST::Alternative.new(
+          symbols: symbols,
+          action: action,
+          prec: prec,
+          location: symbols.first&.location || start_location
+        )
+      end
+
+      def parse_epilogue
+        return nil unless match?(:SECTION_SEPARATOR)
+
+        advance
+        code = +""
+
+        until match?(:EOF)
+          code << current_token.value
+          advance
+        end
+
+        AST::Epilogue.new(code: code, location: current_token.location) unless code.empty?
+      end
+    end
+  end
+end

data/lib/collie/reporter/github.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Collie
+  module Reporter
+    # GitHub Actions format reporter
+    class Github
+      def report(offenses)
+        offenses.map { |o| format_offense(o) }.join("\n")
+      end
+
+      private
+
+      def format_offense(offense)
+        level = github_level(offense.severity)
+        file = offense.location.file
+        line = offense.location.line
+        col = offense.location.column
+        message = offense.message.gsub(",", "%2C") # Escape commas
+
+        "::#{level} file=#{file},line=#{line},col=#{col}::#{message}"
+      end
+
+      def github_level(severity)
+        case severity
+        when :error
+          "error"
+        when :warning
+          "warning"
+        else
+          "notice"
+        end
+      end
+    end
+  end
+end

data/lib/collie/reporter/json.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Collie
+  module Reporter
+    # JSON reporter
+    class Json
+      def report(offenses)
+        output = {
+          summary: {
+            total: offenses.length,
+            by_severity: count_by_severity(offenses)
+          },
+          files: group_by_file(offenses)
+        }
+
+        JSON.pretty_generate(output)
+      end
+
+      private
+
+      def count_by_severity(offenses)
+        offenses.group_by(&:severity).transform_values(&:count)
+      end
+
+      def group_by_file(offenses)
+        grouped = offenses.group_by { |o| o.location.file }
+
+        grouped.map do |file, file_offenses|
+          {
+            path: file,
+            offenses: file_offenses.map { |o| format_offense(o) }
+          }
+        end
+      end
+
+      def format_offense(offense)
+        {
+          rule: offense.rule.rule_name,
+          severity: offense.severity,
+          message: offense.message,
+          location: {
+            line: offense.location.line,
+            column: offense.location.column,
+            length: offense.location.length
+          }
+        }
+      end
+    end
+  end
+end

data/lib/collie/reporter/text.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+begin
+  require "pastel"
+  PASTEL_AVAILABLE = true
+rescue LoadError
+  PASTEL_AVAILABLE = false
+end
+
+module Collie
+  module Reporter
+    # Text reporter for terminal output
+    class Text
+      def initialize(colorize: true)
+        @colorize = colorize && PASTEL_AVAILABLE
+        @pastel = PASTEL_AVAILABLE ? Pastel.new(enabled: @colorize) : nil
+      end
+
+      def report(offenses)
+        return success_message if offenses.empty?
+
+        grouped = offenses.group_by { |o| o.location.file }
+        output = []
+
+        grouped.each do |file, file_offenses|
+          output << ""
+          output << (@pastel ? @pastel.bold(file) : file)
+
+          file_offenses.sort_by { |o| [o.location.line, o.location.column] }.each do |offense|
+            output << format_offense(offense)
+          end
+        end
+
+        output << ""
+        output << summary(offenses)
+        output.join("\n")
+      end
+
+      private
+
+      def format_offense(offense)
+        location = "#{offense.location.line}:#{offense.location.column}"
+        severity = colorize_severity(offense.severity)
+        rule = offense.rule.rule_name
+
+        "  #{location}: #{severity}: [#{rule}] #{offense.message}"
+      end
+
+      def colorize_severity(severity)
+        text = severity.to_s
+        return text unless @pastel
+
+        case severity
+        when :error
+          @pastel.red.bold(text)
+        when :warning
+          @pastel.yellow.bold(text)
+        when :convention
+          @pastel.blue(text)
+        when :info
+          @pastel.cyan(text)
+        else
+          text
+        end
+      end
+
+      def success_message
+        msg = "✓ No offenses detected"
+        @pastel ? @pastel.green(msg) : msg
+      end
+
+      def summary(offenses)
+        counts = offenses.group_by(&:severity).transform_values(&:count)
+        parts = []
+
+        if counts[:error]
+          msg = "#{counts[:error]} error(s)"
+          parts << (@pastel ? @pastel.red(msg) : msg)
+        end
+        if counts[:warning]
+          msg = "#{counts[:warning]} warning(s)"
+          parts << (@pastel ? @pastel.yellow(msg) : msg)
+        end
+        if counts[:convention]
+          msg = "#{counts[:convention]} convention(s)"
+          parts << (@pastel ? @pastel.blue(msg) : msg)
+        end
+        if counts[:info]
+          msg = "#{counts[:info]} info"
+          parts << (@pastel ? @pastel.cyan(msg) : msg)
+        end
+
+        "#{parts.join(', ')} found"
+      end
+    end
+  end
+end

data/lib/collie/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Collie
+  VERSION = "0.1.0"
+end

data/lib/collie.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "collie/version"
+require_relative "collie/cli"
+require_relative "collie/config"
+require_relative "collie/ast"
+require_relative "collie/parser/lexer"
+require_relative "collie/parser/parser"
+require_relative "collie/analyzer/symbol_table"
+require_relative "collie/analyzer/reachability"
+require_relative "collie/analyzer/recursion"
+require_relative "collie/analyzer/conflict"
+require_relative "collie/linter/base"
+require_relative "collie/linter/registry"
+require_relative "collie/formatter/formatter"
+require_relative "collie/formatter/options"
+require_relative "collie/reporter/text"
+require_relative "collie/reporter/json"
+require_relative "collie/reporter/github"
+
+# Collie is a linter and formatter for Lrama Style BNF grammar files (.y files).
+#
+# @example Basic usage
+#   require 'collie'
+#
+#   # Parse a grammar file
+#   parser = Collie::Parser::Parser.new(File.read('grammar.y'))
+#   ast = parser.parse
+#
+#   # Run linter
+#   config = Collie::Config.new
+#   linter = Collie::Linter.new(config)
+#   offenses = linter.lint(ast)
+#
+#   # Format the grammar
+#   formatter = Collie::Formatter::Formatter.new(config.formatter_options)
+#   puts formatter.format(ast)
+#
+# @see https://github.com/ruby/lrama Lrama parser generator
+module Collie
+  # Base error class for all Collie errors
+  class Error < StandardError; end
+
+  class << self
+    # Returns the root directory of the Collie gem
+    #
+    # @return [String] absolute path to the gem root directory
+    def root
+      File.expand_path("..", __dir__)
+    end
+  end
+end