collie 0.1.0

data/docs/playground/js/examples.js

@@ -0,0 +1,80 @@
+// Example grammar files for the playground
+
+const EXAMPLES = {
+  simple: {
+    name: 'Simple Calculator',
+    code: `%token NUMBER
+%token PLUS MINUS TIMES DIVIDE
+%token LPAREN RPAREN
+
+%left PLUS MINUS
+%left TIMES DIVIDE
+
+%%
+
+program
+    : expr
+    ;
+
+expr
+    : expr PLUS expr    { $$ = $1 + $3; }
+    | expr MINUS expr   { $$ = $1 - $3; }
+    | expr TIMES expr   { $$ = $1 * $3; }
+    | expr DIVIDE expr  { $$ = $1 / $3; }
+    | LPAREN expr RPAREN { $$ = $2; }
+    | NUMBER            { $$ = $1; }
+    ;
+
+%%
+`
+  },
+
+  lrama: {
+    name: 'Lrama Features Demo',
+    code: `%token NUMBER IDENTIFIER
+%token LPAREN RPAREN COMMA
+
+%rule pair(X, Y): X COMMA Y ;
+%rule list(X): X | list(X) COMMA X ;
+
+%%
+
+program
+    : function_call
+    ;
+
+function_call
+    : IDENTIFIER[func] LPAREN argument_list RPAREN
+        { call_function($func, $3); }
+    ;
+
+argument_list
+    : list(expr)
+    | /* empty */  { $$ = empty_list(); }
+    ;
+
+expr
+    : NUMBER[n]         { $$ = make_number($n); }
+    | IDENTIFIER[id]    { $$ = make_variable($id); }
+    | pair(NUMBER, NUMBER)
+    ;
+
+%%
+`
+  },
+
+  invalid: {
+    name: 'Invalid Grammar (Demo)',
+    code: `%token NUMBER
+%token NUMBER
+
+%%
+
+expr: UNDEFINED_TOKEN ;
+
+unused_rule: NUMBER ;
+
+%%
+`
+  }
+};

data/docs/playground/js/ruby-runner.js

@@ -0,0 +1,75 @@
+// Ruby.wasm runner for the playground
+
+class RubyRunner {
+  constructor() {
+    this.vm = null;
+    this.isReady = false;
+  }
+
+  async initialize() {
+    try {
+      await this.waitForRubyWasm();
+
+      if (typeof window.rubyWasm === 'object' && window.rubyWasm.eval) {
+        this.vm = window.rubyWasm;
+      } else if (window.rubyWasm && window.rubyWasm.DefaultRubyVM) {
+        const { DefaultRubyVM } = window.rubyWasm;
+        const response = await fetch(
+          'https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.6.2/dist/ruby+stdlib.wasm'
+        );
+        const module = await WebAssembly.compileStreaming(response);
+        const { vm } = await DefaultRubyVM(module);
+        this.vm = vm;
+      } else {
+        throw new Error('Unexpected Ruby.wasm API structure');
+      }
+
+      await this.loadCollieBundle();
+
+      this.isReady = true;
+      return true;
+    } catch (error) {
+      console.error('Failed to initialize Ruby.wasm:', error);
+      throw error;
+    }
+  }
+
+  async waitForRubyWasm() {
+    const maxAttempts = 50;
+    let attempts = 0;
+    const possibleNames = ['rubyVM', 'rubyWasm', 'RubyWasm', 'ruby', 'Ruby'];
+
+    while (attempts < maxAttempts) {
+      for (const name of possibleNames) {
+        if (window[name]) {
+          window.rubyWasm = window[name];
+          return;
+        }
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+      attempts++;
+    }
+
+    throw new Error('Ruby.wasm failed to load. Please refresh the page.');
+  }
+
+  async loadCollieBundle() {
+    try {
+      const response = await fetch(`collie-bundle.rb?v=${Date.now()}`);
+      const code = await response.text();
+      await this.eval(code);
+    } catch (error) {
+      console.error('Failed to load Collie bundle:', error);
+      throw error;
+    }
+  }
+
+  async eval(code) {
+    if (!this.isReady && !code.includes('module Collie')) {
+      throw new Error('Ruby VM is not ready');
+    }
+
+    return this.vm.eval(code);
+  }
+}

data/docs/playground/test-server.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Simple HTTP server for testing the playground locally
+
+cd "$(dirname "$0")"
+echo "Starting HTTP server at http://localhost:8000"
+echo "Open http://localhost:8000 in your browser"
+echo "Press Ctrl+C to stop"
+echo ""
+
+# Try Python 3 first, then Python 2
+if command -v python3 &> /dev/null; then
+    python3 -m http.server 8000
+elif command -v python &> /dev/null; then
+    python -m SimpleHTTPServer 8000
+else
+    echo "Error: Python not found. Please install Python to run the test server."
+    exit 1
+fi

data/exe/collie

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/collie"
+
+begin
+  Collie::CLI.start(ARGV)
+rescue Interrupt
+  warn "\nInterrupted"
+  exit 130
+rescue StandardError => e
+  warn "Error: #{e.message}"
+  warn e.backtrace.join("\n") if ENV["DEBUG"]
+  exit 1
+end

data/lib/collie/analyzer/conflict.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+
+module Collie
+  module Analyzer
+    # Conflict detection helpers for grammar analysis
+    class Conflict
+      def initialize(grammar, symbol_table)
+        @grammar = grammar
+        @symbol_table = symbol_table
+        @precedence_map = {}
+      end
+
+      def analyze
+        build_precedence_map
+        {
+          potential_shift_reduce: detect_shift_reduce_conflicts,
+          potential_reduce_reduce: detect_reduce_reduce_conflicts,
+          ambiguous_precedence: detect_ambiguous_precedence
+        }
+      end
+
+      private
+
+      def build_precedence_map
+        precedence_level = 0
+        @grammar.declarations.each do |decl|
+          next unless decl.is_a?(AST::PrecedenceDeclaration)
+
+          precedence_level += 1
+          decl.tokens.each do |token|
+            @precedence_map[token] = {
+              level: precedence_level,
+              associativity: decl.associativity
+            }
+          end
+        end
+      end
+
+      def detect_shift_reduce_conflicts
+        conflicts = []
+
+        @grammar.rules.each do |rule|
+          rule.alternatives.each_with_index do |alt, alt_idx|
+            alt.symbols.each_with_index do |symbol, sym_idx|
+              next unless symbol.terminal?
+              next if sym_idx == alt.symbols.length - 1
+
+              # Check if this could cause a shift-reduce conflict
+              next_symbol = alt.symbols[sym_idx + 1]
+              next unless next_symbol.nonterminal? && !has_precedence?(symbol.name)
+
+              conflicts << {
+                rule: rule.name,
+                alternative: alt_idx,
+                symbol: symbol.name,
+                location: symbol.location
+              }
+            end
+          end
+        end
+
+        conflicts
+      end
+
+      def detect_reduce_reduce_conflicts
+        conflicts = []
+        rule_groups = @grammar.rules.group_by { |r| r.alternatives.map { |a| a.symbols.map(&:name) } }
+
+        rule_groups.each_value do |rules|
+          next if rules.length <= 1
+
+          conflicts << {
+            rules: rules.map(&:name),
+            location: rules.first.location
+          }
+        end
+
+        conflicts
+      end
+
+      def detect_ambiguous_precedence
+        ambiguous = []
+
+        @grammar.rules.each do |rule|
+          rule.alternatives.each do |alt|
+            operators = alt.symbols.select { |s| s.terminal? && operator?(s.name) }
+            next if operators.empty?
+
+            operators_without_prec = operators.reject { |op| has_precedence?(op.name) }
+            next if operators_without_prec.empty?
+
+            ambiguous << {
+              rule: rule.name,
+              operators: operators_without_prec.map(&:name),
+              location: rule.location
+            }
+          end
+        end
+
+        ambiguous
+      end
+
+      def has_precedence?(token)
+        @precedence_map.key?(token)
+      end
+
+      def operator?(token)
+        token.match?(%r{^[+\-*/%^<>=!&|]+$})
+      end
+    end
+  end
+end

data/lib/collie/analyzer/reachability.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+
+module Collie
+  module Analyzer
+    # Reachability analysis for grammar rules
+    class Reachability
+      def initialize(grammar)
+        @grammar = grammar
+        @reachable = Set.new
+        @dependencies = Hash.new { |h, k| h[k] = Set.new }
+      end
+
+      def analyze(start_symbol = nil)
+        build_dependency_graph
+        start = start_symbol || infer_start_symbol
+        mark_reachable(start) if start
+        @reachable
+      end
+
+      def unreachable_rules
+        all_rules = @grammar.rules.to_set(&:name)
+        all_rules - @reachable
+      end
+
+      private
+
+      def build_dependency_graph
+        # Process normal rules
+        @grammar.rules.each do |rule|
+          rule.alternatives.each do |alt|
+            alt.symbols.each do |symbol|
+              if symbol.nonterminal?
+                @dependencies[rule.name] << symbol.name
+                # Also consider parameterized rule call arguments: list(expr)
+                if symbol.arguments
+                  symbol.arguments.each do |arg|
+                    @dependencies[rule.name] << arg.name if arg.nonterminal?
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        # Process parameterized rules (%rule)
+        @grammar.declarations.each do |decl|
+          next unless decl.is_a?(AST::ParameterizedRule)
+
+          decl.alternatives.each do |alt|
+            alt.symbols.each do |symbol|
+              if symbol.nonterminal?
+                @dependencies[decl.name] << symbol.name
+                if symbol.arguments
+                  symbol.arguments.each do |arg|
+                    @dependencies[decl.name] << arg.name if arg.nonterminal?
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def infer_start_symbol
+        # Find start symbol from %start declaration
+        start_decl = @grammar.declarations.find { |d| d.is_a?(AST::StartDeclaration) }
+        return start_decl.symbol if start_decl
+
+        # Otherwise, use the first rule
+        @grammar.rules.first&.name
+      end
+
+      def mark_reachable(symbol)
+        return if @reachable.include?(symbol)
+
+        @reachable << symbol
+        @dependencies[symbol].each { |dep| mark_reachable(dep) }
+      end
+    end
+  end
+end

data/lib/collie/analyzer/recursion.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+
+module Collie
+  module Analyzer
+    # Recursion analysis for grammar rules
+    class Recursion
+      def initialize(grammar)
+        @grammar = grammar
+        @left_recursive = []
+        @right_recursive = []
+      end
+
+      def analyze
+        @grammar.rules.each do |rule|
+          check_left_recursion(rule)
+          check_right_recursion(rule)
+        end
+
+        {
+          left_recursive: @left_recursive,
+          right_recursive: @right_recursive
+        }
+      end
+
+      def left_recursive?(rule_name)
+        @left_recursive.include?(rule_name)
+      end
+
+      def right_recursive?(rule_name)
+        @right_recursive.include?(rule_name)
+      end
+
+      private
+
+      def check_left_recursion(rule)
+        rule.alternatives.each do |alt|
+          next if alt.symbols.empty?
+
+          first_symbol = alt.symbols.first
+          if first_symbol.nonterminal? && first_symbol.name == rule.name && !@left_recursive.include?(rule.name)
+            @left_recursive << rule.name
+          end
+        end
+
+        # Check for indirect left recursion
+        check_indirect_left_recursion(rule)
+      end
+
+      def check_right_recursion(rule)
+        rule.alternatives.each do |alt|
+          next if alt.symbols.empty?
+
+          last_symbol = alt.symbols.last
+          if last_symbol.nonterminal? && last_symbol.name == rule.name && !@right_recursive.include?(rule.name)
+            @right_recursive << rule.name
+          end
+        end
+      end
+
+      def check_indirect_left_recursion(rule, visited = Set.new)
+        return if visited.include?(rule.name)
+
+        visited << rule.name
+
+        rule.alternatives.each do |alt|
+          check_alternative_for_indirect_recursion(alt, rule.name)
+        end
+      end
+
+      def check_alternative_for_indirect_recursion(alt, rule_name)
+        return if alt.symbols.empty?
+
+        first_symbol = alt.symbols.first
+        return unless first_symbol.nonterminal?
+
+        dependent_rule = @grammar.rules.find { |r| r.name == first_symbol.name }
+        return unless dependent_rule
+
+        check_dependent_rule_for_recursion(dependent_rule, rule_name)
+      end
+
+      def check_dependent_rule_for_recursion(dependent_rule, rule_name)
+        dependent_rule.alternatives.each do |dep_alt|
+          next if dep_alt.symbols.empty?
+          next unless dep_alt.symbols.first.nonterminal?
+          next unless dep_alt.symbols.first.name == rule_name
+          next if @left_recursive.include?(rule_name)
+
+          @left_recursive << rule_name
+        end
+      end
+    end
+  end
+end

data/lib/collie/analyzer/symbol_table.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+
+module Collie
+  module Analyzer
+    # Symbol table for tracking declared tokens and nonterminals
+    class SymbolTable
+      attr_reader :tokens, :nonterminals, :types
+
+      def initialize
+        @tokens = {} # name => {type_tag:, location:, usage_count:}
+        @nonterminals = {} # name => {location:, usage_count:}
+        @types = {} # type_tag => [names]
+      end
+
+      def add_token(name, type_tag: nil, location: nil)
+        raise Error, "Token '#{name}' already declared at #{@tokens[name][:location]}" if @tokens.key?(name)
+
+        @tokens[name] = { type_tag: type_tag, location: location, usage_count: 0 }
+        (@types[type_tag] ||= []) << name if type_tag
+      end
+
+      def add_nonterminal(name, location: nil)
+        return if @nonterminals.key?(name)
+
+        @nonterminals[name] = { location: location, usage_count: 0 }
+      end
+
+      def use_token(name)
+        return unless @tokens.key?(name)
+
+        @tokens[name][:usage_count] += 1
+      end
+
+      def use_nonterminal(name)
+        return unless @nonterminals.key?(name)
+
+        @nonterminals[name][:usage_count] += 1
+      end
+
+      def token?(name)
+        @tokens.key?(name)
+      end
+
+      def nonterminal?(name)
+        @nonterminals.key?(name)
+      end
+
+      def declared?(name)
+        token?(name) || nonterminal?(name)
+      end
+
+      def unused_tokens
+        @tokens.select { |_name, info| info[:usage_count].zero? }.keys
+      end
+
+      def unused_nonterminals
+        @nonterminals.select { |_name, info| info[:usage_count].zero? }.keys
+      end
+
+      def duplicate_symbols
+        @tokens.keys & @nonterminals.keys
+      end
+    end
+  end
+end