rouge-ddot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f88c6029952b82c0718d5e84838c76366d1b2bd9a26cbabdd36ecbbe52c49e8
+  data.tar.gz: 14439ccab259956c663b1eb0ba250ba34753f1817ba35c8c6bbdb318dc9542be
+SHA512:
+  metadata.gz: 024f4d7e79864531850402223871f15b315cd897d9114506c66a37924d25246906744d616755d921077201b91566c8ae5e00fae94f88ce43b3f5914b516412d7
+  data.tar.gz: f170684e1c767d8333fd014dcad35b2f13a60988e21c50989fc393b8c90f420ebb59d521beef6ea1546682ca13f1b852ebb48ae6ff9e02a2253ca464415ddead

data/README.md

@@ -0,0 +1,69 @@
+# rouge-ddot
+
+[Rouge](https://github.com/rouge-ruby/rouge) lexer for the ddot.it knowledge
+graph notation (https://ddot.it).
+
+## Usage
+
+```ruby
+require 'rouge'
+require 'rouge/lexers/ddot'
+
+Rouge::Lexers::Ddot.new.lex("Project Eagle ..started in.. 2024") do |tok, val|
+  puts [tok.qualname, val].inspect
+end
+```
+
+In Asciidoctor with `:source-highlighter: rouge` set, `[source,ddot]` blocks
+are dispatched here automatically — no extra wiring per document.
+
+## 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`      |
+
+## Conformance
+
+The lexer is asserted byte-equal to the corpus at
+[`../../ddot.it/test-data/cases/*/expected.tokens.json`](../../ddot.it/test-data/cases/)
+(after the mapping above). To run:
+
+```sh
+# from the ddot.it-syntax-tools/ root
+ruby tools/conformance-rouge.rb       # exits non-zero on any case diverging
+npm run conformance:rouge             # npm-wrapped form
+```
+
+The same corpus also feeds `npm run conformance:textmate`. Any change to the
+canonical vocabulary or adding a case must keep both implementations in
+lockstep.
+
+## Layout
+
+```
+rouge/
+├── lib/
+│   └── rouge/
+│       └── lexers/
+│           └── ddot.rb          # the lexer
+├── README.md
+└── rouge-ddot.gemspec
+```
+
+## License
+
+MIT.

data/lib/rouge/lexers/ddot.rb

@@ -0,0 +1,272 @@
+# 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`.
+#
+# Token mapping (Rouge → canonical, see ../../../ddot.it/test-data/tokens.md):
+#   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
+#
+# 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
+# calls `token Token, m[0]` then `goto :next`.
+
+require 'rouge'
+
+module Rouge
+  module Lexers
+    class Ddot < RegexLexer
+      title 'ddot.it'
+      desc 'Knowledge graph notation (https://ddot.it)'
+      tag 'ddot'
+      aliases 'ddotit', 'ddot.it'
+      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
+
+      # ─────────── line-dispatch root ───────────
+      state :root do
+        # Standalone ,, opens a free-form meta block.
+        rule(%r/^[ \t]*,,[ \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]
+          goto :disabled
+        end
+        # 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 }
+      end
+
+      # ─────────── disabled span ───────────
+      state :disabled do
+        rule(%r/^[ \t]*#{ON_RE}[ \t]*(?=\n|\z)/) do |m|
+          token Keyword::Pseudo, m[0]
+          goto :root
+        end
+        rule %r/^[ \t]*\n/, Text
+        rule %r/[^\n]+/, Comment::Single
+        rule %r/\n/, Text
+      end
+
+      # ─────────── multi-line meta block (free-form) ───────────
+      state :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 %r/[^\n]+/, Comment::Multiline
+        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]
+          goto :after_subject
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      # ─────────── after subject (or continuation 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|
+          token Operator, m[0]
+          goto :object
+        end
+        rule(%r/\.{2}/) do |m|
+          token Operator, m[0]
+          goto :relation
+        end
+        rule(%r/,,/) do |m|
+          token Comment::Preproc, m[0]
+          goto :inline_meta
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      # ─────────── relation phase ───────────
+      state :relation do
+        rule(/[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\z)/) do |m|
+          token Name::Function, m[0]
+          goto :after_relation
+        end
+        rule %r/[ \t]+/, Text
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      state :after_relation do
+        rule %r/[ \t]+/, Text
+        rule(%r/\.{2}/) do |m|
+          token Operator, m[0]
+          goto :object
+        end
+        rule(%r/,,/) do |m|
+          token Comment::Preproc, m[0]
+          goto :inline_meta
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      # ─────────── object phase ───────────
+      state :object do
+        rule(/[^\s,][^\n,]*?(?=[ \t]*,,|[ \t]*$|\n|\z)/) do |m|
+          token Literal::String::Symbol, m[0]
+          goto :after_object
+        end
+        rule %r/[ \t]+/, Text
+        rule(%r/\n/) { token Text, "\n"; 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|
+          token Comment::Preproc, m[0]
+          goto :typed_meta_open
+        end
+        # Inline `,,` followed by content on the same line.
+        rule(%r/,,/) do |m|
+          token Comment::Preproc, m[0]
+          goto :inline_meta
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      # Right after trailing `,,` — wait for the newline, then enter
+      # :typed_meta_block for subsequent lines.
+      state :typed_meta_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
+      end
+
+      state :typed_meta_op1 do
+        rule %r/[ \t]+/, Text
+        rule(%r/\.{2}/) do |m|
+          token Comment::Hashbang, m[0]
+          goto :typed_meta_relation
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+      end
+
+      state :typed_meta_relation do
+        rule(/[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\z)/) do |m|
+          token Comment::Doc, m[0]
+          goto :typed_meta_after_relation
+        end
+        rule %r/[ \t]+/, Text
+        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+      end
+
+      state :typed_meta_after_relation do
+        rule %r/[ \t]+/, Text
+        rule(%r/\.{2}/) do |m|
+          token Comment::Hashbang, m[0]
+          goto :typed_meta_object
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+      end
+
+      state :typed_meta_object do
+        rule(/[^\s,][^\n,]*?(?=[ \t]*$|\n|\z)/) do |m|
+          token Comment::Special, m[0]
+          goto :typed_meta_after_object
+        end
+        rule %r/[ \t]+/, Text
+        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+      end
+
+      state :typed_meta_after_object do
+        rule %r/[ \t]+/, Text
+        rule(%r/\n/) { token Text, "\n"; goto :typed_meta_block }
+      end
+
+      # ─────────── inline metadata (after `,,` on a triple line) ───────────
+      state :inline_meta do
+        rule %r/[ \t]+/, Text
+        rule(%r/\.{2}/) do |m|
+          token Comment::Hashbang, m[0]
+          goto :inline_meta_relation
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      state :inline_meta_relation do
+        rule(/[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\z)/) do |m|
+          token Comment::Doc, m[0]
+          goto :inline_meta_after_relation
+        end
+        rule %r/[ \t]+/, Text
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      state :inline_meta_after_relation do
+        rule %r/[ \t]+/, Text
+        rule(%r/\.{2}/) do |m|
+          token Comment::Hashbang, m[0]
+          goto :inline_meta_object
+        end
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+
+      state :inline_meta_object do
+        rule(/[^\s,][^\n,]*?(?=[ \t]*$|\n|\z)/) do |m|
+          token Comment::Special, m[0]
+          goto :after_object
+        end
+        rule %r/[ \t]+/, Text
+        rule(%r/\n/) { token Text, "\n"; goto :root }
+      end
+    end
+  end
+end

data/rouge-ddot.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name        = 'rouge-ddot'
+  s.version     = '0.1.0'
+  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 ' \
+                  'highlighting (Asciidoctor, Jekyll, GitLab, …) can colourise ' \
+                  '[source,ddot] blocks against the canonical token vocabulary.'
+  s.authors     = ['Calpano']
+  s.email       = ['hello@calpano.com']
+  s.homepage    = 'https://ddot.it'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 2.7'
+  s.add_runtime_dependency 'rouge', '>= 3.30'
+
+  s.files = Dir[
+    'lib/**/*.rb',
+    'README.md',
+    'rouge-ddot.gemspec'
+  ]
+  s.require_paths = ['lib']
+
+  s.metadata = {
+    'source_code_uri' => 'https://github.com/calpano/ddot.it-syntax-tools',
+    'bug_tracker_uri' => 'https://github.com/calpano/ddot.it-syntax-tools/issues'
+  }
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: rouge-ddot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Calpano
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.30'
+description: Syntax highlighter for the ddot.it knowledge graph notation. Plugs into
+  Rouge so any tool that uses Rouge for source highlighting (Asciidoctor, Jekyll,
+  GitLab, …) can colourise [source,ddot] blocks against the canonical token vocabulary.
+email:
+- hello@calpano.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rouge/lexers/ddot.rb
+- rouge-ddot.gemspec
+homepage: https://ddot.it
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/calpano/ddot.it-syntax-tools
+  bug_tracker_uri: https://github.com/calpano/ddot.it-syntax-tools/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Rouge lexer for ddot.it
+test_files: []