red_quilt 0.6.1

data/lib/red_quilt/renderer/mdast.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  module Renderer
+    # Builds an MDAST-compatible Hash from the document arena.
+    #
+    # MDAST (https://github.com/syntax-tree/mdast) is the unified.js AST
+    # format for Markdown; emitting it lets external tooling (linters,
+    # editor plugins) consume red_quilt output without bespoke adapters.
+    class Mdast
+      MDAST_TYPE_NAMES = {
+        document: "root",
+        paragraph: "paragraph",
+        heading: "heading",
+        thematic_break: "thematicBreak",
+        blockquote: "blockquote",
+        list: "list",
+        list_item: "listItem",
+        code_block: "code",
+        html_block: "html",
+        table: "table",
+        table_row: "tableRow",
+        table_cell: "tableCell",
+        text: "text",
+        softbreak: "break",
+        hardbreak: "break",
+        emphasis: "emphasis",
+        strong: "strong",
+        code_span: "inlineCode",
+        link: "link",
+        image: "image",
+        html_inline: "html",
+        strikethrough: "delete",
+        footnote_reference: "footnoteReference",
+        footnote_definition: "footnoteDefinition",
+      }.freeze
+
+      def initialize(document)
+        @document = document
+        @arena = document.arena
+      end
+
+      def render
+        node(@document.root_id)
+      end
+
+      private
+
+      def node(node_id, parent_spread: false)
+        type_int = @arena.type(node_id)
+        type_sym = NodeType.name_for(type_int)
+
+        result = { "type" => mdast_type_name(type_sym) }
+
+        span = @arena.source_span(node_id)
+        result["position"] = position(span) if span
+
+        case type_int
+        when NodeType::HEADING
+          result["depth"] = @arena.int1(node_id)
+          result["children"] = children(node_id)
+        when NodeType::LIST
+          result["ordered"] = @arena.int1(node_id) == 1
+          tight = @arena.int3(node_id) == 1
+          result["start"] = @arena.int2(node_id) if result["ordered"]
+          result["spread"] = !tight
+          result["children"] = children(node_id, parent_spread: !tight)
+        when NodeType::LIST_ITEM
+          result["spread"] = parent_spread
+          result["children"] = children(node_id)
+        when NodeType::CODE_BLOCK
+          info = @arena.str2(node_id)
+          lang = info && !info.empty? ? info.split.first : nil
+          result["lang"] = lang
+          result["value"] = @arena.text(node_id).to_s
+        when NodeType::TEXT
+          result["value"] = @arena.text(node_id).to_s
+        when NodeType::SOFTBREAK
+          result["type"] = "text"
+          result["value"] = "\n"
+        when NodeType::CODE_SPAN
+          result["value"] = @arena.text(node_id).to_s
+        when NodeType::LINK
+          result["url"] = @arena.str1(node_id).to_s
+          title = @arena.str2(node_id)
+          result["title"] = title && !title.empty? ? title : nil
+          result["children"] = children(node_id)
+        when NodeType::IMAGE
+          result["url"] = @arena.str1(node_id).to_s
+          title = @arena.str2(node_id)
+          result["title"] = title && !title.empty? ? title : nil
+          result["alt"] = NodeRef.new(@document, node_id).text.to_s
+        when NodeType::FOOTNOTE_REFERENCE
+          label = @arena.str1(node_id).to_s
+          result["identifier"] = label
+          result["label"] = label
+        when NodeType::FOOTNOTE_DEFINITION
+          label = @arena.str1(node_id).to_s
+          result["identifier"] = label
+          result["label"] = label
+          result["children"] = children(node_id)
+        when NodeType::HTML_BLOCK, NodeType::HTML_INLINE
+          result["value"] = NodeRef.new(@document, node_id).text.to_s
+        when NodeType::TABLE
+          result["align"] = []
+          result["children"] = children(node_id)
+        when NodeType::DOCUMENT, NodeType::PARAGRAPH, NodeType::BLOCKQUOTE,
+             NodeType::TABLE_ROW, NodeType::TABLE_CELL,
+             NodeType::EMPHASIS, NodeType::STRONG, NodeType::STRIKETHROUGH
+          result["children"] = children(node_id)
+        end
+
+        result
+      end
+
+      def children(node_id, parent_spread: false)
+        result = []
+        @arena.child_ids(node_id).each do |child_id|
+          # mdast has no footnotes-section wrapper: footnote definitions are
+          # plain root-level nodes, so splice the section's children in.
+          if @arena.type(child_id) == NodeType::FOOTNOTES_SECTION
+            @arena.child_ids(child_id).each { |def_id| result << node(def_id, parent_spread: parent_spread) }
+          else
+            result << node(child_id, parent_spread: parent_spread)
+          end
+        end
+        result
+      end
+
+      def position(span)
+        start_loc = @document.source_map.line_column(span.start_byte)
+        end_loc = @document.source_map.line_column(span.end_byte)
+        {
+          "start" => {
+            "line" => start_loc[:line],
+            "column" => start_loc[:column],
+            "offset" => span.start_byte,
+          },
+          "end" => {
+            "line" => end_loc[:line],
+            "column" => end_loc[:column],
+            "offset" => span.end_byte,
+          },
+        }
+      end
+
+      def mdast_type_name(type_sym)
+        MDAST_TYPE_NAMES.fetch(type_sym, type_sym.to_s)
+      end
+    end
+  end
+end

data/lib/red_quilt/source_map.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  class SourceMap
+    def initialize(source)
+      @source = source
+      @line_starts = build_line_starts(source)
+    end
+
+    def line_column(byte_offset)
+      line = (@line_starts.bsearch_index { |s| s > byte_offset } || @line_starts.length) - 1
+      line_start = @line_starts[line]
+      column = @source.byteslice(line_start, byte_offset - line_start).to_s.length
+      { line: line + 1, column: column }
+    end
+
+    private
+
+    def build_line_starts(source)
+      starts = [0]
+      pos = 0
+      while (idx = source.index("\n", pos))
+        starts << (idx + 1)
+        pos = idx + 1
+      end
+      starts
+    end
+  end
+end

data/lib/red_quilt/source_span.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  class SourceSpan
+    attr_reader :start_byte, :end_byte
+
+    def initialize(start_byte, end_byte)
+      @start_byte = start_byte
+      @end_byte = end_byte
+    end
+
+    def length
+      @end_byte - @start_byte
+    end
+
+    def ==(other)
+      other.is_a?(SourceSpan) &&
+        other.start_byte == @start_byte &&
+        other.end_byte == @end_byte
+    end
+
+    def to_h
+      { start_byte: @start_byte, end_byte: @end_byte }
+    end
+  end
+end

data/lib/red_quilt/theme.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  # Optional bundled stylesheets for standalone HTML output. `:none` (the
+  # default) embeds no CSS and leaves the bare document untouched; named
+  # themes load a stylesheet shipped under lib/red_quilt/themes/.
+  module Theme
+    DIR = File.expand_path("themes", __dir__)
+    private_constant :DIR
+
+    # Theme names that embed a bundled stylesheet (excludes :none).
+    NAMES = %i[default].freeze
+
+    module_function
+
+    # Returns the CSS for `name`, or nil for :none / nil (no embedded CSS).
+    # Raises ArgumentError for an unknown name.
+    def css(name)
+      name = (name || :none).to_sym
+      return nil if name == :none
+      unless NAMES.include?(name)
+        raise ArgumentError, "unknown theme #{name.inspect} (available: none, #{NAMES.join(', ')})"
+      end
+
+      (@cache ||= {})[name] ||= File.read(File.join(DIR, "#{name}.css")).freeze
+    end
+  end
+end

data/lib/red_quilt/themes/default.css

@@ -0,0 +1,87 @@
+/* RedQuilt default theme — a compact, readable stylesheet for standalone
+   HTML output. Intentionally minimal: no syntax highlighting, no JS. */
+
+body {
+  max-width: 54rem;
+  margin: 0 auto;
+  padding: 2rem 1rem 4rem;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+  font-size: 16px;
+  line-height: 1.6;
+  color: #1f2328;
+  background: #ffffff;
+  word-wrap: break-word;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 1.6em 0 0.6em;
+  line-height: 1.25;
+  font-weight: 600;
+}
+
+h1 { font-size: 1.9em; }
+h2 { font-size: 1.5em; }
+h3 { font-size: 1.25em; }
+h1, h2 { padding-bottom: 0.3em; border-bottom: 1px solid #d0d7de; }
+
+p, ul, ol, blockquote, table, pre { margin: 0 0 1rem; }
+
+a { color: #0969da; text-decoration: none; }
+a:hover { text-decoration: underline; }
+
+ul, ol { padding-left: 1.6em; }
+li + li { margin-top: 0.2em; }
+
+blockquote {
+  margin-left: 0;
+  padding: 0 1em;
+  color: #59636e;
+  border-left: 0.25em solid #d0d7de;
+}
+
+code {
+  font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
+  font-size: 0.9em;
+  background: #eff1f3;
+  padding: 0.15em 0.35em;
+  border-radius: 4px;
+}
+
+pre {
+  background: #f6f8fa;
+  padding: 1rem;
+  border-radius: 6px;
+  overflow: auto;
+}
+
+pre code { background: none; padding: 0; font-size: 0.875em; }
+
+table { border-collapse: collapse; }
+th, td { padding: 0.4em 0.8em; border: 1px solid #d0d7de; }
+th { background: #f6f8fa; }
+
+hr { height: 1px; margin: 2rem 0; border: 0; background: #d0d7de; }
+
+img { max-width: 100%; }
+
+.footnotes {
+  margin-top: 2.5rem;
+  padding-top: 1rem;
+  font-size: 0.9em;
+  color: #59636e;
+  border-top: 1px solid #d0d7de;
+}
+
+/* Follow the OS / browser preference for dark mode. */
+@media (prefers-color-scheme: dark) {
+  body { color: #e6edf3; background: #0d1117; }
+  a { color: #4493f8; }
+  h1, h2 { border-bottom-color: #30363d; }
+  blockquote { color: #9198a1; border-left-color: #30363d; }
+  code { background: #262c36; }
+  pre { background: #161b22; }
+  th, td { border-color: #30363d; }
+  th { background: #161b22; }
+  hr { background: #30363d; }
+  .footnotes { color: #9198a1; border-top-color: #30363d; }
+}

data/lib/red_quilt/version.rb

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

data/lib/red_quilt.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "red_quilt/version"
+require_relative "red_quilt/node_type"
+require_relative "red_quilt/source_span"
+require_relative "red_quilt/line"
+require_relative "red_quilt/indentation"
+require_relative "red_quilt/source_map"
+require_relative "red_quilt/arena"
+require_relative "red_quilt/node_ref"
+require_relative "red_quilt/diagnostic"
+require_relative "red_quilt/plain_text"
+require_relative "red_quilt/theme"
+require_relative "red_quilt/document"
+require_relative "red_quilt/inline"
+require_relative "red_quilt/inline/html_entities"
+require_relative "red_quilt/reference_definition"
+require_relative "red_quilt/footnote_registry"
+require_relative "red_quilt/footnote_definition"
+require_relative "red_quilt/list"
+require_relative "red_quilt/blockquote"
+require_relative "red_quilt/block_parser"
+require_relative "red_quilt/inline/token_kind"
+require_relative "red_quilt/inline/tokens"
+require_relative "red_quilt/inline/flanking"
+require_relative "red_quilt/inline/lexer"
+require_relative "red_quilt/inline/link_scanner"
+require_relative "red_quilt/inline/builder"
+require_relative "red_quilt/inline_pass"
+require_relative "red_quilt/footnote_pass"
+require_relative "red_quilt/extended_autolink_pass"
+require_relative "red_quilt/lint_pass"
+require_relative "red_quilt/renderer/html"
+require_relative "red_quilt/renderer/mdast"
+
+module RedQuilt
+  class Error < StandardError; end
+
+  class << self
+    def parse(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false)
+      normalized = normalize_input(source)
+      arena = Arena.new(normalized)
+      footnote_registry = FootnoteRegistry.new if footnotes
+      block_parser = BlockParser.new(arena, footnotes: footnote_registry)
+      root_id = block_parser.parse
+      document = Document.new(normalized, arena, root_id,
+                              allow_html: allow_html,
+                              disallow_raw_html: disallow_raw_html,
+                              references: block_parser.references,
+                              footnotes: footnote_registry)
+      document.diagnostics.concat(block_parser.diagnostics)
+      InlinePass.new(document).apply
+      FootnotePass.new(document).apply if footnote_registry
+      ExtendedAutolinkPass.new(document).apply if extended_autolinks
+      LintPass.new(document).apply if lint
+      document
+    end
+
+    def render_html(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false)
+      parse(source,
+            allow_html: allow_html,
+            disallow_raw_html: disallow_raw_html,
+            extended_autolinks: extended_autolinks,
+            footnotes: footnotes,
+            lint: lint).to_html
+    end
+
+    private
+
+    NUL_CHAR = 0.chr
+    REPLACEMENT_CHAR = 0xFFFD.chr(Encoding::UTF_8)
+    private_constant :NUL_CHAR, :REPLACEMENT_CHAR
+
+    # CommonMark normalization applied before parsing:
+    # - line endings: \r\n and lone \r -> \n (spec defines all three as line endings)
+    # - NUL (U+0000) -> U+FFFD (spec requires this replacement for security)
+    def normalize_input(source)
+      # Both substitutions rewrite the whole document, so skip each scan
+      # (and its full-string copy) when the trigger byte is absent -- the
+      # common case is LF-only text with no NUL.
+      source = source.gsub(/\r\n?/, "\n") if source.include?("\r")
+      source = source.gsub(NUL_CHAR, REPLACEMENT_CHAR) if source.include?(NUL_CHAR)
+      source
+    end
+  end
+end

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "4.0.5"

data/sig/red_quilt.rbs

@@ -0,0 +1,45 @@
+module RedQuilt
+  VERSION: String
+
+  def self.parse: (String source, ?allow_html: bool) -> Document
+  def self.render_html: (String source, ?allow_html: bool) -> String
+
+  class Document
+    attr_reader source: String
+    attr_reader arena: Arena
+    attr_reader root_id: Integer
+
+    def root: () -> NodeRef
+    def to_html: () -> String
+    def to_ast: () -> Hash[Symbol, untyped]
+    def allow_html?: () -> bool
+    def source_map: () -> SourceMap
+  end
+
+  class NodeRef
+    include Enumerable[NodeRef]
+
+    attr_reader document: Document
+    attr_reader node_id: Integer
+
+    def type: () -> Symbol
+    def children: () -> Array[NodeRef]
+    def walk: () { (NodeRef) -> void } -> void
+    def walk: () -> Enumerator[NodeRef, void]
+    def find_all: (Symbol type) -> Array[NodeRef]
+    def to_h: () -> Hash[Symbol, untyped]
+    def text: () -> String?
+    def source_span: () -> SourceSpan?
+    def source_location: () -> { start_line: Integer, start_column: Integer, end_line: Integer, end_column: Integer }?
+  end
+
+  class Arena
+  end
+
+  class SourceMap
+    def initialize: (String source) -> void
+    def line_column: (Integer byte_offset) -> { line: Integer, column: Integer }
+  end
+
+  SourceSpan = Data[Integer, Integer]
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: red_quilt
+version: !ruby/object:Gem::Version
+  version: 0.6.1
+platform: ruby
+authors:
+- takahashim
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A modern Markdown document processor in pure Ruby, with an arena-style
+  AST and full CommonMark spec test suite compliance.
+email:
+- takahashimm@gmail.com
+executables:
+- redquilt
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- CHANGELOG.md
+- README.md
+- Rakefile
+- ast-spec.md
+- docs/architecture.md
+- docs/arena-usage.md
+- docs/commonmark-conformance.md
+- exe/redquilt
+- lib/red_quilt.rb
+- lib/red_quilt/arena.rb
+- lib/red_quilt/block_parser.rb
+- lib/red_quilt/blockquote.rb
+- lib/red_quilt/cli.rb
+- lib/red_quilt/diagnostic.rb
+- lib/red_quilt/document.rb
+- lib/red_quilt/extended_autolink_pass.rb
+- lib/red_quilt/footnote_definition.rb
+- lib/red_quilt/footnote_pass.rb
+- lib/red_quilt/footnote_registry.rb
+- lib/red_quilt/indentation.rb
+- lib/red_quilt/inline.rb
+- lib/red_quilt/inline/builder.rb
+- lib/red_quilt/inline/flanking.rb
+- lib/red_quilt/inline/html_entities.rb
+- lib/red_quilt/inline/lexer.rb
+- lib/red_quilt/inline/link_scanner.rb
+- lib/red_quilt/inline/token_kind.rb
+- lib/red_quilt/inline/tokens.rb
+- lib/red_quilt/inline_pass.rb
+- lib/red_quilt/line.rb
+- lib/red_quilt/lint_pass.rb
+- lib/red_quilt/list.rb
+- lib/red_quilt/node_ref.rb
+- lib/red_quilt/node_type.rb
+- lib/red_quilt/plain_text.rb
+- lib/red_quilt/reference_definition.rb
+- lib/red_quilt/renderer/html.rb
+- lib/red_quilt/renderer/mdast.rb
+- lib/red_quilt/source_map.rb
+- lib/red_quilt/source_span.rb
+- lib/red_quilt/theme.rb
+- lib/red_quilt/themes/default.css
+- lib/red_quilt/version.rb
+- mise.toml
+- sig/red_quilt.rbs
+homepage: https://github.com/takahashim/red_quilt
+licenses: []
+metadata:
+  homepage_uri: https://github.com/takahashim/red_quilt
+  source_code_uri: https://github.com/takahashim/red_quilt
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: CommonMark-based Markdown processor written in pure Ruby
+test_files: []