rouge-ddot 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 030aed92e51b80504fd3f03b850fcb27e2d0177946f18b180259ca922c9a26c4
-  data.tar.gz: 6b0ff837c2198a05e3b1170cef2b26177d746f3b7afe7b352b2fe523943af2af
+  metadata.gz: a99cbaae721a52151bcfff4eb8d656c88aade697eab78160a3841f8274c0041e
+  data.tar.gz: adda0083411ae5755d34944ca3a194947b95827f73af93b8c55094a7660df8cd
 SHA512:
-  metadata.gz: c11702ea5d91f5deaadf0bdd1da69386c03d16371e942f88fdd2183228823cedb7ac7dea774a58fcd87ed9c4fcb2193fb3c01f6c7852d84dbfa9e75d7d2c552c
-  data.tar.gz: f169ad082eb380492f30e27360b08b3e45eb70020a364320ad7fb777244793a8dc6e89a7f43fbd0e51ee7056a3d9817593796790777542a0b0bed811c5445732
+  metadata.gz: 285d6debe396c45d56abd71d15998bb414c877d74d6d792a6d2cd3531957bd97187cfd2e3fcde1a84aab842a3cf94a15029a66d0b4f3cab17832b80b5a3d2f47
+  data.tar.gz: 422c3c2721efe2b5ecb062f23cd65e7bc518f3733f2aa2f1859f3f9ea3615680610caaf967440da55f18e8803f640294678909a54378f1b5f5642b0ba461e1ac

data/CHANGELOG.md

@@ -0,0 +1,105 @@
+# Changelog
+
+## 0.1.3
+
+No lexer changes — token output is identical to 0.1.2.
+
+### Added
+
+- **`require 'rouge-ddot'` now works.** The gem shipped only
+  `lib/rouge/lexers/ddot.rb`, so requiring it by gem *name* raised
+  `LoadError: cannot load such file -- rouge-ddot`. Since Rouge does not
+  auto-discover third-party lexers, and `Bundler.require` (Jekyll's
+  `:jekyll_plugins` group, Rails initializers, …) requires gems by name,
+  hosts could not load the lexer the conventional way: adding it to a
+  `:jekyll_plugins` group *crashed the build*. Every host therefore had to
+  know the internal path and write `require 'rouge/lexers/ddot'` into a plugin
+  file of its own. A `lib/rouge-ddot.rb` entry point now requires the lexer,
+  so this is enough to highlight `[source,ddot.it]` blocks in Jekyll:
+
+  ```ruby
+  # Gemfile
+  group :jekyll_plugins do
+    gem 'rouge-ddot', '~> 0.1.3'
+  end
+  ```
+
+  `require 'rouge/lexers/ddot'` keeps working unchanged.
+
+## 0.1.2
+
+Brings the lexer in line with the ddot.it Parse and Highlight specifications.
+Conformance is asserted against all 33 cases of the cross-implementation
+corpus (`../ddot.it/test-data/cases/`), with the TextMate grammar canonical.
+
+### Fixed
+
+- **`FrozenError` on any block containing a non-triple line.** The file carried
+  `# frozen_string_literal: true`, but Rouge mutates the string handed to
+  `token`, so lexing a `!!block` body, an annotation line or an end marker
+  raised `can't modify frozen String` (Rouge 4.7). This crashed Asciidoctor
+  outright, making 0.1.1 unusable on real ddot.it documentation.
+- **`Error` token on the blank line inside a `?end=` block.** The blank-line
+  rule matched zero-width, so Rouge could not advance and emitted `Error` for
+  the newline — an error-styled blank line in every marked block. The rule now
+  consumes the newline. Invisible to the corpus, whose harness drops
+  whitespace-only chunks; it showed only in rendered output.
+
+### Added
+
+- **`!!off` / `!!on` recognised anywhere on a line**, not only alone on one, so
+  the commands work inside host-language comments (`<!-- ddot.it/off -->`,
+  `# !!off`, `// !!on`). Only the command itself is coloured; the line yields no
+  triple and the region starts on the next line. The command *name* is still
+  matched exactly, so `!!office` is not `!!off`.
+- **Metadata continuation after a block** (Parse Spec *block-continuation*): a
+  line whose first token is `,,` continues the triple whose **object** a block
+  filled, and `;;` continues after a block **meta object**. Previously both read
+  as a fresh triple with the subject `,,` / `;;`, and the unmatched delimiter
+  produced an `Error` token.
+- **Continuation lines that open a block** (`..knows.. !!block`), so one logical
+  line can carry a block subject *and* a block object.
+
+### Changed
+
+- **Canonical token names** (`test-data/tokens.md`), which changes the emitted
+  Rouge token types:
+
+  | ddot.it token   | 0.1.1                | 0.1.2                       |
+  |-----------------|----------------------|-----------------------------|
+  | `doubledot`     | `Operator` → *operator* | `Operator`               |
+  | `meta-doubledot`| `Comment::Hashbang` → *meta-operator* | `Comment::Hashbang` |
+  | `excluded`      | `Comment::Single` → *disabled* | `Comment::Single`  |
+  | `meta-separator`| —                    | `Punctuation`               |
+  | `command-param` | —                    | `Name::Attribute`           |
+  | `block-end`     | —                    | `Name::Label`               |
+  | `verbatim`      | —                    | `Literal::String::Backtick` |
+
+  Themes that styled `operator`, `meta-operator` or `disabled` by *name* need
+  updating; those styling by Rouge token class are unaffected except for the
+  four newly emitted classes.
+- **Lexical tokens follow the spec's counting rule.** `DT2`/`DT4`/`CM2`/`SC2`
+  are runs of *exactly* n, expressed with lookarounds, so `...` and `......`
+  are text rather than operators.
+- **The line-shape gate.** A line is ddot.it only when it carries a complete
+  operator skeleton — two `DT2`, or one `DT4` / `.. ..`. Prose with a lone `..`,
+  an ellipsis, `Node.js` or `U.S.A.` stays plain.
+- **Commands require the slash and a name**: bare `ddot.it` is a document
+  marker, not a command, and `?`/`#` introduce a command's query and fragment
+  instead of terminating it (`!!block?end=EOS` is one command).
+- **`!!block` as a field value** in the Subject, Object and MetaObject
+  positions, blank-line and `?end=MARKER` terminated, with the body emitted as
+  `verbatim`.
+- **`;;` separates inline metadata pairs only.** Inside a `,,` block a metadata
+  object runs to the end of its line, so `;;` there is ordinary text.
+
+## 0.1.1
+
+First release published via OIDC trusted publishing
+(`Calpano/ddot.it-syntax-tools` → RubyGems). No functional
+changes vs 0.1.0.
+
+## 0.1.0
+
+Initial release. Rouge lexer for ddot.it. See
+[`design.adoc`](./design.adoc).

data/README.md

@@ -6,35 +6,53 @@ graph notation (https://ddot.it).
 ## Usage
 
 ```ruby
-require 'rouge'
-require 'rouge/lexers/ddot'
+require 'rouge-ddot'
 
 Rouge::Lexers::Ddot.new.lex("Project Eagle ..started in.. 2024") do |tok, val|
   puts [tok.qualname, val].inspect
 end
 ```
 
+Rouge does not auto-discover third-party lexers, so the gem has to be required
+before a `ddot.it` block can be highlighted. Requiring it by name is enough
+(since 0.1.3); `require 'rouge/lexers/ddot'` also works.
+
+In **Jekyll**, put it in the `:jekyll_plugins` group and Bundler requires it at
+startup — no `_plugins/` file needed:
+
+```ruby
+# Gemfile
+group :jekyll_plugins do
+  gem 'rouge-ddot', '~> 0.1.3'
+end
+```
+
 In Asciidoctor with `:source-highlighter: rouge` set, `[source,ddot]` blocks
-are dispatched here automatically — no extra wiring per document.
+are dispatched here automatically — no extra wiring per document. The lexer
+registers under the tag `ddot`, with the aliases `ddotit` and `ddot.it`.
 
 ## Token mapping
 
 The lexer emits standard Rouge tokens; they map to the canonical ddot.it
 token vocabulary in [`../../ddot.it/test-data/tokens.md`](../../ddot.it/test-data/tokens.md):
 
-| Rouge                       | Canonical       |
-|-----------------------------|-----------------|
-| `Name::Class`               | `subject`       |
-| `Name::Function`            | `relation`      |
-| `Literal::String::Symbol`   | `object`        |
-| `Operator`                  | `operator`      |
-| `Keyword::Pseudo`           | `command`       |
-| `Comment::Preproc`          | `meta-delim`    |
-| `Comment::Hashbang`         | `meta-operator` |
-| `Comment::Doc`              | `meta-relation` |
-| `Comment::Special`          | `meta-object`   |
-| `Comment::Multiline`        | `meta-text`     |
-| `Comment::Single`           | `disabled`      |
+| Rouge                       | Canonical        |
+|-----------------------------|------------------|
+| `Name::Class`               | `subject`        |
+| `Name::Function`            | `relation`       |
+| `Literal::String::Symbol`   | `object`         |
+| `Operator`                  | `doubledot`      |
+| `Keyword::Pseudo`           | `command`        |
+| `Name::Attribute`           | `command-param`  |
+| `Name::Label`               | `block-end`      |
+| `Comment::Preproc`          | `meta-delim`     |
+| `Punctuation`               | `meta-separator` |
+| `Comment::Hashbang`         | `meta-doubledot` |
+| `Comment::Doc`              | `meta-relation`  |
+| `Comment::Special`          | `meta-object`    |
+| `Comment::Multiline`        | `meta-text`      |
+| `Comment::Single`           | `excluded`       |
+| `Literal::String::Backtick` | `verbatim`       |
 
 ## Conformance
 
@@ -57,9 +75,11 @@ lockstep.
 ```
 rouge/
 ├── lib/
+│   ├── rouge-ddot.rb            # entry point: require 'rouge-ddot'
 │   └── rouge/
 │       └── lexers/
 │           └── ddot.rb          # the lexer
+├── CHANGELOG.md
 ├── README.md
 └── rouge-ddot.gemspec
 ```

data/lib/rouge/lexers/ddot.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-#
 # Rouge lexer for ddot.it (https://ddot.it). Emits tokens that — after the
 # scope-name mapping in `tools/conformance-rouge.rb` — equal the canonical
 # token streams in `../../ddot.it/test-data/cases/*/expected.tokens.json`.
@@ -8,18 +6,24 @@
 #   Name::Class                  → subject
 #   Name::Function               → relation
 #   Literal::String::Symbol      → object
-#   Operator                     → operator
+#   Operator                     → doubledot
 #   Keyword::Pseudo              → command
+#   Name::Attribute              → command-param
+#   Name::Label                  → block-end
 #   Comment::Preproc             → meta-delim
-#   Comment::Hashbang            → meta-operator
+#   Punctuation                  → meta-separator
+#   Comment::Hashbang            → meta-doubledot
 #   Comment::Doc                 → meta-relation
 #   Comment::Special             → meta-object
 #   Comment::Multiline           → meta-text
-#   Comment::Single              → disabled
+#   Comment::Single              → excluded
+#   Literal::String::Backtick    → verbatim
+#
+# NOT `# frozen_string_literal: true`: Rouge mutates the string handed to
+# `token`, so a frozen literal raises FrozenError (observed with Rouge 4.7).
 #
 # State machine is flat by design: we use `goto` exclusively (no `push`), so
 # the stack is always one deep and `\n` simply transitions back to `:root`.
-# This keeps line-by-line dispatch clean — every line starts fresh.
 #
 # Rouge gotcha: `rule pat, Token do |m| ... end` IGNORES the Token arg when
 # a block is given. To both emit a token AND transition, use a block that
@@ -37,34 +41,144 @@ module Rouge
       filenames '*.ddot'
       mimetypes 'text/x-ddot'
 
-      OFF_RE = /(?:ddot\.it\/off|!!off)/.freeze
-      ON_RE  = /(?:ddot\.it\/on|!!on)/.freeze
-      CMD_RE = /(?:ddot\.it(?:\/[\w.-]+)?|!![\w.-]*)/.freeze
+      # --- lexical tokens (see the Parse Spec's "Token Sequences") ----------
+      # Each is a run of EXACTLY n, neither preceded nor followed by the same
+      # character — the lookarounds are what express that. `\.{2}` alone would
+      # happily match the first two dots of `...`.
+      DT2  = /(?<!\.)\.{2}(?!\.)/.freeze
+      DT4  = /(?<!\.)\.{4}(?!\.)/.freeze
+      QUAD = /(?<!\.)(?:\.{4}|\.{2}[ \t]+\.{2})(?!\.)/.freeze
+      CM2  = /(?<!,),,(?!,)/.freeze
+      SC2  = /(?<!;);;(?!;)/.freeze
+
+      OFF_RE   = %r{(?:ddot\.it/off|!!off)}.freeze
+      ON_RE    = %r{(?:ddot\.it/on|!!on)}.freeze
+      # Pins the command NAME: `!!office` must not read as `!!off`.
+      BOUND_SRC = /(?![^\s?#])/.freeze
+      # A command needs the slash and a non-empty name; bare `ddot.it` is not one.
+      CMD_RE   = %r{(?:(?:https?://)?ddot\.it/|!!)[^\s?#]+(?:\?[^\s#]*)?(?:\#\S*)?}.freeze
+      BLOCK_RE = %r{(?:(?:https?://)?ddot\.it/|!!)block}.freeze
+
+      # The line-shape gate: a line is ddot.it only if it carries a complete
+      # operator skeleton — two DT2, or one DT4 / '.. ..'. A lone `..` in prose
+      # does not qualify, which is what keeps 23-not-a-triple entirely plain.
+      GATE = /(?=[^\n]*(?:#{DT4}|#{DT2}[^\n]*#{DT2}))/.freeze
+
+      # `!!block` filling a whole field: it must END its physical line.
+      BLOCK_OPENER = /#{BLOCK_RE}(?:(\?end=)(\S+))?[ \t]*(?=\n|\z)/.freeze
+
+      def reset!
+        super
+        @block_end = nil
+      end
+
+      # Emit a slot's text as `slot_token`, unless it is exactly a command —
+      # then it is a command (tokens.md: "a slot whose text is a command is
+      # emitted as command, not subject").
+      def slot(match, slot_token)
+        text = match[0]
+        token(text.match?(/\A#{CMD_RE}\z/) ? Keyword::Pseudo : slot_token, text)
+      end
+
+      # A `!!block` opener was matched: emit its parts, remember any ?end=
+      # marker, and switch to verbatim.
+      def open_block(match)
+        raw  = match[0]
+        lead = raw[/\A[ \t]*/]
+        body = raw[lead.length..].rstrip
+        tail = raw[(lead.length + body.length)..]
+        token Text, lead unless lead.empty?
+        if match[2]
+          token Keyword::Pseudo, body[0...body.index('?end=')]
+          token Name::Attribute, match[1]
+          token Name::Label, match[2]
+          @block_end = match[2]
+        else
+          token Keyword::Pseudo, body
+          @block_end = nil
+        end
+        token Text, tail unless tail.nil? || tail.empty?
+        goto :verbatim
+      end
 
       # ─────────── line-dispatch root ───────────
       state :root do
         # Standalone ,, opens a free-form meta block.
-        rule(%r/^[ \t]*,,[ \t]*(?=\n|\z)/) do |m|
+        rule(%r/^[ \t]*#{CM2}[ \t]*(?=\n|\z)/) do |m|
           token Comment::Preproc, m[0]
           goto :meta_block
         end
-        # Off-marker enters disabled span.
-        rule(%r/^[ \t]*#{OFF_RE}[ \t]*(?=\n|\z)/) do |m|
-          token Keyword::Pseudo, m[0]
+        # Parse Spec "block-continuation": after a block that filled the OBJECT,
+        # a line whose first token is CM2 CONTINUES the logical line as metadata
+        # (and SC2 after a block meta object).
+        # Without this it lexes as a fresh triple whose subject is ",," (or, in
+        # this lexer, as an unmatched ",," followed by subject "since").
+        # Keyed on shape — a state machine over physical lines cannot see that a
+        # block object preceded: ",," then whitespace then "..".
+        rule(%r/^[ \t]*(#{CM2})(?=[ \t]+#{DT2})/) do |m|
+          token Comment::Preproc, m[1]
+          push :inline_meta
+        end
+        # ... and SC2 after a block META OBJECT (`;; ..until.. 2020`).
+        rule(%r/^[ \t]*(#{SC2})(?=[ \t]+#{DT2})/) do |m|
+          token Punctuation, m[1]
+          push :inline_meta
+        end
+        # Off-marker enters an excluded span.
+        # Recognised ANYWHERE on the line (host-language comments), but the whole
+        # line is consumed so only the command itself is coloured.
+        rule(%r/^([^\n]*?)(#{OFF_RE}#{BOUND_SRC})([^\n]*)(?=\n|\z)/) do |m|
+          token Text, m[1]
+          token Keyword::Pseudo, m[2]
+          token Text, m[3]
           goto :disabled
         end
+        # `!!block` alone on a line = a SUBJECT opener (block-as-field).
+        rule(%r/^[ \t]*#{BLOCK_OPENER}/) { |m| open_block(m) }
         # Empty / whitespace-only line.
         rule %r/^[ \t]*\n/, Text
-        # Continuation line (starts with `..` or `....`).
-        rule(/^(?=[ \t]*\.{2,4})/) { goto :after_subject }
-        # Triple line — start with subject parsing.
-        rule(/^/) { goto :subject }
+        # Gate: only lines with a full operator skeleton parse as triples.
+        rule(/^#{GATE}(?=[ \t]*(?:#{DT2}|#{QUAD}))/) { goto :after_subject }
+        rule(/^#{GATE}/) { goto :subject }
+        # Anything else is not a triple: consume the line, emit no token.
+        rule %r/[^\n]+/, Text
+        rule %r/\n/, Text
       end
 
-      # ─────────── disabled span ───────────
+      # ─────────── verbatim (a !!block body) ───────────
+      state :verbatim do
+        # A blank line ends the unmarked form; in a marked block it is content.
+        # The newline MUST be consumed here: a zero-width match leaves the
+        # stream where it was, Rouge cannot advance, and it emits Error for the
+        # newline instead — visible as an error-styled blank line inside every
+        # `?end=` block. (The conformance harness drops whitespace-only chunks,
+        # so the corpus cannot catch this; it only shows in rendered output.)
+        rule(%r/^[ \t]*\n/) do |m|
+          token Text, m[0]
+          goto :root if @block_end.nil?
+        end
+        rule(%r/^[ \t]*\z/) do |m|
+          token Text, m[0]
+          goto :root if @block_end.nil?
+        end
+        rule(%r/^[^\n]+/) do |m|
+          if @block_end && m[0].strip == @block_end
+            token Name::Label, m[0]
+            @block_end = nil
+            goto :root
+          else
+            token Literal::String::Backtick, m[0]
+          end
+        end
+        rule %r/\n/, Text
+      end
+
+      # ─────────── excluded span ───────────
       state :disabled do
-        rule(%r/^[ \t]*#{ON_RE}[ \t]*(?=\n|\z)/) do |m|
-          token Keyword::Pseudo, m[0]
+        rule(%r/^([^\n]*?)(#{ON_RE}#{BOUND_SRC})([^\n]*)(?=\n|\z)/) do |m|
+          token Text, m[1]
+          token Keyword::Pseudo, m[2]
+          token Text, m[3]
           goto :root
         end
         rule %r/^[ \t]*\n/, Text
@@ -72,200 +186,211 @@ module Rouge
         rule %r/\n/, Text
       end
 
-      # ─────────── multi-line meta block (free-form) ───────────
+      # ─────────── multi-line meta block (free-form or typed) ───────────
       state :meta_block do
-        rule(%r/^[ \t]*,,[ \t]*(?=\n|\z)/) do |m|
+        rule(%r/^[ \t]*#{CM2}[ \t]*(?=\n|\z)/) do |m|
           token Comment::Preproc, m[0]
           goto :root
         end
         rule %r/^[ \t]*\n/, Text
-        rule %r/[^\n]+/, Comment::Multiline
+        rule(/^(?=[ \t]*(?:#{DT2}|#{QUAD}))/) { goto :typed_meta_op }
+        rule %r/[^\n]+/, Comment::Multiline   # free-form meta text
         rule %r/\n/, Text
       end
 
       # ─────────── triple line: subject phase ───────────
       state :subject do
         rule %r/[ \t]+/, Text
-        rule(/#{CMD_RE}(?=[ \t]+\.{2,4}|[ \t]*,,|[ \t]*$|\n|\z)/) do |m|
-          token Keyword::Pseudo, m[0]
-          goto :after_subject
-        end
-        rule(/[^\s.,][^\n,]*?(?=[ \t]+\.{2,4}|[ \t]*,,|[ \t]*$|\n|\z)/) do |m|
-          token Name::Class, m[0]
+        rule(/[^\s.,][^\n,]*?(?=[ \t]*(?:#{DT2}|#{QUAD})|[ \t]*#{CM2}|[ \t]*$|\n|\z)/) do |m|
+          slot m, Name::Class
           goto :after_subject
         end
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
-      # ─────────── after subject (or continuation entry) ───────────
+      # ─────────── after subject (or continuation-line entry) ───────────
       state :after_subject do
         rule %r/[ \t]+/, Text
-        # `.. ..` (spaced operator) — emit as one operator token covering the
-        # whole sequence, matching the canonical corpus.
-        rule(%r/\.{2}[ \t]+\.{2}/) do |m|
-          token Operator, m[0]
-          goto :object
-        end
-        rule(%r/\.{4}/) do |m|
+        # QuadDot FIRST: '.. ..' is ONE operator, not two.
+        rule(%r/#{QUAD}/) do |m|
           token Operator, m[0]
           goto :object
         end
-        rule(%r/\.{2}/) do |m|
+        rule(%r/#{DT2}/) do |m|
           token Operator, m[0]
           goto :relation
         end
-        rule(%r/,,/) do |m|
+        rule(%r/#{CM2}/) do |m|
           token Comment::Preproc, m[0]
           goto :inline_meta
         end
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
       # ─────────── relation phase ───────────
       state :relation do
-        rule(/[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\z)/) do |m|
-          token Name::Function, m[0]
+        rule %r/[ \t]+/, Text
+        rule(/[^\s.,][^\n.,]*?(?=[ \t]*#{DT2}|[ \t]*$|\n|\z)/) do |m|
+          slot m, Name::Function
           goto :after_relation
         end
-        rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
       state :after_relation do
         rule %r/[ \t]+/, Text
-        rule(%r/\.{2}/) do |m|
+        rule(%r/#{DT2}/) do |m|
           token Operator, m[0]
           goto :object
         end
-        rule(%r/,,/) do |m|
+        rule(%r/#{CM2}/) do |m|
           token Comment::Preproc, m[0]
           goto :inline_meta
         end
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
       # ─────────── object phase ───────────
+      # Object := TextExcept{NL,CM2} — it MAY contain `..` (20-object-dotdot),
+      # so it runs to end of line or to a `,,`; it does not stop at a DT2.
       state :object do
-        rule(/[^\s,][^\n,]*?(?=[ \t]*,,|[ \t]*$|\n|\z)/) do |m|
-          token Literal::String::Symbol, m[0]
+        rule %r/[ \t]+/, Text
+        rule(%r/#{BLOCK_OPENER}/) { |m| open_block(m) }
+        rule(/[^\s,][^\n,]*?(?=[ \t]*#{CM2}|[ \t]*$|\n|\z)/) do |m|
+          slot m, Literal::String::Symbol
           goto :after_object
         end
-        rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
       state :after_object do
         rule %r/[ \t]+/, Text
-        # Trailing `,,` at end-of-line opens a typed multi-line meta block:
-        # subsequent lines are `..key.. value` triples emitted as meta-*
-        # until a closing standalone `,,`.
-        rule(%r/,,(?=[ \t]*(?:\n|\z))/) do |m|
+        # Trailing `,,` at end-of-line opens a multi-line meta block.
+        rule(%r/#{CM2}(?=[ \t]*(?:\n|\z))/) do |m|
           token Comment::Preproc, m[0]
-          goto :typed_meta_open
+          goto :meta_block_open
         end
-        # Inline `,,` followed by content on the same line.
-        rule(%r/,,/) do |m|
+        rule(%r/#{CM2}/) do |m|
           token Comment::Preproc, m[0]
           goto :inline_meta
         end
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
-      # Right after trailing `,,` — wait for the newline, then enter
-      # :typed_meta_block for subsequent lines.
-      state :typed_meta_open do
+      state :meta_block_open do
         rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
-      end
-
-      # Typed meta block: each line is `..relation.. object`, closed by `,,`.
-      state :typed_meta_block do
-        rule(%r/^[ \t]*,,[ \t]*(?=\n|\z)/) do |m|
-          token Comment::Preproc, m[0]
-          goto :root
-        end
-        rule %r/^[ \t]*\n/, Text
-        rule(/^(?=[ \t]*\.{2,4})/) { goto :typed_meta_op1 }
-        rule %r/[^\n]+/, Comment::Multiline   # free-form fallback
-        rule %r/\n/, Text
+        rule(%r/\n/) { |m| token Text, m[0]; goto :meta_block }
       end
 
-      state :typed_meta_op1 do
+      # ─────────── typed meta inside a ,, block ───────────
+      state :typed_meta_op do
         rule %r/[ \t]+/, Text
-        rule(%r/\.{2}/) do |m|
+        rule(%r/#{QUAD}/) do |m|          # implicit meta relation
+          token Comment::Hashbang, m[0]
+          goto :typed_meta_object
+        end
+        rule(%r/#{DT2}/) do |m|
           token Comment::Hashbang, m[0]
           goto :typed_meta_relation
         end
-        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :meta_block }
       end
 
       state :typed_meta_relation do
-        rule(/[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\z)/) do |m|
-          token Comment::Doc, m[0]
+        rule %r/[ \t]+/, Text
+        rule(/[^\s.,][^\n.,]*?(?=[ \t]*#{DT2}|[ \t]*$|\n|\z)/) do |m|
+          slot m, Comment::Doc
           goto :typed_meta_after_relation
         end
-        rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :meta_block }
       end
 
       state :typed_meta_after_relation do
         rule %r/[ \t]+/, Text
-        rule(%r/\.{2}/) do |m|
+        rule(%r/#{DT2}/) do |m|
           token Comment::Hashbang, m[0]
           goto :typed_meta_object
         end
-        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :meta_block }
       end
 
+      # MetaObjectInBlock := TextExcept{NL} — `;;` is CONTENT here, not a
+      # separator (that is the inline form only). See 28-semicolon-in-meta-block.
       state :typed_meta_object do
-        rule(/[^\s,][^\n,]*?(?=[ \t]*$|\n|\z)/) do |m|
-          token Comment::Special, m[0]
+        rule %r/[ \t]+/, Text
+        rule(%r/#{BLOCK_OPENER}/) { |m| open_block(m) }
+        rule(/[^\s][^\n]*?(?=[ \t]*$|\n|\z)/) do |m|
+          slot m, Comment::Special
           goto :typed_meta_after_object
         end
-        rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :meta_block }
       end
 
       state :typed_meta_after_object do
         rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :meta_block }
       end
 
       # ─────────── inline metadata (after `,,` on a triple line) ───────────
       state :inline_meta do
+        # A `..` / `....` right after the `,,` selects the triple form…
+        rule(/(?=[ \t]*(?:#{DT2}|#{QUAD}))/) { goto :inline_meta_op }
+        # …anything else is free-form meta text, trimmed of surrounding WS.
+        rule %r/[ \t]+/, Text
+        rule(/[^\s][^\n]*?(?=[ \t]*$|\n|\z)/) { |m| token Comment::Multiline, m[0] }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
+      end
+
+      state :inline_meta_op do
         rule %r/[ \t]+/, Text
-        rule(%r/\.{2}/) do |m|
+        rule(%r/#{QUAD}/) do |m|          # implicit meta relation
+          token Comment::Hashbang, m[0]
+          goto :inline_meta_object
+        end
+        rule(%r/#{DT2}/) do |m|
           token Comment::Hashbang, m[0]
           goto :inline_meta_relation
         end
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
       state :inline_meta_relation do
-        rule(/[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\z)/) do |m|
-          token Comment::Doc, m[0]
+        rule %r/[ \t]+/, Text
+        rule(/[^\s.,][^\n.,]*?(?=[ \t]*#{DT2}|[ \t]*$|\n|\z)/) do |m|
+          slot m, Comment::Doc
           goto :inline_meta_after_relation
         end
-        rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
       state :inline_meta_after_relation do
         rule %r/[ \t]+/, Text
-        rule(%r/\.{2}/) do |m|
+        rule(%r/#{DT2}/) do |m|
           token Comment::Hashbang, m[0]
           goto :inline_meta_object
         end
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
 
+      # MetaObjectInline := TextExcept{NL,SC2} — stops at `;;`.
       state :inline_meta_object do
-        rule(/[^\s,][^\n,]*?(?=[ \t]*$|\n|\z)/) do |m|
-          token Comment::Special, m[0]
-          goto :after_object
+        rule %r/[ \t]+/, Text
+        rule(%r/#{BLOCK_OPENER}/) { |m| open_block(m) }
+        rule(/[^\s;][^\n;]*?(?=[ \t]*#{SC2}|[ \t]*$|\n|\z)/) do |m|
+          slot m, Comment::Special
+          goto :inline_meta_next
         end
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
+      end
+
+      # `;;` divides several (relation, object) pairs about one triple.
+      state :inline_meta_next do
         rule %r/[ \t]+/, Text
-        rule(%r/\n/) { token Text, "\n"; goto :root }
+        rule(%r/#{SC2}/) do |m|
+          token Punctuation, m[0]
+          goto :inline_meta_op
+        end
+        rule(%r/\n/) { |m| token Text, m[0]; goto :root }
       end
     end
   end

data/lib/rouge-ddot.rb

@@ -0,0 +1,13 @@
+# Entry point for `require 'rouge-ddot'` — the path Bundler takes when the gem
+# is listed in a Jekyll `:jekyll_plugins` group, or under any other
+# `Bundler.require`, which requires a gem by its *name*.
+#
+# Rouge does not auto-discover third-party lexers: a lexer is registered only
+# when its file is loaded. Up to 0.1.2 the gem shipped `lib/rouge/lexers/ddot.rb`
+# alone, so `require 'rouge-ddot'` raised LoadError and every host had to know
+# the internal path and write `require 'rouge/lexers/ddot'` into a plugin file
+# of its own. This file makes the conventional require work.
+#
+# `require_relative` rather than `require` so loading does not depend on this
+# gem's lib directory being on `$LOAD_PATH`. The lexer requires 'rouge' itself.
+require_relative 'rouge/lexers/ddot'

data/rouge-ddot.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rouge-ddot'
-  s.version     = '0.1.1'
+  s.version     = '0.1.3'
   s.summary     = 'Rouge lexer for ddot.it'
   s.description = 'Syntax highlighter for the ddot.it knowledge graph notation. ' \
                   'Plugs into Rouge so any tool that uses Rouge for source ' \
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.files = Dir[
     'lib/**/*.rb',
     'README.md',
+    'CHANGELOG.md',
     'rouge-ddot.gemspec'
   ]
   s.require_paths = ['lib']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge-ddot
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Calpano
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-09 00:00:00.000000000 Z
+date: 2026-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rouge
@@ -33,7 +33,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - README.md
+- lib/rouge-ddot.rb
 - lib/rouge/lexers/ddot.rb
 - rouge-ddot.gemspec
 homepage: https://ddot.it