red_quilt 0.6.1

data/lib/red_quilt/blockquote.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  # CommonMark spec 5.1 blockquotes.
+  #
+  # Module-level functions are stateless helpers used by BlockParser's
+  # predicate dispatch. `Blockquote::Parser` is a cached collaborator
+  # created once in BlockParser#initialize and reused for every
+  # blockquote (including nested ones) — per-call state lives in method
+  # locals so reentrant `#parse` calls are safe.
+  module Blockquote
+    BLOCKQUOTE_PREFIX_RE = /\A {0,3}>/
+
+    module_function
+
+    def match?(text)
+      text.match?(BLOCKQUOTE_PREFIX_RE)
+    end
+
+    # Strip the leading `>` (and at most one column of whitespace after
+    # it) from a blockquote line. Returns a new Line whose
+    # content is the inner text. If the line has no `>` prefix, the
+    # original line is returned unchanged (wrapped in a fresh Line so
+    # the caller treats it uniformly).
+    def strip_prefix(line)
+      content = line.content
+      bytes = content.bytesize
+      i = 0
+      abs_col = 0
+      # Up to 3 spaces of indent before `>`.
+      while i < 3 && i < bytes && content.getbyte(i) == 0x20
+        i += 1
+        abs_col += 1
+      end
+      unless i < bytes && content.getbyte(i) == 0x3E
+        return Line.new(content, line.start_byte, line.end_byte, !content.match?(/\S/))
+      end
+
+      i += 1
+      abs_col += 1 # consume `>`
+
+      # Count column width of leading whitespace after `>` using
+      # absolute-column tracking so a tab right after `>` (at col 1) is
+      # correctly billed as only 3 columns of indent, not 4.
+      ws_start_col = abs_col
+      j = i
+      while j < bytes
+        b = content.getbyte(j)
+        if b == 0x20
+          abs_col += 1
+        elsif b == 0x09
+          abs_col = ((abs_col / 4) + 1) * 4
+        else
+          break
+        end
+        j += 1
+      end
+      ws_cols = abs_col - ws_start_col
+
+      if ws_cols >= 1
+        tail = (" " * (ws_cols - 1)) + content.byteslice(j..)
+        offset = j
+      else
+        tail = content.byteslice(i..)
+        offset = i
+      end
+
+      Line.new(tail, line.start_byte + offset, line.end_byte, !tail.match?(/\S/))
+    end
+
+    class Parser
+      def initialize(block_parser)
+        @block_parser = block_parser
+        @arena = block_parser.arena
+      end
+
+      def parse(parent_id, lines, index)
+        block_lines = []
+        paragraph_open = false
+
+        while index < lines.length
+          line = lines[index]
+
+          if line.blank
+            # Blank line outside the blockquote prefix closes it.
+            break
+          elsif Blockquote.match?(line.content)
+            stripped = Blockquote.strip_prefix(line)
+            paragraph_open =
+              if stripped.content.strip.empty?
+                false # `>` 単独 (or `>` followed by blank) ends any open paragraph
+              else
+                # Recurse through any inner blockquote prefixes — an
+                # innermost open paragraph (e.g. `> > > foo` where
+                # `foo` is paragraph-eligible) lets a `>`-less follow-
+                # up line lazily continue it even at the outer level.
+                paragraph_eligible_through_blockquotes?(stripped.content)
+              end
+            block_lines << stripped
+          elsif paragraph_open && !@block_parser.lazy_break?(lines, index)
+            # Lazy continuation: a `>`-less line is absorbed into the
+            # currently open paragraph as long as it doesn't itself
+            # start a new block. Only allowed while the most recent
+            # in-quote line is paragraph-eligible content. The `lazy`
+            # flag prevents the paragraph parser from interpreting
+            # `===` / `---` on such a line as a setext underline.
+            block_lines << Line.new(line.content, line.start_byte, line.end_byte, line.blank, true)
+          else
+            break
+          end
+
+          index += 1
+        end
+
+        block_id = @arena.add_node(NodeType::BLOCKQUOTE,
+                                   source_start: block_lines.first.start_byte,
+                                   source_len: block_lines.last.end_byte - block_lines.first.start_byte)
+        @arena.append_child(parent_id, block_id)
+        @block_parser.parse_lines(block_id, block_lines, transformed: true)
+        index
+      end
+
+      private
+
+      # Like BlockParser#paragraph_eligible_line?, but transparently
+      # peels any number of leading wrapper prefixes (blockquote `>`
+      # and list item markers) to find out whether the innermost block
+      # is still paragraph content. Used so `> > > foo\nbar` and
+      # `> 1. > foo\nbar` both let the unprefixed line lazily continue
+      # the deepest paragraph.
+      def paragraph_eligible_through_blockquotes?(content)
+        c = content
+        loop do
+          if Blockquote.match?(c)
+            m = /\A {0,3}> ?/.match(c)
+            break unless m
+
+            c = c[m[0].length..]
+            return false if c.strip.empty?
+          elsif (li = List.match(c))
+            c = li[:content]
+            return false if c.strip.empty?
+          else
+            break
+          end
+        end
+        @block_parser.paragraph_eligible_line?(c)
+      end
+    end
+  end
+end

data/lib/red_quilt/cli.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RedQuilt
+  # Entry point for the `redquilt` executable. Defined as a module-level
+  # function so tests can drive it without shelling out.
+  #
+  # CLI.run takes an argv-style array and an optional set of IO objects
+  # (stdin / stdout / stderr) for testability. It returns an Integer
+  # exit code: 0 on success, 1 on usage errors.
+  module CLI
+    USAGE = <<~USAGE
+      Usage: redquilt [options] [file]
+
+      Reads Markdown from FILE (or stdin if FILE is omitted) and writes the
+      result to stdout.
+
+      Options:
+    USAGE
+
+    DEFAULTS = {
+      format: :html,
+      allow_html: false,
+      disallow_raw_html: false,
+      extended_autolinks: false,
+      lint: false,
+      diagnostics: false,
+      diagnostics_only: false,
+      standalone: true,
+      auto_title: false,
+      title: nil,
+      lang: "en",
+      css: nil,
+      theme: :default,
+    }.freeze
+
+    THEMES = %i[none default].freeze
+
+    FORMATS = %i[html ast json].freeze
+
+    def self.run(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr)
+      options = parse_options(argv, stderr: stderr)
+      return options if options.is_a?(Integer)
+
+      source = read_source(argv, stdin: stdin, stderr: stderr)
+      return 1 unless source
+
+      doc = RedQuilt.parse(source,
+                           allow_html: options[:allow_html],
+                           disallow_raw_html: options[:disallow_raw_html],
+                           extended_autolinks: options[:extended_autolinks],
+                           lint: options[:lint])
+
+      unless options[:diagnostics_only]
+        case options[:format]
+        when :html
+          stdout.write(render_html(doc, options))
+        when :ast
+          require "pp"
+          PP.pp(doc.to_ast, stdout)
+        when :json
+          stdout.puts doc.to_json
+        end
+      end
+
+      if options[:diagnostics] || options[:diagnostics_only]
+        write_diagnostics(doc.diagnostics, stderr)
+      end
+
+      doc.diagnostics.any? { |d| d.severity == :error } ? 1 : 0
+    end
+
+    def self.parse_options(argv, stderr:)
+      options = DEFAULTS.dup
+      parser = OptionParser.new do |opts|
+        opts.banner = USAGE
+        opts.on("--format FORMAT", FORMATS, "Output format: html (default), ast, json") do |f|
+          options[:format] = f
+        end
+        opts.on("--allow-html", "Pass raw HTML through to the output") do
+          options[:allow_html] = true
+        end
+        opts.on("--disallow-raw-html",
+                "Filter dangerous tags (script, iframe, ...) even with --allow-html (GFM)") do
+          options[:disallow_raw_html] = true
+        end
+        opts.on("--extended-autolinks",
+                "Linkify bare URLs and email addresses (GFM)") do
+          options[:extended_autolinks] = true
+        end
+        opts.on("--lint",
+                "Emit lint-style diagnostics (empty_link, missing_alt, heading_level_skip)") do
+          options[:lint] = true
+        end
+        opts.on("--[no-]standalone",
+                "Wrap (or not) the rendered HTML in a full document (default: on)") do |v|
+          options[:standalone] = v
+        end
+        opts.on("--auto-title",
+                "Use the first heading's text as <title> (standalone only)") do
+          options[:auto_title] = true
+        end
+        opts.on("--title TITLE", "Explicit <title> text (standalone only)") do |t|
+          options[:title] = t
+        end
+        opts.on("--lang LANG", "html lang attribute (standalone only; default \"en\")") do |l|
+          options[:lang] = l
+        end
+        opts.on("--css URL", "Add a stylesheet link (standalone only)") do |u|
+          options[:css] = u
+        end
+        opts.on("--theme THEME", THEMES,
+                "Embedded stylesheet: default (the default) or none (bare HTML)") do |t|
+          options[:theme] = t
+        end
+        opts.on("--diagnostics", "Also print diagnostics to stderr") do
+          options[:diagnostics] = true
+        end
+        opts.on("--diagnostics-only", "Print diagnostics only (suppress normal output)") do
+          options[:diagnostics_only] = true
+        end
+        opts.on("-h", "--help", "Show this help") do
+          stderr.puts opts
+          return 0
+        end
+        opts.on("-v", "--version", "Show version") do
+          stderr.puts "redquilt #{RedQuilt::VERSION}"
+          return 0
+        end
+      end
+
+      begin
+        parser.parse!(argv)
+      rescue OptionParser::ParseError => e
+        stderr.puts "redquilt: #{e.message}"
+        stderr.puts parser
+        return 1
+      end
+
+      options
+    end
+
+    def self.read_source(argv, stdin:, stderr:)
+      if argv.empty?
+        stdin.read
+      elsif argv.size == 1
+        path = argv.first
+        unless File.file?(path)
+          stderr.puts "redquilt: no such file: #{path}"
+          return nil
+        end
+        File.read(path)
+      else
+        stderr.puts "redquilt: too many arguments: #{argv.inspect}"
+        nil
+      end
+    end
+
+    def self.render_html(doc, options)
+      title = options[:title]
+      title = doc.first_heading_text.to_s if title.nil? && options[:auto_title]
+      doc.to_html(
+        standalone: options[:standalone],
+        title: title,
+        lang: options[:lang],
+        css: options[:css],
+        theme: options[:theme],
+      )
+    end
+
+    def self.write_diagnostics(diagnostics, stderr)
+      if diagnostics.empty?
+        stderr.puts "redquilt: no diagnostics"
+        return
+      end
+      diagnostics.each do |d|
+        stderr.puts "[#{d.severity}] #{d.rule}: #{d.message}"
+      end
+    end
+  end
+end

data/lib/red_quilt/diagnostic.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  # A single warning / error raised while parsing or rendering a
+  # document. Diagnostics are collected on the Document and never
+  # interrupt processing — every parse / render call still produces a
+  # tree and HTML, even if it emitted diagnostics along the way.
+  #
+  # severity: :info / :warning / :error
+  # rule:     a short Symbol identifying the rule (e.g. :unsafe_url,
+  #           :missing_reference) so callers can filter / silence
+  # message:  human-readable explanation
+  # source_span: optional SourceSpan, points at the offending byte range
+  class Diagnostic
+    SEVERITIES = %i[info warning error].freeze
+
+    attr_reader :severity, :rule, :message, :source_span
+
+    def initialize(severity:, rule:, message:, source_span: nil)
+      unless SEVERITIES.include?(severity)
+        raise ArgumentError, "unknown severity: #{severity.inspect}"
+      end
+
+      @severity = severity
+      @rule = rule
+      @message = message
+      @source_span = source_span
+    end
+
+    def to_h
+      {
+        severity: severity,
+        rule: rule,
+        message: message,
+        source_span: source_span && { start_byte: source_span.start_byte, end_byte: source_span.end_byte },
+      }
+    end
+
+    def ==(other)
+      other.is_a?(Diagnostic) &&
+        other.severity == severity &&
+        other.rule == rule &&
+        other.message == message &&
+        other.source_span == source_span
+    end
+  end
+end

data/lib/red_quilt/document.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  class Document
+    attr_reader :source, :arena, :root_id, :references, :footnotes
+
+    def initialize(source, arena, root_id, allow_html: false, disallow_raw_html: false, references: {}, footnotes: nil)
+      @source = source
+      @arena = arena
+      @root_id = root_id
+      @allow_html = allow_html
+      @disallow_raw_html = disallow_raw_html
+      @references = references
+      @footnotes = footnotes
+    end
+
+    def allow_html?
+      @allow_html
+    end
+
+    # When true, raw HTML output filters the 9 dangerous tags defined by
+    # GFM's "Disallowed Raw HTML" extension (title, textarea, style, xmp,
+    # iframe, noembed, noframes, script, plaintext) by replacing their
+    # leading `<` with `&lt;`. Only meaningful when allow_html? is true;
+    # when allow_html? is false everything is already escaped.
+    def disallow_raw_html?
+      @disallow_raw_html
+    end
+
+    def root
+      NodeRef.new(self, @root_id)
+    end
+
+    def walk(&)
+      root.walk(&)
+    end
+
+    # Renders the document to HTML.
+    #
+    # standalone: when true, wrap the rendered body in a `<!DOCTYPE html>`
+    #   template with `<head>` (charset / title / optional stylesheet)
+    #   and `<body>`. When false (the default), only the rendered body
+    #   fragment is returned.
+    # title / lang / css / theme: applied only when standalone is true.
+    # theme: a bundled stylesheet to inline (`:none` embeds nothing, keeping
+    #   the bare template; `:default` embeds RedQuilt's default theme). `css`
+    #   (an external stylesheet link) is independent and may be combined.
+    def to_html(standalone: false, title: nil, lang: "en", css: nil, theme: :none)
+      body = Renderer::HTML.new(self).render
+      return body unless standalone
+
+      wrap_standalone_html(body, title: title.to_s, lang: lang.to_s, css: css, theme: Theme.css(theme))
+    end
+
+    def to_ast
+      root.to_h
+    end
+
+    def to_json(*)
+      require "json"
+      JSON.pretty_generate(to_mdast)
+    end
+
+    def to_mdast
+      Renderer::Mdast.new(self).render
+    end
+
+    # Returns the plain-text content of the first HEADING in the
+    # document, or nil if there is no heading. Used by callers (e.g. the
+    # CLI's --auto-title) to derive a document title.
+    def first_heading_text
+      first_heading_text_walk(@root_id)
+    end
+
+    def source_map
+      @source_map ||= SourceMap.new(@source)
+    end
+
+    # Returns the array of diagnostics collected during parse / render.
+    # The array is mutable and shared with the parser / renderer; new
+    # entries appear here without further calls.
+    def diagnostics
+      @diagnostics ||= []
+    end
+
+    private
+
+    def wrap_standalone_html(body, title:, lang:, css:, theme:)
+      out = +"<!DOCTYPE html>\n"
+      out << %(<html lang="#{html_escape_attr(lang)}">\n)
+      out << "<head>\n"
+      out << %(<meta charset="utf-8">\n)
+      out << "<title>#{html_escape_text(title)}</title>\n"
+      out << %(<link rel="stylesheet" href="#{html_escape_attr(css)}">\n) if css
+      out << "<style>\n#{theme}</style>\n" if theme
+      out << "</head>\n<body>\n"
+      out << body
+      out << "</body>\n</html>\n"
+      out
+    end
+
+    def html_escape_text(str)
+      str.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+    end
+
+    def html_escape_attr(str)
+      html_escape_text(str).gsub('"', "&quot;")
+    end
+
+    def first_heading_text_walk(node_id)
+      return nil if node_id == -1
+      if @arena.type(node_id) == NodeType::HEADING
+        return PlainText.from(@arena, node_id)
+      end
+
+      child = @arena.raw_first_child_id(node_id)
+      while child != -1
+        text = first_heading_text_walk(child)
+        return text if text
+
+        child = @arena.raw_next_sibling_id(child)
+      end
+      nil
+    end
+  end
+end

data/lib/red_quilt/extended_autolink_pass.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  # GFM Extended autolinks: rewrites bare URLs (`https://...`,
+  # `http://...`, `ftp://...`, `www....`) and email addresses inside
+  # TEXT nodes into LINK nodes. Runs as an optional pass after the
+  # ordinary inline pipeline, so by then all CommonMark inline structure
+  # (real `<...>` autolinks, code spans, links, ...) is already in place
+  # and protected from rewriting.
+  class ExtendedAutolinkPass
+    URL_RE = %r{
+      (?<![A-Za-z0-9_])
+      (?:https?://|ftp://|www\.)
+      [^\s<>]+
+    }x
+
+    EMAIL_RE = /
+      (?<![A-Za-z0-9._+-])
+      [A-Za-z0-9._+-]+
+      @
+      [A-Za-z0-9](?:[A-Za-z0-9\-_]{0,61}[A-Za-z0-9])?
+      (?:\.[A-Za-z0-9](?:[A-Za-z0-9\-_]{0,61}[A-Za-z0-9])?)+
+    /x
+
+    TRAILING_PUNCT_RE = /[?!.,:*_~]+\z/
+    TRAILING_ENTITY_RE = /&[A-Za-z0-9]+;\z/
+
+    # AST contexts whose TEXT descendants must not be auto-linkified.
+    SKIP_TYPES = [
+      NodeType::LINK,
+      NodeType::IMAGE,
+      NodeType::CODE_SPAN,
+      NodeType::HTML_INLINE,
+      NodeType::CODE_BLOCK,
+      NodeType::HTML_BLOCK,
+    ].freeze
+
+    def initialize(document)
+      @document = document
+      @arena = document.arena
+    end
+
+    def apply
+      walk(@document.root_id)
+    end
+
+    private
+
+    def walk(node_id)
+      return if node_id == -1
+
+      type = @arena.type(node_id)
+      return if SKIP_TYPES.include?(type)
+
+      if type == NodeType::TEXT
+        process_text(node_id)
+        return
+      end
+
+      child = @arena.raw_first_child_id(node_id)
+      while child != -1
+        nxt = @arena.raw_next_sibling_id(child)
+        walk(child)
+        child = nxt
+      end
+    end
+
+    Match = Struct.new(:start, :finish, :label, :dest)
+
+    def process_text(node_id)
+      text = @arena.text(node_id).to_s
+      return if text.empty?
+
+      matches = scan_text(text)
+      return if matches.empty?
+
+      parent = @arena.raw_parent_id(node_id)
+      prev_end = 0
+      matches.each do |m|
+        if m.start > prev_end
+          @arena.insert_before(parent, node_id,
+                               @arena.add_node(NodeType::TEXT, str1: text[prev_end...m.start]))
+        end
+        link_id = @arena.add_node(NodeType::LINK, str1: m.dest)
+        @arena.append_child(link_id,
+                            @arena.add_node(NodeType::TEXT, str1: m.label))
+        @arena.insert_before(parent, node_id, link_id)
+        prev_end = m.finish
+      end
+      if prev_end < text.length
+        @arena.insert_before(parent, node_id,
+                             @arena.add_node(NodeType::TEXT, str1: text[prev_end..]))
+      end
+      @arena.detach(node_id)
+    end
+
+    def scan_text(text)
+      matches = []
+      pos = 0
+      while pos < text.length
+        url_m = URL_RE.match(text, pos)
+        email_m = EMAIL_RE.match(text, pos)
+        m = first_match(url_m, email_m)
+        break unless m
+
+        candidate = m[0]
+        is_email = (m == email_m)
+        trimmed = trim_trailing(candidate, email: is_email)
+        if trimmed.empty? || !valid_domain?(trimmed, email: is_email)
+          pos = m.begin(0) + 1
+          next
+        end
+
+        start = m.begin(0)
+        finish = start + trimmed.length
+        dest = build_destination(trimmed, email: is_email)
+        matches << Match.new(start, finish, trimmed, dest)
+        pos = finish
+      end
+      matches
+    end
+
+    # GFM spec: "If the domain name contains an underscore (_) in its last two
+    # segments, it is invalid." Applies to both URLs and email domains.
+    def valid_domain?(candidate, email:)
+      domain = extract_domain(candidate, email: email)
+      return false if domain.nil? || domain.empty?
+
+      segments = domain.split(".")
+      return false if segments.length < 2
+
+      last_two = segments.last(2)
+      last_two.none? { |seg| seg.include?("_") }
+    end
+
+    def extract_domain(candidate, email:)
+      if email
+        candidate.split("@", 2)[1]
+      elsif candidate.start_with?("www.")
+        host = candidate[4..]
+        host.split("/", 2).first
+      else
+        # https://, http://, ftp://
+        after_scheme = candidate.sub(%r{\A[a-z]+://}, "")
+        after_scheme.split("/", 2).first
+      end
+    end
+
+    def first_match(a, b)
+      return b unless a
+      return a unless b
+
+      a.begin(0) <= b.begin(0) ? a : b
+    end
+
+    def trim_trailing(candidate, email:)
+      loop do
+        before = candidate.length
+        candidate = candidate.sub(TRAILING_PUNCT_RE, "")
+        candidate = strip_excess_close_paren(candidate) unless email
+        if candidate.end_with?(";") && (em = TRAILING_ENTITY_RE.match(candidate))
+          candidate = candidate[0...em.begin(0)]
+        end
+        break candidate if candidate.length == before
+      end
+    end
+
+    def strip_excess_close_paren(s)
+      opens = s.count("(")
+      closes = s.count(")")
+      while closes > opens && s.end_with?(")")
+        s = s[0..-2]
+        closes -= 1
+      end
+      s
+    end
+
+    def build_destination(label, email:)
+      return "mailto:#{label}" if email
+      return "http://#{label}" if label.start_with?("www.")
+
+      label
+    end
+  end
+end