rouge-carve 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbeb1c2fa0f572f138c6a89a23bafcae682051c9e10474951b5cba9de3bc0aa3
+  data.tar.gz: 7d089e544a959be5c208ef4e1cc523feda2b1d8cf6632b99086ae41c5cb13c31
+SHA512:
+  metadata.gz: 439cc10aa425adaec2fed2e19e6af9aab75ffec47b699c3a3dff0632ee2503ca6240d7d4f869db0c93f907fee29f43b351ba9a507f89cff5b0a3a11ddb257e72
+  data.tar.gz: b93c04c6c832959f1a58e238efb161b5d6a7283b104cec5deae971e62065f18b8bf88abf03fc61fdf7cc29da54bac7d3cddaa384f267c7e6e91478cd124f8a59

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## [0.1.0] - 2026-08-27
+
+First release.
+
+- Every Carve construct: headings, containers, fenced and raw blocks, tables
+  with alignment and per-row attributes, definition lists, footnotes,
+  citations, cross-references, attribute blocks, task items, critic markup,
+  symbol shortcodes, mentions, tags and typographic runs.
+- Fenced code is delegated to a lexer for its declared language; a `=FORMAT`
+  raw block stays opaque, because a format is not a language.
+- Fence widths are closed over per block, so a shorter inner fence does not
+  end a wider one.
+- Input preservation is gated: concatenating the token values reproduces the
+  source exactly, checked over every document in the Carve corpus.
+- Construct parity with the sibling grammars is gated against the same
+  inventory the highlight.js definition answers to.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Scherer and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# rouge-carve
+
+A [Rouge](https://github.com/rouge-ruby/rouge) lexer for the
+[Carve](https://markup-carve.github.io/carve/) markup language.
+
+```bash
+gem install rouge-carve
+```
+
+```ruby
+require 'rouge-carve'
+
+Rouge::Lexer.find('carve')                    # => Rouge::Lexers::Carve
+Rouge::Lexer.guess(filename: 'notes.crv')     # => Rouge::Lexers::Carve
+```
+
+Requiring the gem registers the lexer. Anything that already highlights with
+Rouge - GitLab, Jekyll, Redcarpet, most Ruby static site generators - then
+handles `.crv` and `.carve` files, and ` ```carve ` fenced blocks, without
+further configuration.
+
+## Why not just use the Markdown lexer
+
+Because it is not close enough to be wrong quietly. Carve deliberately changed
+the delimiters Markdown got backwards, and three of them **invert**:
+
+| Carve | means | Markdown reads it as |
+| --- | --- | --- |
+| `*bold*` | strong | emphasis |
+| `/italic/` | emphasis | literal slashes |
+| `_under_` | underline | emphasis |
+| `~strike~` | strikethrough | subscript, or literal |
+| `{=mark=}` | highlight | literal braces |
+| `{^sup^}` | superscript | literal braces |
+
+Highlighting a Carve document as Markdown does not degrade to plain text. It
+shows bold where the author wrote emphasis.
+
+## What it covers
+
+Every construct in the language: headings, containers (`::: note`), fenced and
+raw blocks, tables with alignment and per-row attributes, definition lists,
+footnotes, citations, cross-references, attribute blocks, task items, critic
+markup, symbol shortcodes, mentions, tags and the typographic runs.
+
+**Fenced code is delegated.** A ` ```ruby ` block inside a `.crv` file is lexed
+as Ruby, because that is what a reader expects. A ` ```=html ` raw block is not:
+its info string names an output format, not a language, so the payload stays
+opaque.
+
+**Fence widths are respected.** A three-backtick line inside a four-backtick
+fence is content, not a closer. The width is closed over per block rather than
+approximated, which the sibling grammars in other ecosystems cannot do.
+
+## What it cannot say
+
+Rouge has no underline token - the vocabulary stops at `Generic::Emph`,
+`Generic::Strong` and `Generic::EmphStrong`. Carve's `_x_` is underline, so its
+content shares `Generic::Emph` with italic. The delimiters stay `Punctuation`,
+so a consumer can still tell the two apart by the delimiter each carries.
+
+Block openers are matched at any indent. Carve opens a block at column 0 or at
+an enclosing container's content column and nowhere in between, which needs a
+container model this lexer does not carry. The trade-off is deliberate and
+shared with the Prism, highlight.js and Pygments grammars, so the four agree:
+it over-colours an indented-at-document-level opener rather than
+under-colouring the far more common indented construct inside a list item.
+
+## Testing
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+Two gates, and the second is the one that finds things:
+
+- `spec/carve_spec.rb` pins the constructs, including each inverted delimiter.
+- `script/corpus_check.rb` lexes every `.crv` document in the Carve spec
+  repository and fails on a single `Error` token. A lexer emitting `Error` is
+  telling the reader its own rules ran out. Both bugs found during development -
+  a blank line inside a comment fence, and a `---` thematic break opening
+  frontmatter that never closed - came from this and not from an example
+  anybody thought to write.
+
+## Related
+
+- [carve](https://github.com/markup-carve/carve) - the language and its spec
+- [pygments-carve](https://github.com/markup-carve/pygments-carve) - the same
+  grammar for Pygments, which this was ported from
+- [carve-grammars](https://github.com/markup-carve/carve-grammars) - TextMate,
+  Prism and highlight.js
+- [carve-css](https://github.com/markup-carve/carve-css) - styles for the HTML
+  Carve renders
+
+## License
+
+MIT.

data/lib/rouge/demos/carve

@@ -0,0 +1,35 @@
+---
+title: Carve
+---
+
+{#intro}
+# Styling a document
+
+Carve swaps the delimiters Markdown got wrong: *bold* is one asterisk,
+/italic/ is a slash, and _underline_ finally has a spelling of its own.
+Sub and sup are braced-only, so H{,2,}O and E = mc{^2^} are unambiguous.
+
+{.lead}
+An attribute line binds an id, classes and `data-*` to the block below it.
+
+- A bullet, with `code` and a [link](https://markup-carve.github.io/carve/)
+- A task item is marked inline
+- [x] and it carries its own state
+
+::: note "Containers are core syntax"
+A word with no registered handler renders as a generic div, which is what
+makes a whole family of constructs possible without touching the parser.
+:::
+
+``` ruby "example.rb"
+def greet(name) = "Hello, #{name}!"
+```
+
+|= Engine   |= Status |
+| carve-js   | shipped |
+| carve-rs   | shipped |
+
+^ Table 1: the reference implementations.
+
+See </#intro> for the opening, cite [@knuth1984] for the argument, and
+%% this trailing comment never reaches the output.

data/lib/rouge/lexers/carve.rb

@@ -0,0 +1,586 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # Carve is a post-Markdown lightweight markup language. Its inline
+    # delimiters deliberately differ from Markdown's, which is why lexing a
+    # Carve document as Markdown produces actively WRONG output rather than
+    # merely plain text:
+    #
+    #   Carve        means            Markdown would read it as
+    #   ---------    -------------    -------------------------
+    #   *bold*       strong           emphasis
+    #   /italic/     emphasis         literal slashes
+    #   _under_      underline        emphasis
+    #   ~strike~     strikethrough    subscript / literal
+    #   {=mark=}     highlight        literal braces
+    #   {^sup^}      superscript      literal braces
+    #
+    # WHY THE BLOCK OPENERS ARE NOT ANCHORED AT COLUMN 0. Carve opens a block at
+    # column 0, or at an enclosing container's content column - nowhere in
+    # between. So `  # H` at document level is a paragraph, while the same
+    # opener at a list item's content column is a real heading. Telling those
+    # apart needs a container model that tracks the item's content column. A
+    # regex lexer's state stack could carry one, but the sibling grammars
+    # (Prism, highlight.js, Pygments) do not, and this lexer keeps their
+    # trade-off on purpose so they agree: block openers match at any indent and
+    # knowingly over-colour the rare indented-at-document-level case, rather
+    # than under-colouring the common valid shape of an indented construct
+    # inside a list item.
+    #
+    # WHY AN ATTRIBUTE BLOCK IS ONE TOKEN. `{#id .cls key="v" :lang}` is emitted
+    # whole as Name::Attribute rather than split into id, class, key, value and
+    # language parts. Splitting reads better in isolation, but an attribute
+    # block can carry a brace inside a quoted value, a language tag, and a bare
+    # key that is not an attribute at all, and the sibling grammars treat the
+    # block as one unit; a consumer asking "is this text inside an attribute
+    # block" must get the same answer here as it does there.
+    #
+    # WHERE ROUGE CANNOT SAY WHAT CARVE MEANS. Carve's `_x_` is UNDERLINE, not
+    # emphasis, and Rouge has no underline token - the vocabulary stops at
+    # Generic::Emph, Generic::Strong and Generic::EmphStrong. The content takes
+    # Generic::Emph so it is at least marked up, and the delimiters stay
+    # Punctuation so a consumer can still tell underline from italic by the
+    # delimiter it carries. Pygments, which has Generic.Underline, does make
+    # the distinction.
+    #
+    # Spec: https://markup-carve.github.io/carve/
+    class Carve < RegexLexer
+      title 'Carve'
+      desc 'Carve, a post-Markdown lightweight markup language'
+
+      tag 'carve'
+      aliases 'crv'
+      filenames '*.crv', '*.carve'
+      mimetypes 'text/x-carve'
+
+      # A leading margin. A byte order mark at the start of a document is not
+      # content, so a block opener behind one is still a block opener.
+      MARGIN = /[ \t]*/.freeze
+
+      # One attribute block, brace to brace. Quoted values may contain a brace
+      # and an escaped quote, so the value alternatives come before the
+      # bare-character one; a single nested brace pair is allowed for a braced
+      # span written inside.
+      ATTRS = %r/
+        \{(?=[.:}'"]|\#[\w-]+[\s}]|[A-Za-z][\w-]*(?:[=\s}]|$))(?:
+          "(?:[^"\\\n]|\\.)*"
+          |'(?:[^'\\\n]|\\.)*'
+          |\{[^{}\n]*\}
+          |[^{}\n]
+        )*\}
+      /x.freeze
+
+      # The same block as a STANDALONE ATTRIBUTE LINE, which may span lines.
+      # The inline form deliberately cannot, because an unclosed inline `{`
+      # would otherwise swallow the rest of the document.
+      ATTRS_LINE = %r/
+        \{(?=[.:}'"]|\#[\w-]+[\s}]|[A-Za-z][\w-]*(?:[=\s}]|$))(?:
+          "(?:[^"\\]|\\.)*"
+          |'(?:[^'\\]|\\.)*'
+          |\{[^{}]*\}
+          |[^{}]
+        )*\}
+      /x.freeze
+
+      # A bracketed label that may itself contain three levels of brackets. A
+      # regex cannot match arbitrarily balanced brackets, and a link label in
+      # practice nests a level or two (`[t[z]](/u)`). Bounding the nesting keeps
+      # the common shapes matching instead of stopping at the first inner
+      # bracket, which is what a naive \[[^\]]*\] does.
+      LABEL = begin
+        inner = '[^\[\]\\\\\n]|\\\\.'
+        pattern = "(?:#{inner})*"
+        3.times { pattern = "(?:#{inner}|\\[#{pattern}\\])*" }
+        Regexp.new("\\[#{pattern}\\]").freeze
+      end
+
+      # Characters that can begin an inline construct. A run of anything else is
+      # ordinary content and is emitted as ONE token - without this every
+      # content character becomes its own token, which is both noisy and
+      # unusable to a consumer asking whether a phrase carries a scope.
+      INLINE_STARTERS = '\\\\%!`${\\[\\^<:@\\#*\\/_~=.\\-'
+
+      # A run of content characters, excluding +extra+ as well.
+      def self.plain_run(extra = '')
+        Regexp.new("[^\n#{INLINE_STARTERS}#{extra}]+")
+      end
+
+      PLAIN = plain_run.freeze
+      PLAIN_NO_PIPE = plain_run('|').freeze
+      PLAIN_NO_BRACKET = plain_run('\\]').freeze
+
+      state :root do
+        mixin :block
+      end
+
+      # ------------------------------------------------------------------
+      # Block level
+      # ------------------------------------------------------------------
+      state :block do
+        # Front matter, only at the very start of the document. \A is what
+        # keeps a `---yaml` line mid-document from opening one.
+        rule %r/\A(?)(---)([a-zA-Z][\w-]*)?([ \t]*\n)(?=[\s\S]*?^---[ \t]*$)/ do
+          groups Text, Punctuation, Keyword::Type, Text
+          push :frontmatter
+        end
+
+        # A comment fence (%%% or longer) versus a one-line comment. The fence
+        # has to be tried first: %%% also matches the one-line form.
+        rule %r/^(#{MARGIN})(%%%+)([^\n]*)(\n)/ do
+          groups Text, Comment::Preproc, Comment, Text
+          push :commentfence
+        end
+        rule %r/^(#{MARGIN})(%%)([^\n]*)$/ do
+          groups Text, Comment::Preproc, Comment
+        end
+
+        # A raw block: the `=FORMAT` info string routes the payload to that
+        # output format verbatim. Emitted as one token including the `=`,
+        # because the format word without its sigil is not the construct. The
+        # payload is never a language, so it is never delegated.
+        rule %r/^(#{MARGIN})(`{3,}|~{3,})([ \t]*)(=[a-zA-Z][\w+.-]*)([^\n]*)/ do |m|
+          groups Text, Punctuation, Text, Keyword::Type
+          token Text, m[5]
+          push_fence(m[2], nil)
+        end
+
+        # A code fence. The first word of the info string names a language, and
+        # a lexer for it highlights the payload - the one place this lexer
+        # looks past Carve, because a reader of a `.crv` file expects an
+        # embedded PHP sample to look like PHP.
+        rule %r/^(#{MARGIN})(`{3,}|~{3,})([ \t]*)([a-zA-Z][\w+#.-]*)?([^\n]*)/ do |m|
+          groups Text, Punctuation, Text, Name::Builtin
+          lex_info_string(m[5])
+          push_fence(m[2], m[4])
+        end
+
+        # Container divs. A reserved kind word (note, tip, figure, ...) names a
+        # known container; `:::` followed by `|` is the layout form.
+        rule %r/^(#{MARGIN})(:{3,})([ \t]*)(\|)/ do
+          groups Text, Punctuation, Text, Operator
+        end
+        rule %r/^(#{MARGIN})(:{3,})([ \t]*)([a-zA-Z][\w-]*)?([^\n]*)/ do |m|
+          groups Text, Punctuation, Text, Keyword::Namespace
+          lex_info_string(m[5])
+        end
+
+        # A caption line attaches to the block above or below it.
+        rule %r/^(#{MARGIN})(\^)([ \t]+)/ do
+          groups Text, Punctuation, Text
+          push :caption
+        end
+
+        # Headings. Carve has no setext form, so a `#` run is the only spelling
+        # and a trailing `{...}` is NOT an attribute block here.
+        rule %r/^(#{MARGIN})(\#{1,6})([ \t]+)/ do
+          groups Text, Punctuation, Text
+          push :heading
+        end
+
+        # Thematic breaks, before the list rules so `---` is not a bullet.
+        rule %r/^#{MARGIN}(?:\*[ \t]*){3,}$/, Punctuation
+        rule %r/^#{MARGIN}(?:-[ \t]*){3,}$/, Punctuation
+        rule %r/^#{MARGIN}(?:_[ \t]*){3,}$/, Punctuation
+
+        # Definition markers: footnote, link reference, abbreviation. The
+        # separator after the colon must START WITH A LITERAL SPACE - a
+        # tab-first separator makes the line an ordinary paragraph.
+        rule %r/^(#{MARGIN})(\[\^)([^\]\n]+)(\]:)( )/ do
+          groups Text, Punctuation, Name::Label, Punctuation, Text
+          push :inline
+        end
+        rule %r/^(#{MARGIN})(\*\[)([^\]\n]+)(\]:)( )/ do
+          groups Text, Punctuation, Name::Entity, Punctuation, Text
+          push :inline
+        end
+        rule %r/^(#{MARGIN})(\[)([^\]\n]+)(\]:)( )/ do
+          groups Text, Punctuation, Name::Label, Punctuation, Text
+          push :linkdest
+        end
+
+        # A definition-list term (`::`) and its definition (`:`).
+        rule %r/^(#{MARGIN})(::)([ \t]+)/ do
+          groups Text, Punctuation, Text
+          push :heading
+        end
+        rule %r/^(#{MARGIN})(:)(?=[ \t])/ do
+          groups Text, Punctuation
+        end
+
+        # A blockquote marker must be followed by a space or end the line;
+        # `>foo` is a paragraph.
+        rule %r/^(#{MARGIN})(>+)(?=[ \t]|$)/ do
+          groups Text, Punctuation
+          push :quoteline
+        end
+
+        # Task items before plain bullets, so the state marker is its own
+        # token. The state is any single character, not only a space or an x:
+        # `[>]` is deferred and `[-]` is dropped.
+        rule %r/^(#{MARGIN})((?:[-*+]|\d+[.)]|[A-Za-z]+[.)])(?:#{ATTRS})?)([ \t]+)(\[[^\]\n]\])/ do
+          groups Text, Punctuation, Text, Name::Constant
+        end
+
+        # Bullets. A run of markers on one line opens nested lists at once
+        # (`- - A`), and attributes may be glued straight onto the marker.
+        rule %r/^(#{MARGIN})((?:[-*+][ \t]+)*[-*+](?:#{ATTRS})?)(?=[ \t]|$)/ do
+          groups Text, Punctuation
+        end
+
+        # Ordered markers: numeric, alphabetic, roman, and the bare `.` that
+        # continues the enclosing sequence.
+        rule %r/^(#{MARGIN})((?:\d+|[A-Za-z]+)[.)](?:#{ATTRS})?)(?=[ \t]|$)/ do
+          groups Text, Num::Integer
+        end
+        rule %r/^(#{MARGIN})(\.(?:#{ATTRS})?)(?=[ \t]|$)/ do
+          groups Text, Num::Integer
+        end
+
+        # Tables. The header marker, the alignment run and the separator row
+        # are their own tokens; cell content is lexed inline.
+        rule %r/^(#{MARGIN})(\|=[<>^v~]*)/ do
+          groups Text, Operator
+          push :tablerow
+        end
+        rule %r/^(#{MARGIN})(\|)/ do
+          groups Text, Punctuation
+          push :tablerow
+        end
+
+        # A standalone attribute block, which may span lines.
+        rule %r/^(#{MARGIN})(#{ATTRS_LINE})/ do
+          groups Text, Name::Attribute
+        end
+
+        mixin :inline
+      end
+
+      state :frontmatter do
+        rule %r/^(---)([ \t]*)$/ do
+          groups Punctuation, Text
+          pop!
+        end
+        rule %r/\n/, Comment::Special
+        rule %r/[^\n]+\n?/, Comment::Special
+      end
+
+      state :commentfence do
+        rule %r/^([ \t]*)(%%%+)([ \t]*)$/ do
+          groups Text, Comment::Preproc, Text
+          pop!
+        end
+        rule %r/\n/, Comment
+        rule %r/[^\n]+\n?/, Comment
+      end
+
+      state :heading do
+        rule %r/$/, Text, :pop!
+        mixin :inlinecontent
+        rule PLAIN, Generic::Heading
+        rule %r/[^\n]/, Generic::Heading
+      end
+
+      state :quoteline do
+        rule %r/$/, Text, :pop!
+        mixin :inlinecontent
+        rule PLAIN, Generic::Emph
+        rule %r/[^\n]/, Generic::Emph
+      end
+
+      state :caption do
+        rule %r/$/, Text, :pop!
+        mixin :inlinecontent
+        rule PLAIN, Generic::Subheading
+        rule %r/[^\n]/, Generic::Subheading
+      end
+
+      state :tablerow do
+        rule %r/$/, Text, :pop!
+        # A header cell marker, optionally carrying an alignment run. The pipe
+        # is part of it, so `|=` reads as one construct.
+        rule %r/\|=[<>^v~]*/, Operator
+        # A separator row cell, in the native and the GFM spelling.
+        rule %r/(?<=\|)[ \t]*:?-{2,}:?[ \t]*(?=\|)/, Punctuation
+        rule %r/(?<=\|)[ \t]*[<>^v~]{1,2}[ \t]*(?=\|)/, Operator
+        rule %r/\|/, Punctuation
+        mixin :inlinecontent
+        rule PLAIN_NO_PIPE, Text
+        rule %r/[^\n|]/, Text
+      end
+
+      state :linkdest do
+        rule %r/$/, Text, :pop!
+        rule %r/<[^>\n]*>/, Name::Tag
+        rule %r/"[^"\n]*"/, Str::Double
+        rule %r/[^\s\n]+/, Name::Tag
+        # Any Unicode whitespace, not only space and tab: a destination can be
+        # preceded by U+202F and friends, and a class of two characters leaves
+        # the state with nothing to match.
+        rule %r/[^\S\n]+/, Text
+      end
+
+      # ------------------------------------------------------------------
+      # Inline level
+      # ------------------------------------------------------------------
+      state :inline do
+        mixin :inlinecontent
+        rule %r/\n/, Text
+        rule %r/./, Text
+      end
+
+      state :inlinecontent do
+        # An escape wins over every delimiter that follows it. A backslash at
+        # END OF LINE escapes nothing - it is a hard break, and needs its own
+        # rule because the general form requires a following character.
+        rule %r/\\(?=\n|$)/, Str::Escape
+        rule %r/\\[!-\/:-@\[-`{-~]/, Str::Escape
+
+        # A trailing comment runs to end of line from anywhere on it.
+        rule %r/(%%)([^\n]*)$/ do
+          groups Comment::Preproc, Comment
+        end
+
+        # Verbatim families first: nothing inside them is markup. The literal
+        # form is a `!` PREFIX on a code span, not a trailing attribute, and it
+        # has to be tried before plain inline code or the `!` would be read as
+        # text and the span as ordinary code.
+        rule %r/(!)(`+)([^\n]*?)(\2)/ do
+          groups Operator, Punctuation, Literal, Punctuation
+        end
+        rule %r/(\$\$)(`+)([^\n]*?)(\2)/ do
+          groups Operator, Punctuation, Str::Other, Punctuation
+        end
+        rule %r/(\$)(`+)([^\n]*?)(\2)/ do
+          groups Operator, Punctuation, Str::Other, Punctuation
+        end
+        rule %r/(`+)([^\n]*?)(\1)/ do
+          groups Punctuation, Str::Backtick, Punctuation
+        end
+
+        # CriticMarkup substitution and comment, before the forced family:
+        # `{~old~>new~}` also matches the forced-strike shape.
+        rule %r/(\{~)([^\n]*?)(~>)([^\n]*?)(~\})/ do
+          groups Punctuation, Generic::Deleted, Operator, Generic::Inserted, Punctuation
+        end
+        rule %r/(\{\#)([^\n]*?)(\#\})/ do
+          groups Punctuation, Comment, Punctuation
+        end
+
+        # The braced FORCED emphasis family. Braces make a delimiter apply
+        # where the bare form would not - `my{_path_}name` is underline inside
+        # a word - so the content is emphasis and the braces are its
+        # delimiters, not an attribute block.
+        rule %r/(\{\*)([^\n]+?)(\*\})/ do
+          groups Punctuation, Generic::Strong, Punctuation
+        end
+        rule %r/(\{\/)([^\n]+?)(\/\})/ do
+          groups Punctuation, Generic::Emph, Punctuation
+        end
+        rule %r/(\{_)([^\n]+?)(_\})/ do
+          groups Punctuation, Generic::Emph, Punctuation
+        end
+        rule %r/(\{~)([^\n]+?)(~\})/ do
+          groups Punctuation, Generic::Deleted, Punctuation
+        end
+
+        # Braced inline families. Sup and sub are braced-only in Carve: a bare
+        # `^x^` or `,x,` is literal text.
+        rule %r/(\{\^)([^\n]+?)(\^\})/ do
+          groups Punctuation, Generic::Emph, Punctuation
+        end
+        rule %r/(\{,)([^\n]+?)(,\})/ do
+          groups Punctuation, Generic::Emph, Punctuation
+        end
+        rule %r/(\{=)([^\n]+?)(=\})/ do
+          groups Punctuation, Generic::Inserted, Punctuation
+        end
+        rule %r/(\{\+)([^\n]+?)(\+\})/ do
+          groups Punctuation, Generic::Inserted, Punctuation
+        end
+        rule %r/(\{-)([^\n]+?)(-\})/ do
+          groups Punctuation, Generic::Deleted, Punctuation
+        end
+        rule %r/(\{>>)([^\n]+?)(<<\})/ do
+          groups Punctuation, Comment, Punctuation
+        end
+        rule %r/(\{%)(.*?)(%\})/ do
+          groups Comment::Preproc, Comment, Comment::Preproc
+        end
+
+        # An inline footnote carries content; a reference carries a label.
+        rule %r/\^\[/, Punctuation, :inlinefootnote
+        rule %r/(\[\^)([^\]\n]+)(\])/ do
+          groups Punctuation, Name::Label, Punctuation
+        end
+
+        # A citation before a link: both open with `[`, and `[@key]` or
+        # `[+@key]` would otherwise be read as a link label.
+        rule %r/(\[)(\+?@[^\]\n]+)(\])/ do
+          groups Punctuation, Name::Variable, Punctuation
+        end
+
+        # Image, then link, then a bare span. All three share the `[...]` shape
+        # and differ only in the prefix and what follows.
+        rule %r/(!#{LABEL})(\()([^)\n]*)(\))/ do
+          groups Str::Other, Punctuation, Name::Tag, Punctuation
+        end
+        rule %r/(!#{LABEL})(#{LABEL})/ do
+          groups Str::Other, Name::Label
+        end
+        rule %r/(#{LABEL})(\()([^)\n]*)(\))/ do
+          groups Name::Entity, Punctuation, Name::Tag, Punctuation
+        end
+        rule %r/(#{LABEL})(#{LABEL})/ do
+          groups Name::Entity, Name::Label
+        end
+        rule %r/#{LABEL}(?=#{ATTRS})/, Name::Entity
+
+        # A cross-reference to a heading id.
+        rule %r/(<\/)(\#[\w-]+)(>)/ do
+          groups Punctuation, Name::Namespace, Punctuation
+        end
+        # An autolink.
+        rule %r/(<)([a-zA-Z][\w+.-]*:[^>\s]+|[^>\s@]+@[^>\s]+)(>)/ do
+          groups Punctuation, Name::Tag, Punctuation
+        end
+
+        # The `:name[...]` extension form.
+        rule %r/(:)([a-zA-Z][\w-]*)(\[)/ do
+          groups Punctuation, Name::Function, Punctuation
+          push :rolebody
+        end
+
+        # A code callout marker, and a symbol shortcode - whose name may start
+        # with a sign, as in `:+1:`.
+        rule %r/<\d+>/, Name::Constant
+        rule %r/(?<![\w:]):[\w+-]+:(?![\w:])/, Name::Constant
+
+        # An attribute block attached to the construct before it.
+        rule ATTRS, Name::Attribute
+
+        # Bare emphasis delimiters. Carve's bare set is / * _ ~ = and each
+        # needs a non-space inner boundary so `a / b` stays literal.
+        rule %r/(\/\*)([^\n]+?)(\*\/)/ do
+          groups Punctuation, Generic::Strong, Punctuation
+        end
+        rule %r/(\*\/)([^\n]+?)(\/\*)/ do
+          groups Punctuation, Generic::Strong, Punctuation
+        end
+        rule %r/(\*)(\S(?:[^\n]*?\S)?)(\*)/ do
+          groups Punctuation, Generic::Strong, Punctuation
+        end
+        rule %r/(\/)(\S(?:[^\n]*?\S)?)(\/)/ do
+          groups Punctuation, Generic::Emph, Punctuation
+        end
+        rule %r/(_)(\S(?:[^\n]*?\S)?)(_)/ do
+          groups Punctuation, Generic::Emph, Punctuation
+        end
+        rule %r/(~)(\S(?:[^\n]*?\S)?)(~)/ do
+          groups Punctuation, Generic::Deleted, Punctuation
+        end
+        rule %r/(=)(\S(?:[^\n]*?\S)?)(=)/ do
+          groups Punctuation, Generic::Inserted, Punctuation
+        end
+
+        # A mention and a tag, each one token: the sigil is part of the name
+        # rather than punctuation beside it.
+        rule %r/(?<![\w\/])@[\w][\w.-]*/, Name::Variable::Magic
+        rule %r/(?<![\w&])\#[\w][\w-]*/, Name::Variable::Instance
+
+        # Typographic runs, longest first: an arrow is not an en dash plus a
+        # stray angle bracket, and `---` is not `--` plus `-`.
+        rule %r/<-->|<==>|<=>|-->|<--|==>|<==|->|<-/, Operator
+        rule %r/(?<!-)---(?!-)|(?<!-)--(?!-)/, Punctuation
+        rule %r/\.\.\./, Punctuation
+      end
+
+      state :inlinefootnote do
+        rule %r/\]/, Punctuation, :pop!
+        mixin :inlinecontent
+        rule PLAIN_NO_BRACKET, Generic::Emph
+        rule %r/[^\]\n]/, Generic::Emph
+        rule %r/\n/, Text
+      end
+
+      state :rolebody do
+        rule %r/\]/, Punctuation, :pop!
+        mixin :inlinecontent
+        rule PLAIN_NO_BRACKET, Name::Function
+        rule %r/[^\]\n]/, Name::Function
+        rule %r/\n/, Text
+      end
+
+      private
+
+      # Lex the tail of a fence or container opener line without leaving the
+      # current state: a quoted title, a bracketed label and an attribute
+      # block, each as its own token.
+      def lex_info_string(text)
+        return if text.nil? || text.empty?
+
+        scanner = StringScanner.new(text)
+        until scanner.eos?
+          if (m = scanner.scan(%r/"[^"\n]*"/))
+            token Str::Double, m
+          elsif (m = scanner.scan(%r/\[[^\]\n]*\]/))
+            token Name::Label, m
+          elsif (m = scanner.scan(ATTRS))
+            token Name::Attribute, m
+          else
+            token Text, scanner.getch
+          end
+        end
+      end
+
+      # Enter a fenced block. The payload is opaque to Carve, so it either goes
+      # to a lexer for the declared language or comes out as one string token.
+      #
+      # The closer must be AT LEAST as long as the opener. A Rouge state cannot
+      # carry the opener's width across rules, so the width is closed over here
+      # instead of approximated - `~~~~` does not close a ```` ``` ```` block,
+      # and a three-backtick line inside a four-backtick fence stays content.
+      def push_fence(opener, language)
+        char = Regexp.escape(opener[0])
+        width = opener.length
+        closer = %r/^[ \t]*#{char}{#{width},}[ \t]*$/
+
+        sublexer = fence_lexer(language)
+        sublexer&.reset!
+
+        push do
+          rule closer, Punctuation, :pop!
+          if sublexer
+            # The opener's own newline, which is not part of the payload and
+            # sits mid-line where the line rule below cannot reach it.
+            rule %r/\n/, Text
+            # WHOLE LINES, never fragments. A delegated lexer carries state
+            # across calls, so handing it a piece of a line at a time makes it
+            # tokenize the pieces rather than the line.
+            rule %r/^.*\n?/ do |m|
+              delegate sublexer, m[0]
+            end
+          else
+            # Carve's own callout marker, which only survives where no
+            # embedded language owns the payload.
+            rule %r/<\d+>/, Name::Constant
+            rule %r/[^\n<]+|<|\n/, Str::Backtick
+          end
+        end
+      end
+
+      # A lexer for the fence's declared language, or nil when there is no
+      # language, none is known, or the name is ambiguous. Guessing is
+      # deliberately not attempted: a wrong guess colours a sample as the wrong
+      # language, which reads worse than leaving it plain.
+      def fence_lexer(language)
+        return nil if language.nil? || language.empty?
+
+        Lexer.find_fancy(language)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rouge-carve.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rouge'
+require_relative 'rouge/lexers/carve'
+
+# A Rouge lexer for the Carve markup language.
+#
+# Requiring this file is the whole interface: defining the lexer class
+# registers it, so `Rouge::Lexer.find('carve')` and
+# `Rouge::Lexer.guess(filename: 'x.crv')` work from that point on.
+module RougeCarve
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: rouge-carve
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Scherer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: |-
+  Syntax highlighting for Carve (.crv) wherever Rouge is the highlighter -
+  GitLab, Jekyll, Redcarpet and most Ruby static site generators. Carve
+  swaps several of Markdown's delimiters, so lexing it as Markdown is not
+  merely imprecise, it inverts them.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/rouge-carve.rb
+- lib/rouge/demos/carve
+- lib/rouge/lexers/carve.rb
+homepage: https://github.com/markup-carve/rouge-carve
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/markup-carve/rouge-carve
+  source_code_uri: https://github.com/markup-carve/rouge-carve
+  bug_tracker_uri: https://github.com/markup-carve/rouge-carve/issues
+  changelog_uri: https://github.com/markup-carve/rouge-carve/blob/main/CHANGELOG.md
+  documentation_uri: https://markup-carve.github.io/carve/
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: A Rouge lexer for the Carve markup language.
+test_files: []