collie 0.1.0 → 1.0.0

data/lib/collie/config/schema.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Collie
+  class Config
+    # JSON Schema for .collie.yml files.
+    module Schema
+      SEVERITIES = %w[error warning convention info].freeze
+
+      SEVERITY_SCHEMA = {
+        "type" => "string",
+        "enum" => SEVERITIES
+      }.freeze
+
+      FORMATTER_PROPERTIES = {
+        "indent_size" => {
+          "type" => "integer",
+          "minimum" => 1
+        },
+        "align_tokens" => {
+          "type" => "boolean"
+        },
+        "align_alternatives" => {
+          "type" => "boolean"
+        },
+        "blank_lines_around_sections" => {
+          "type" => "integer",
+          "minimum" => 0
+        },
+        "max_line_length" => {
+          "type" => "integer",
+          "minimum" => 1
+        }
+      }.freeze
+
+      class << self
+        def to_h
+          {
+            "$schema" => "https://json-schema.org/draft/2020-12/schema",
+            "title" => "Collie configuration",
+            "type" => "object",
+            "additionalProperties" => false,
+            "properties" => properties,
+            "$defs" => definitions
+          }
+        end
+
+        private
+
+        def properties
+          {
+            "inherit_from" => {
+              "type" => "string"
+            },
+            "include" => string_array_schema,
+            "exclude" => string_array_schema,
+            "formatter" => formatter_schema,
+            "rules" => rules_schema
+          }
+        end
+
+        def formatter_schema
+          {
+            "type" => "object",
+            "additionalProperties" => false,
+            "properties" => FORMATTER_PROPERTIES
+          }
+        end
+
+        def rules_schema
+          {
+            "type" => "object",
+            "additionalProperties" => { "$ref" => "#/$defs/ruleConfig" },
+            "propertyNames" => {
+              "pattern" => "^[A-Za-z][A-Za-z0-9_]*$"
+            }
+          }
+        end
+
+        def definitions
+          {
+            "severity" => SEVERITY_SCHEMA,
+            "ruleConfig" => {
+              "oneOf" => [
+                { "type" => "boolean" },
+                rule_object_schema
+              ]
+            }
+          }
+        end
+
+        def rule_object_schema
+          {
+            "type" => "object",
+            "additionalProperties" => true,
+            "properties" => {
+              "enabled" => { "type" => "boolean" },
+              "severity" => { "$ref" => "#/$defs/severity" },
+              "pattern" => { "type" => "string" },
+              "max_alternatives" => {
+                "type" => "integer",
+                "minimum" => 1
+              }
+            }
+          }
+        end
+
+        def string_array_schema
+          {
+            "type" => "array",
+            "items" => { "type" => "string" },
+            "uniqueItems" => true
+          }
+        end
+      end
+    end
+  end
+end

data/lib/collie/config.rb

@@ -18,6 +18,62 @@ module Collie
       "exclude" => ["vendor/**/*", "tmp/**/*"]
     }.freeze
 
+    PROFILE_OVERRIDES = {
+      "default" => {},
+      "lrama" => {
+        "rules" => {
+          "LeftRecursion" => { "enabled" => false },
+          "FactorizableRules" => { "enabled" => false },
+          "RightRecursion" => { "severity" => "warning" }
+        }
+      },
+      "bison" => {
+        "rules" => {
+          "LeftRecursion" => { "enabled" => false },
+          "FactorizableRules" => { "enabled" => false },
+          "RightRecursion" => { "severity" => "warning" }
+        }
+      },
+      "strict" => {
+        "formatter" => {
+          "max_line_length" => 100
+        },
+        "rules" => {
+          "AmbiguousPrecedence" => { "severity" => "warning" },
+          "ConsistentTagNaming" => { "severity" => "warning" },
+          "EmptyAction" => { "severity" => "warning" },
+          "FactorizableRules" => { "severity" => "warning" },
+          "LongRule" => { "severity" => "warning" },
+          "NonterminalNaming" => { "severity" => "warning" },
+          "PrecImprovement" => { "severity" => "warning" },
+          "RedundantEpsilon" => { "severity" => "warning" },
+          "TokenNaming" => { "severity" => "warning" },
+          "TrailingWhitespace" => { "severity" => "warning" }
+        }
+      },
+      "minimal" => {
+        "rules" => {
+          "AmbiguousPrecedence" => { "enabled" => false },
+          "ConsistentTagNaming" => { "enabled" => false },
+          "EmptyAction" => { "enabled" => false },
+          "FactorizableRules" => { "enabled" => false },
+          "LeftRecursion" => { "enabled" => false },
+          "LongRule" => { "enabled" => false },
+          "NonterminalNaming" => { "enabled" => false },
+          "PrecImprovement" => { "enabled" => false },
+          "RedundantEpsilon" => { "enabled" => false },
+          "RightRecursion" => { "enabled" => false },
+          "TokenNaming" => { "enabled" => false },
+          "TrailingWhitespace" => { "enabled" => false },
+          "UnreachableRule" => { "enabled" => false },
+          "UnusedNonterminal" => { "enabled" => false },
+          "UnusedToken" => { "enabled" => false }
+        }
+      }
+    }.freeze
+
+    PROFILE_NAMES = PROFILE_OVERRIDES.keys.freeze
+
     attr_reader :config
 
     def initialize(config_path = nil)
@@ -51,34 +107,22 @@ module Collie
       new
     end
 
-    def self.generate_default(path = ".collie.yml")
-      File.write(path, DEFAULT_CONFIG.to_yaml)
+    def self.generate_default(path = ".collie.yml", profile: "default")
+      File.write(path, profile_config(profile).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)
+    def self.profile_config(profile)
+      profile_name = profile.to_s
+      raise Error, "Unknown config profile: #{profile}" unless PROFILE_OVERRIDES.key?(profile_name)
 
-        # 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
+      deep_merge(DEFAULT_CONFIG, PROFILE_OVERRIDES.fetch(profile_name))
+    end
 
-      config
+    def self.schema
+      Schema.to_h
     end
 
-    def deep_merge(hash1, hash2)
+    def self.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)
@@ -87,5 +131,45 @@ module Collie
         end
       end
     end
+
+    private
+
+    def load_config(config_path)
+      config = DEFAULT_CONFIG.dup
+      if config_path
+        raise Error, "Config file not found: #{config_path}" unless File.exist?(config_path)
+
+        path = config_path
+      else
+        path = ".collie.yml" if File.exist?(".collie.yml")
+      end
+      return config unless path
+
+      user_config = load_yaml_config(path)
+
+      if user_config["inherit_from"]
+        parent_path = File.expand_path(user_config["inherit_from"], File.dirname(path))
+        raise Error, "Inherited config file not found: #{parent_path}" unless File.exist?(parent_path)
+
+        config = deep_merge(config, load_yaml_config(parent_path))
+      end
+
+      deep_merge(config, user_config)
+    end
+
+    def load_yaml_config(path)
+      loaded = YAML.safe_load(File.read(path), aliases: true) || {}
+      raise Error, "Config file must contain a YAML mapping: #{path}" unless loaded.is_a?(Hash)
+
+      loaded
+    rescue Psych::SyntaxError => e
+      raise Error, "Invalid config file #{path}: #{e.message}"
+    end
+
+    def deep_merge(hash1, hash2)
+      self.class.deep_merge(hash1, hash2)
+    end
   end
 end
+
+require_relative "config/schema"

data/lib/collie/formatter/formatter.rb

@@ -13,26 +13,28 @@ module Collie
 
         # Prologue
         output << format_prologue(ast.prologue) if ast.prologue
+        append_blank_lines(output) if ast.prologue
 
         # Declarations
         output << format_declarations(ast.declarations) unless ast.declarations.empty?
+        append_blank_lines(output) unless ast.declarations.empty?
 
         # Section separator
-        output << ""
         output << "%%"
-        output << ""
+        append_blank_lines(output)
 
         # Rules
-        output << format_rules(ast.rules)
+        output << format_rules(ast.rules) unless ast.rules.empty?
 
         # Epilogue
         if ast.epilogue
-          output << ""
+          append_blank_lines(output)
           output << "%%"
-          output << ""
+          append_blank_lines(output)
           output << ast.epilogue.code
         end
 
+        output.pop while output.last == ""
         output.join("\n")
       end
 
@@ -43,47 +45,44 @@ module Collie
       end
 
       def format_declarations(declarations)
-        grouped = declarations.group_by(&:class)
         output = []
+        index = 0
 
-        # 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])
+        while index < declarations.length
+          declaration = declarations[index]
+          declarations_group = consecutive_declarations(declarations, index, declaration.class)
+          output << format_declaration_group(declarations_group)
           output << ""
+          index += declarations_group.length
         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
+        output.pop while output.last == ""
+        output.join("\n")
+      end
 
-        # Format %rule declarations (Lrama extension)
-        if grouped[AST::ParameterizedRule]
-          output << format_parameterized_rule_declarations(grouped[AST::ParameterizedRule])
-          output << ""
-        end
+      def consecutive_declarations(declarations, start_index, declaration_class)
+        declarations[start_index..].take_while { |declaration| declaration.is_a?(declaration_class) }
+      end
 
-        # Format %inline declarations (Lrama extension)
-        if grouped[AST::InlineRule]
-          output << format_inline_rule_declarations(grouped[AST::InlineRule])
-          output << ""
+      def format_declaration_group(declarations)
+        case declarations.first
+        when AST::TokenDeclaration
+          format_token_declarations(declarations)
+        when AST::TypeDeclaration
+          format_type_declarations(declarations)
+        when AST::PrecedenceDeclaration
+          format_precedence_declarations(declarations)
+        when AST::UnionDeclaration
+          format_union_declarations(declarations)
+        when AST::UnknownDeclaration
+          format_unknown_declarations(declarations)
+        when AST::StartDeclaration
+          format_start_declarations(declarations)
+        when AST::ParameterizedRule
+          format_parameterized_rule_declarations(declarations)
+        when AST::InlineRule
+          format_inline_rule_declarations(declarations)
         end
-
-        output.join("\n")
       end
 
       def format_token_declarations(declarations)
@@ -98,19 +97,20 @@ module Collie
         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(' ')}"
+          prefix = tag.empty? ? "%token" : "%token #{tag.ljust(max_tag_length)}"
+          wrap_declaration(prefix, decl.names)
         end.join("\n")
       end
 
       def format_token_declaration(decl)
         tag = decl.type_tag ? " <#{decl.type_tag}>" : ""
-        "%token#{tag} #{decl.names.join(' ')}"
+        wrap_declaration("%token#{tag}", decl.names)
       end
 
       def format_type_declarations(declarations)
         declarations.map do |decl|
           tag = decl.type_tag ? " <#{decl.type_tag}>" : ""
-          "%type#{tag} #{decl.names.join(' ')}"
+          wrap_declaration("%type#{tag}", decl.names)
         end.join("\n")
       end
 
@@ -125,25 +125,65 @@ module Collie
 
         declarations.map do |decl|
           directive = directive_names[decl.associativity]
-          if @options.align_tokens
-            "#{directive.ljust(max_directive_length)} #{decl.tokens.join(' ')}"
+          prefix = @options.align_tokens ? directive.ljust(max_directive_length) : directive
+          wrap_declaration(prefix, decl.tokens)
+        end.join("\n")
+      end
+
+      def wrap_declaration(prefix, names)
+        return prefix if names.empty?
+
+        lines = []
+        current = prefix
+
+        names.each do |name|
+          candidate = "#{current} #{name}"
+          if current != prefix && candidate.length > @options.max_line_length
+            lines << current
+            current = "#{@options.indent}#{name}"
           else
-            "#{directive} #{decl.tokens.join(' ')}"
+            current = candidate
           end
+        end
+
+        lines << current
+        lines.join("\n")
+      end
+
+      def format_union_declarations(declarations)
+        declarations.map do |decl|
+          body = decl.body.to_s
+          body.start_with?("{") ? "%union #{body}" : "%union {#{body}}"
         end.join("\n")
       end
 
+      def format_unknown_declarations(declarations)
+        declarations.map(&:source).join("\n")
+      end
+
+      def format_start_declarations(declarations)
+        declarations.map { |decl| "%start #{decl.symbol}" }.join("\n")
+      end
+
       def format_parameterized_rule_declarations(declarations)
         declarations.map do |decl|
-          params = "(#{decl.parameters.join(', ')})"
+          params = decl.parameters.empty? ? "" : "(#{decl.parameters.join(', ')})"
           alternatives = decl.alternatives.map { |alt| format_alternative(alt) }.join(" | ")
-          "%rule #{decl.name}#{params}: #{alternatives} ;"
+          separator = alternatives.start_with?(" |") ? "" : " "
+          "%rule #{decl.name}#{params}:#{separator}#{alternatives} ;"
         end.join("\n")
       end
 
       def format_inline_rule_declarations(declarations)
         declarations.map do |decl|
-          "%inline #{decl.rule}"
+          output = "%inline #{decl.rule}"
+          output += "(#{decl.parameters.join(', ')})" unless decl.parameters.empty?
+          unless decl.alternatives.empty?
+            alternatives = decl.alternatives.map { |alt| format_alternative(alt) }.join(" | ")
+            separator = alternatives.start_with?(" |") ? "" : " "
+            output += ":#{separator}#{alternatives} ;"
+          end
+          output
         end.join("\n")
       end
 
@@ -159,18 +199,19 @@ module Collie
         end
 
         output = [rule_header]
+        indent = @options.align_alternatives ? @options.indent : ""
 
         rule.alternatives.each_with_index do |alt, index|
-          prefix = index.zero? ? "    :" : "    |"
+          prefix = index.zero? ? "#{indent}:" : "#{indent}|"
           output << "#{prefix} #{format_alternative(alt)}"
         end
 
-        output << "    ;"
+        output << "#{indent};"
         output.join("\n")
       end
 
       def format_alternative(alt)
-        symbols_str = alt.symbols.map { |sym| format_symbol(sym) }.join(" ")
+        symbols_str = alt.explicit_empty ? (alt.empty_marker || "%empty") : alt.symbols.map { |sym| format_symbol(sym) }.join(" ")
         action_str = alt.action ? " #{alt.action.code}" : ""
         prec_str = alt.prec ? " %prec #{alt.prec}" : ""
 
@@ -191,6 +232,10 @@ module Collie
 
         result
       end
+
+      def append_blank_lines(output)
+        @options.blank_lines_around_sections.times { output << "" }
+      end
     end
   end
 end

data/lib/collie/formatter/options.rb

@@ -8,16 +8,28 @@ module Collie
                     :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
+        @indent_size = fetch_option(config, :indent_size, 2)
+        @align_tokens = fetch_option(config, :align_tokens, true)
+        @align_alternatives = fetch_option(config, :align_alternatives, true)
+        @blank_lines_around_sections = fetch_option(config, :blank_lines_around_sections, 1)
+        @max_line_length = fetch_option(config, :max_line_length, 120)
       end
 
       def indent(level = 1)
         " " * (indent_size * level)
       end
+
+      private
+
+      def fetch_option(config, key, default)
+        return default unless config
+
+        string_key = key.to_s
+        return config[string_key] if config.key?(string_key)
+        return config[key] if config.key?(key)
+
+        default
+      end
     end
   end
 end

data/lib/collie/formatter/signature.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Collie
+  module Formatter
+    # Semantic signature for verifying that formatting preserved grammar structure.
+    class Signature
+      def self.build(ast)
+        new.build(ast)
+      end
+
+      def build(ast)
+        [
+          :grammar,
+          ast.prologue&.code,
+          ast.declarations.map { |declaration| declaration_signature(declaration) },
+          ast.rules.map { |rule| rule_signature(rule) },
+          ast.epilogue&.code
+        ]
+      end
+
+      private
+
+      def declaration_signature(declaration)
+        case declaration
+        when AST::TokenDeclaration
+          [:token, declaration.type_tag, declaration.names]
+        when AST::TypeDeclaration
+          [:type, declaration.type_tag, declaration.names]
+        when AST::PrecedenceDeclaration
+          [:precedence, declaration.associativity, declaration.tokens]
+        when AST::StartDeclaration
+          [:start, declaration.symbol]
+        when AST::UnionDeclaration
+          [:union, declaration.body]
+        when AST::UnknownDeclaration
+          [:unknown, declaration.source]
+        when AST::ParameterizedRule, AST::InlineRule
+          rule_signature(declaration)
+        else
+          [declaration.class.name]
+        end
+      end
+
+      def rule_signature(rule)
+        [
+          rule.is_a?(AST::InlineRule) ? :inline_rule : :rule,
+          rule.is_a?(AST::InlineRule) ? rule.rule : rule.name,
+          rule.respond_to?(:parameters) ? rule.parameters : [],
+          rule.alternatives.map { |alternative| alternative_signature(alternative) }
+        ]
+      end
+
+      def alternative_signature(alternative)
+        [
+          alternative.symbols.map { |symbol| symbol_signature(symbol) },
+          alternative.action&.code,
+          alternative.prec,
+          alternative.explicit_empty
+        ]
+      end
+
+      def symbol_signature(symbol)
+        [
+          symbol.name,
+          symbol.kind,
+          symbol.alias_name,
+          Array(symbol.arguments).map { |argument| symbol_signature(argument) }
+        ]
+      end
+    end
+  end
+end

data/lib/collie/linter/base.rb

@@ -28,6 +28,8 @@ module Collie
 
     # Base class for all lint rules
     class Base
+      VALID_SEVERITIES = %i[error warning convention info].freeze
+
       class << self
         attr_accessor :rule_name, :description, :severity, :autocorrectable
       end
@@ -52,11 +54,58 @@ module Collie
           rule: self.class,
           location: node.location,
           message: message,
+          severity: configured_severity,
           autocorrect: autocorrect
         )
       end
 
       attr_reader :offenses
+
+      def configured_severity
+        severity = config_value(:severity)
+        return self.class.severity unless severity
+
+        normalized = severity.to_sym
+        VALID_SEVERITIES.include?(normalized) ? normalized : self.class.severity
+      end
+
+      def config_value(key, default = nil)
+        string_key = key.to_s
+        return @config[string_key] if @config.key?(string_key)
+        return @config[key] if @config.key?(key)
+
+        default
+      end
+
+      def each_rule_like(ast)
+        ast.rules.each { |rule| yield rule }
+
+        ast.declarations.each do |declaration|
+          next unless rule_like_declaration?(declaration)
+
+          yield declaration
+        end
+      end
+
+      def rule_like_declaration?(declaration)
+        declaration.is_a?(AST::ParameterizedRule) || declaration.is_a?(AST::InlineRule)
+      end
+
+      def rule_like_name(rule)
+        rule.is_a?(AST::InlineRule) ? rule.rule : rule.name
+      end
+
+      def rule_like_parameters(rule)
+        rule.respond_to?(:parameters) ? rule.parameters : []
+      end
+
+      def find_rule_like(ast, name)
+        each_rule_like(ast) do |rule|
+          return rule if rule_like_name(rule) == name
+        end
+
+        nil
+      end
     end
   end
 end