rusa 0.1.0

data/lib/rusa/analysis/parse_action.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Rusa
+  module Analysis
+    # Parse actions populate ACTION tables.
+    class Shift
+      attr_reader :state #: Integer
+
+      #: (Integer) -> void
+      def initialize(state)
+        @state = state
+        freeze
+      end
+
+      #: () -> [:shift, Integer]
+      def to_a
+        [:shift, state]
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class) && other.state == state
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        [self.class, state].hash
+      end
+    end
+
+    class Reduce
+      attr_reader :production_id #: Integer?
+
+      #: (Integer?) -> void
+      def initialize(production_id)
+        @production_id = production_id
+        freeze
+      end
+
+      #: () -> [:reduce, Integer?]
+      def to_a
+        [:reduce, production_id]
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class) && other.production_id == production_id
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        [self.class, production_id].hash
+      end
+    end
+
+    class Accept
+      #: () -> void
+      def initialize
+        freeze
+      end
+
+      #: () -> [:accept]
+      def to_a
+        [:accept]
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class)
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        self.class.hash
+      end
+    end
+  end
+end

data/lib/rusa/cli.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rusa
+  # CLI wires grammar loading, table generation, and code output.
+  class CLI
+    #: (Array[String]) -> Integer
+    def run(argv)
+      command = argv.shift
+
+      case command
+      when "generate"
+        generate(argv)
+      when "report"
+        report(argv)
+      when "check"
+        check(argv)
+      else
+        $stderr.puts(usage)
+        1
+      end
+    end
+
+    private
+
+    #: (Array[String]) -> Integer
+    def generate(argv)
+      options = parse_generate_options(argv)
+      grammar_file = required_grammar_file(argv)
+      grammar, table = build(grammar_file)
+      generator = Generator::CodeGenerator.new(
+        grammar,
+        table,
+        class_name: generator_class_name(options, grammar_file),
+        compact: compact_option(options),
+        line_tracking: line_tracking_option(options)
+      )
+      output_path = output_path_for(options, grammar_file)
+      File.write(output_path, generator.generate)
+      puts "generated #{output_path}"
+      puts table.report if verbose_option(options)
+      0
+    end
+
+    #: (Array[String]) -> Integer
+    def report(argv)
+      grammar_file = required_grammar_file(argv)
+      grammar, table = build(grammar_file)
+      print_section("Grammar warnings:", grammar.warnings)
+      puts
+      print_section("Conflict report:", conflict_messages(table))
+      puts
+      puts table.report
+      0
+    end
+
+    #: (Array[String]) -> Integer
+    def check(argv)
+      grammar_file = required_grammar_file(argv)
+      grammar, table = build(grammar_file)
+      puts "ok: #{grammar_file}"
+      puts "warnings: #{grammar.warnings.length}"
+      puts "conflicts: #{table.conflicts.length}"
+      0
+    end
+
+    #: (String) -> [Grammar::Grammar, Analysis::LALRTable]
+    def build(grammar_file)
+      grammar = load_grammar(grammar_file)
+      [grammar, Analysis::LALRTable.new(grammar)]
+    end
+
+    #: (String) -> Grammar::Grammar
+    def load_grammar(path)
+      source = File.read(path)
+      result = TOPLEVEL_BINDING.eval(source, path)
+      return result if result.is_a?(Grammar::Grammar)
+
+      raise ArgumentError, "#{path} did not evaluate to a Rusa grammar"
+    end
+
+    #: (String) -> String
+    def default_output_path(grammar_file)
+      base = File.basename(grammar_file, File.extname(grammar_file))
+      "#{base}_parser.rb"
+    end
+
+    #: (String) -> String
+    def default_class_name(grammar_file)
+      base = File.basename(grammar_file, File.extname(grammar_file))
+      classify(base) + "Parser"
+    end
+
+    #: () -> String
+    def usage
+      <<~TEXT
+        Usage:
+          rusa generate GRAMMAR.rb [-o OUTPUT.rb] [--class NAME]
+            [--compact] [--verbose] [--no-line-tracking]
+          rusa report GRAMMAR.rb
+          rusa check GRAMMAR.rb
+      TEXT
+    end
+
+    #: (Array[String]) -> Hash[Symbol, bool | String]
+    def parse_generate_options(argv)
+      options = default_generate_options
+      OptionParser.new do |opts|
+        opts.on("-o FILE") { |value| options[:output] = value }
+        opts.on("--class NAME") { |value| options[:class_name] = value }
+        opts.on("--compact") { options[:compact] = true }
+        opts.on("--verbose") { options[:verbose] = true }
+        opts.on("--no-line-tracking") { options[:line_tracking] = false }
+      end.parse!(argv)
+      options
+    end
+
+    #: () -> Hash[Symbol, bool | String]
+    def default_generate_options
+      {
+        compact: false,
+        line_tracking: true,
+        verbose: false
+      }
+    end
+
+    #: (Array[String]) -> String
+    def required_grammar_file(argv)
+      argv.first or raise ArgumentError, "grammar file is required"
+    end
+
+    #: (Hash[Symbol, bool | String], String) -> String
+    def generator_class_name(options, grammar_file)
+      class_name = options[:class_name]
+      return class_name if class_name.is_a?(String)
+
+      default_class_name(grammar_file)
+    end
+
+    #: (Hash[Symbol, bool | String], String) -> String
+    def output_path_for(options, grammar_file)
+      output = options[:output]
+      return output if output.is_a?(String)
+
+      default_output_path(grammar_file)
+    end
+
+    #: (Hash[Symbol, bool | String]) -> bool
+    def compact_option(options)
+      options[:compact] == true
+    end
+
+    #: (Hash[Symbol, bool | String]) -> bool
+    def line_tracking_option(options)
+      options[:line_tracking] != false
+    end
+
+    #: (Hash[Symbol, bool | String]) -> bool
+    def verbose_option(options)
+      options[:verbose] == true
+    end
+
+    #: (String, Array[String]) -> void
+    def print_section(title, items)
+      puts title
+      return puts("  none") if items.empty?
+
+      items.each { |item| puts "  #{item}" }
+    end
+
+    #: (Analysis::LALRTable) -> Array[String]
+    def conflict_messages(table)
+      table.conflicts.map do |conflict|
+        "state #{conflict.state_id}, lookahead #{conflict.lookahead}: #{conflict.message}"
+      end
+    end
+
+    #: (String) -> String
+    def classify(text)
+      text
+        .split(/[^a-zA-Z0-9]+/)
+        .reject(&:empty?)
+        .map(&:capitalize)
+        .join
+    end
+  end
+end

data/lib/rusa/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rusa
+  class Error < StandardError; end
+
+  class GrammarError < Error; end
+  class DuplicateTokenError < GrammarError; end
+  class DuplicateRuleError < GrammarError; end
+  class UndefinedSymbolError < GrammarError; end
+  class NoStartSymbolError < GrammarError; end
+  class InvalidGrammarError < GrammarError; end
+end

data/lib/rusa/generator/code_generator.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require "base64"
+require "erb"
+
+module Rusa
+  module Generator
+    # CodeGenerator emits a standalone Ruby parser class.
+    class CodeGenerator
+      TEMPLATE = <<~'RUBY'
+        # frozen_string_literal: true
+        # Generated by Rusa v<%= version %>
+        <% if compact %>
+        require "base64"
+        <% end %>
+
+        class <%= class_name %>
+          class ParseError < StandardError; end
+          Token = Struct.new(:type, :value, :line, :column)
+
+          ACTION_TABLE = <%= action_table_source %>.freeze
+          GOTO_TABLE = <%= goto_table_source %>.freeze
+          PRODUCTIONS = <%= productions_source %>.freeze
+          TOKEN_PATTERNS = <%= token_patterns_source %>.freeze
+          SKIP_PATTERNS = <%= skip_patterns_source %>.freeze
+
+          def tokenize(input)
+            tokens = []
+            pos = 0
+            line = 1
+            column = 1
+
+            while pos < input.length
+              chunk = input[pos..]
+
+              if (consumed = consume_pattern(SKIP_PATTERNS, chunk))
+                line, column = advance_position(consumed, line, column)
+                pos += consumed.length
+                next
+              end
+
+              matched = consume_token(chunk)
+              unless matched
+                message =
+                  "Unexpected character #{input[pos].inspect}" \
+                  "#{position_suffix(line, column)}"
+                raise ParseError, message
+              end
+
+              name, lexeme = matched
+              tokens << Token.new(name, lexeme, line, column)
+              line, column = advance_position(lexeme, line, column)
+              pos += lexeme.length
+            end
+
+            tokens << Token.new(:$end, nil, line, column)
+          end
+
+          def parse(input)
+            tokens = tokenize(input)
+            stack = [0]
+            values = []
+            position = 0
+
+            loop do
+              state = stack.last
+              token = tokens.fetch(position)
+              action = ACTION_TABLE.dig(state, token.type)
+
+              unless action
+                raise ParseError, unexpected_token_message(state, token, tokens, position)
+              end
+
+              case action[0]
+              when :shift
+                stack << action[1]
+                values << token.value
+                position += 1
+              when :reduce
+                production_id = action[1]
+                lhs, rhs_length = PRODUCTIONS.fetch(production_id)
+                args = rhs_length.zero? ? [] : values.pop(rhs_length)
+                rhs_length.times { stack.pop }
+                values << semantic_action(production_id, args)
+
+                goto_state = GOTO_TABLE.dig(stack.last, lhs)
+                raise ParseError, "Internal parser error: missing goto for #{lhs}" unless goto_state
+
+                stack << goto_state
+              when :accept
+                return values.last
+              else
+                raise ParseError, "Unknown parser action: #{action.inspect}"
+              end
+            end
+          end
+
+          private
+
+          def consume_pattern(patterns, chunk)
+            patterns.each do |pattern|
+              if (match = pattern.match(chunk)) && match.begin(0).zero?
+                return match[0]
+              end
+            end
+
+            nil
+          end
+
+          def consume_token(chunk)
+            TOKEN_PATTERNS.each do |name, pattern|
+              if (match = pattern.match(chunk)) && match.begin(0).zero?
+                return [name, match[0]]
+              end
+            end
+
+            nil
+          end
+
+          def advance_position(text, line, column)
+            text.each_char do |char|
+              if char == "\n"
+                line += 1
+                column = 1
+              else
+                column += 1
+              end
+            end
+
+            [line, column]
+          end
+
+          def position_suffix(line, column)
+        <% if line_tracking %>
+            " at line #{line}, column #{column}"
+        <% else %>
+            ""
+        <% end %>
+          end
+
+          def semantic_action(production_id, args)
+            case production_id
+        <%= action_cases %>
+            else
+              default_semantic_action(args)
+            end
+          end
+
+          def default_semantic_action(args)
+            return nil if args.empty?
+            return args.first if args.length == 1
+
+            args
+          end
+
+          def unexpected_token_message(state, token, tokens, position)
+            expected = expected_tokens_for(state)
+            context = context_for(tokens, position)
+
+            "Unexpected #{token.type}#{position_suffix(token.line, token.column)}. " \
+              "Expected: #{expected.join(', ')}. Context: #{context}"
+          end
+
+          def expected_tokens_for(state)
+            ACTION_TABLE.fetch(state, {}).keys.reject { |name| name == :$end }
+          end
+
+          def context_for(tokens, position)
+            tokens
+              .slice([position - 2, 0].max, 5)
+              .to_a
+              .map { |entry| entry.value || entry.type }
+              .join(" ")
+          end
+        end
+      RUBY
+
+      #: (Grammar::Grammar, Analysis::LALRTable, ?class_name: String, ?compact: bool, ?line_tracking: bool) -> void
+      def initialize(
+        grammar,
+        lalr_table,
+        class_name: "Parser",
+        compact: false,
+        line_tracking: true
+      )
+        @grammar = grammar
+        @table = lalr_table
+        @class_name = class_name
+        @compact = compact
+        @line_tracking = line_tracking
+      end
+
+      #: () -> String
+      def generate
+        ERB.new(TEMPLATE, trim_mode: "-").result_with_hash(template_context)
+      end
+
+      private
+
+      attr_reader :grammar #: Grammar::Grammar
+      attr_reader :table #: Analysis::LALRTable
+      attr_reader :class_name #: String
+      attr_reader :compact #: bool
+      attr_reader :line_tracking #: bool
+
+      #: () -> Hash[Symbol, String | bool]
+      def template_context
+        {
+          version: Rusa::VERSION,
+          compact: compact,
+          class_name: class_name,
+          line_tracking: line_tracking,
+          action_table_source: serialized_action_table,
+          goto_table_source: serialized_plain_object(table.goto_table),
+          productions_source: serialized_productions,
+          token_patterns_source: serialized_tokens,
+          skip_patterns_source: serialized_skip_patterns,
+          action_cases: action_cases
+        }
+      end
+
+      #: () -> String
+      def serialized_action_table
+        serialize(action_table_payload)
+      end
+
+      #: () -> String
+      def serialized_productions
+        serialize(production_payload)
+      end
+
+      #: () -> String
+      def serialized_tokens
+        serialize(token_payload)
+      end
+
+      #: () -> String
+      def serialized_skip_patterns
+        serialize(skip_payload)
+      end
+
+      #: (Object) -> String
+      def serialized_plain_object(object)
+        serialize(plain_object(object))
+      end
+
+      #: () -> Hash[Integer, Hash[Symbol, [:shift, Integer] | [:reduce, Integer?] | [:accept]]]
+      def action_table_payload
+        table.action_table.each_with_object(action_table_index) do |(state_id, actions), payload|
+          payload[state_id] = actions.transform_values(&:to_a)
+        end
+      end
+
+      #: () -> Array[[Symbol, Integer]]
+      def production_payload
+        grammar.productions.map do |production|
+          [production.lhs, production.rhs.length]
+        end
+      end
+
+      #: () -> Array[[Symbol, Regexp]]
+      def token_payload
+        token_terminals.map { |terminal| [terminal.name, terminal.pattern] }
+      end
+
+      #: () -> Array[Regexp]
+      def skip_payload
+        grammar.skip_patterns
+      end
+
+      #: (Object) -> String
+      def serialize(object)
+        return object.inspect unless compact
+
+        encoded = Base64.strict_encode64(Marshal.dump(object))
+        "Marshal.load(Base64.decode64(#{encoded.inspect}))"
+      end
+
+      #: (Object) -> Object
+      def plain_object(object)
+        case object
+        when Hash
+          plain_hash = {} #: Hash[Object, Object]
+          object.each do |key, value|
+            plain_hash[key] = plain_object(value)
+          end
+          plain_hash
+        when Array
+          object.map { |entry| plain_object(entry) }
+        else
+          object
+        end
+      end
+
+      #: () -> Hash[Integer, Hash[Symbol, [:shift, Integer] | [:reduce, Integer?] | [:accept]]]
+      def action_table_index
+        {} #: Hash[Integer, Hash[Symbol, [:shift, Integer] | [:reduce, Integer?] | [:accept]]]
+      end
+
+      #: () -> Array[Grammar::TerminalSymbol]
+      def token_terminals
+        grammar.terminals.values.reject do |terminal|
+          terminal.name == Grammar::Grammar::END_OF_INPUT
+        end
+      end
+
+      #: () -> String
+      def action_cases
+        grammar.productions.map { |production| action_case_for(production) }.join("\n")
+      end
+
+      #: (Grammar::Production) -> String
+      def action_case_for(production)
+        "      when #{production.id} then #{action_body_for(production)}"
+      end
+
+      #: (Grammar::Production) -> String
+      def action_body_for(production)
+        source = normalize_action_source(production.action_source)
+        return "default_semantic_action(args)" unless source
+
+        "(#{source}).call(*args)"
+      end
+
+      #: (String?) -> String?
+      def normalize_action_source(source)
+        return nil unless source
+        return source if source.lstrip.start_with?("lambda", "->", "proc")
+
+        "proc { #{source} }"
+      end
+    end
+  end
+end