pygments-ddot 0.1.0__tar.gz

pygments_ddot-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: pygments-ddot
+Version: 0.1.0
+Summary: Pygments lexer for ddot.it (Knowledge Graph Notation).
+Author-email: Calpano <hello@calpano.com>
+License: MIT
+Project-URL: Homepage, https://ddot.it
+Project-URL: Source, https://github.com/Calpano/ddot.it-syntax-tools
+Keywords: pygments,ddot.it,syntax-highlighting,knowledge-graph
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Pygments>=2.10
+
+# pygments-ddot
+
+[Pygments](https://pygments.org) lexer for **ddot.it** — a minimal text
+format for typed knowledge graphs.
+
+## Install
+
+```sh
+pip install pygments-ddot
+```
+
+The package registers itself via the `pygments.lexers` entry point, so
+both `pygmentize` and any tool that uses `pygments.lexers.get_lexer_by_name`
+will pick up `ddot` automatically.
+
+## Use
+
+### From the command line
+
+```sh
+pygmentize -l ddot -f html sample.ddot > sample.html
+pygmentize -l ddot -f terminal sample.ddot
+```
+
+### From Python
+
+```python
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+
+code = open("sample.ddot").read()
+lexer = get_lexer_by_name("ddot")
+print(highlight(code, lexer, HtmlFormatter()))
+```
+
+Aliases registered: `ddot.it`, `ddot`, `ddotit`. File pattern: `*.ddot`.
+
+## Token mapping
+
+The lexer emits Pygments tokens chosen to map cleanly onto the canonical
+token vocabulary at
+[`ddot.it/test-data/tokens.md`](https://github.com/Calpano/ddot.it/blob/main/test-data/tokens.md).
+
+| Pygments token              | Canonical name |
+|-----------------------------|----------------|
+| `Name.Class`                | `subject`      |
+| `Name.Function`             | `relation`     |
+| `Literal.String.Symbol`     | `object`       |
+| `Operator`                  | `operator`     |
+| `Keyword.Pseudo`            | `command`      |
+| `Comment.Preproc`           | `meta-delim`   |
+| `Comment.Special.Operator`  | `meta-operator`|
+| `Comment.Special.Relation`  | `meta-relation`|
+| `Comment.Special.Object`    | `meta-object`  |
+| `Comment.Multiline`         | `meta-text`    |
+| `Comment.Single`            | `disabled`     |
+
+## Conformance
+
+The lexer is verified against the cross-implementation golden corpus —
+identical to the TextMate, Shiki, and Rouge ports. See
+[`tools/conformance-pygments.py`](https://github.com/Calpano/ddot.it-syntax-tools/blob/main/tools/conformance-pygments.py).
+
+## License
+
+MIT

pygments_ddot-0.1.0/README.md

@@ -0,0 +1,67 @@
+# pygments-ddot
+
+[Pygments](https://pygments.org) lexer for **ddot.it** — a minimal text
+format for typed knowledge graphs.
+
+## Install
+
+```sh
+pip install pygments-ddot
+```
+
+The package registers itself via the `pygments.lexers` entry point, so
+both `pygmentize` and any tool that uses `pygments.lexers.get_lexer_by_name`
+will pick up `ddot` automatically.
+
+## Use
+
+### From the command line
+
+```sh
+pygmentize -l ddot -f html sample.ddot > sample.html
+pygmentize -l ddot -f terminal sample.ddot
+```
+
+### From Python
+
+```python
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+
+code = open("sample.ddot").read()
+lexer = get_lexer_by_name("ddot")
+print(highlight(code, lexer, HtmlFormatter()))
+```
+
+Aliases registered: `ddot.it`, `ddot`, `ddotit`. File pattern: `*.ddot`.
+
+## Token mapping
+
+The lexer emits Pygments tokens chosen to map cleanly onto the canonical
+token vocabulary at
+[`ddot.it/test-data/tokens.md`](https://github.com/Calpano/ddot.it/blob/main/test-data/tokens.md).
+
+| Pygments token              | Canonical name |
+|-----------------------------|----------------|
+| `Name.Class`                | `subject`      |
+| `Name.Function`             | `relation`     |
+| `Literal.String.Symbol`     | `object`       |
+| `Operator`                  | `operator`     |
+| `Keyword.Pseudo`            | `command`      |
+| `Comment.Preproc`           | `meta-delim`   |
+| `Comment.Special.Operator`  | `meta-operator`|
+| `Comment.Special.Relation`  | `meta-relation`|
+| `Comment.Special.Object`    | `meta-object`  |
+| `Comment.Multiline`         | `meta-text`    |
+| `Comment.Single`            | `disabled`     |
+
+## Conformance
+
+The lexer is verified against the cross-implementation golden corpus —
+identical to the TextMate, Shiki, and Rouge ports. See
+[`tools/conformance-pygments.py`](https://github.com/Calpano/ddot.it-syntax-tools/blob/main/tools/conformance-pygments.py).
+
+## License
+
+MIT

pygments_ddot-0.1.0/pygments_ddot/__init__.py

@@ -0,0 +1,23 @@
+"""Pygments lexer for ddot.it (https://ddot.it).
+
+Emits Pygments tokens that — after the canonical-name mapping in
+`tools/conformance-pygments.py` — equal the canonical token streams in
+`../../ddot.it/test-data/cases/*/expected.tokens.json`.
+
+Token mapping (Pygments → 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.Special.Operator       → meta-operator
+  Comment.Special.Relation       → meta-relation
+  Comment.Special.Object         → meta-object
+  Comment.Multiline              → meta-text
+  Comment.Single                 → disabled
+"""
+
+from .lexer import DdotLexer
+
+__all__ = ["DdotLexer"]

pygments_ddot-0.1.0/pygments_ddot/lexer.py

@@ -0,0 +1,212 @@
+"""ddot.it Pygments lexer — direct port of the Rouge lexer in
+`../../rouge/lib/rouge/lexers/ddot.rb`. Both implementations share the same
+flat state machine: every state ends a line by transitioning back to
+`root`, so each `\\n` resets dispatch."""
+
+from pygments.lexer import RegexLexer
+from pygments.token import (
+    Comment,
+    Keyword,
+    Literal,
+    Name,
+    Operator,
+    Text,
+)
+
+OFF_RE = r"(?:ddot\.it/off|!!off)"
+ON_RE = r"(?:ddot\.it/on|!!on)"
+CMD_RE = r"(?:ddot\.it(?:/[\w.\-]+)?|!![\w.\-]*)"
+
+
+class DdotLexer(RegexLexer):
+    name = "ddot.it"
+    aliases = ["ddot.it", "ddot", "ddotit"]
+    filenames = ["*.ddot"]
+    mimetypes = ["text/x-ddot"]
+
+    tokens = {
+        # ─────────── line-dispatch root ───────────
+        "root": [
+            # Standalone `,,` opens a free-form meta block.
+            (r"^[ \t]*,,[ \t]*(?=\n|\Z)", Comment.Preproc, "meta_block"),
+            # Off marker enters disabled span.
+            (r"^[ \t]*" + OFF_RE + r"[ \t]*(?=\n|\Z)", Keyword.Pseudo, "disabled"),
+            # Empty / whitespace-only line.
+            (r"^[ \t]*\n", Text),
+            # Continuation line (starts with `..` or `....`).
+            (r"^(?=[ \t]*\.{2,4})", Text, "after_subject"),
+            # Triple line — start with subject parsing.
+            (r"^", Text, "subject"),
+        ],
+
+        # ─────────── disabled span ───────────
+        "disabled": [
+            (r"^[ \t]*" + ON_RE + r"[ \t]*(?=\n|\Z)", Keyword.Pseudo, "#pop"),
+            (r"^[ \t]*\n", Text),
+            (r"[^\n]+", Comment.Single),
+            (r"\n", Text),
+        ],
+
+        # ─────────── multi-line meta block (free-form) ───────────
+        "meta_block": [
+            (r"^[ \t]*,,[ \t]*(?=\n|\Z)", Comment.Preproc, "#pop"),
+            (r"^[ \t]*\n", Text),
+            (r"[^\n]+", Comment.Multiline),
+            (r"\n", Text),
+        ],
+
+        # ─────────── triple line: subject phase ───────────
+        "subject": [
+            (r"[ \t]+", Text),
+            (
+                CMD_RE + r"(?=[ \t]+\.{2,4}|[ \t]*,,|[ \t]*$|\n|\Z)",
+                Keyword.Pseudo,
+                ("#pop", "after_subject"),
+            ),
+            (
+                r"[^\s.,][^\n,]*?(?=[ \t]+\.{2,4}|[ \t]*,,|[ \t]*$|\n|\Z)",
+                Name.Class,
+                ("#pop", "after_subject"),
+            ),
+            (r"\n", Text, "#pop"),
+        ],
+
+        # ─────────── after subject (or continuation entry) ───────────
+        "after_subject": [
+            (r"[ \t]+", Text),
+            # `.. ..` (spaced operator) — one token covering both dots+space,
+            # matching the canonical corpus.
+            (r"\.{2}[ \t]+\.{2}", Operator, ("#pop", "object")),
+            (r"\.{4}", Operator, ("#pop", "object")),
+            (r"\.{2}", Operator, ("#pop", "relation")),
+            (r",,", Comment.Preproc, ("#pop", "inline_meta")),
+            (r"\n", Text, "#pop"),
+        ],
+
+        # ─────────── relation phase ───────────
+        "relation": [
+            (
+                r"[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\Z)",
+                Name.Function,
+                ("#pop", "after_relation"),
+            ),
+            (r"[ \t]+", Text),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "after_relation": [
+            (r"[ \t]+", Text),
+            (r"\.{2}", Operator, ("#pop", "object")),
+            (r",,", Comment.Preproc, ("#pop", "inline_meta")),
+            (r"\n", Text, "#pop"),
+        ],
+
+        # ─────────── object phase ───────────
+        "object": [
+            (
+                r"[^\s,][^\n,]*?(?=[ \t]*,,|[ \t]*$|\n|\Z)",
+                Literal.String.Symbol,
+                ("#pop", "after_object"),
+            ),
+            (r"[ \t]+", Text),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "after_object": [
+            (r"[ \t]+", Text),
+            # Trailing `,,` at end of line opens a typed multi-line meta block.
+            (
+                r",,(?=[ \t]*(?:\n|\Z))",
+                Comment.Preproc,
+                ("#pop", "typed_meta_open"),
+            ),
+            # Inline `,,` followed by content on the same line.
+            (r",,", Comment.Preproc, ("#pop", "inline_meta")),
+            (r"\n", Text, "#pop"),
+        ],
+
+        # Right after trailing `,,` — wait for newline, then enter the block.
+        "typed_meta_open": [
+            (r"[ \t]+", Text),
+            (r"\n", Text, ("#pop", "typed_meta_block")),
+        ],
+
+        # Typed meta block: each line is `..rel.. obj`, closed by standalone `,,`.
+        "typed_meta_block": [
+            (r"^[ \t]*,,[ \t]*(?=\n|\Z)", Comment.Preproc, "#pop"),
+            (r"^[ \t]*\n", Text),
+            (r"^(?=[ \t]*\.{2,4})", Text, "typed_meta_op1"),
+            (r"[^\n]+", Comment.Multiline),
+            (r"\n", Text),
+        ],
+
+        "typed_meta_op1": [
+            (r"[ \t]+", Text),
+            (r"\.{2}", Comment.Special.Operator, ("#pop", "typed_meta_relation")),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "typed_meta_relation": [
+            (
+                r"[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\Z)",
+                Comment.Special.Relation,
+                ("#pop", "typed_meta_after_relation"),
+            ),
+            (r"[ \t]+", Text),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "typed_meta_after_relation": [
+            (r"[ \t]+", Text),
+            (r"\.{2}", Comment.Special.Operator, ("#pop", "typed_meta_object")),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "typed_meta_object": [
+            (
+                r"[^\s,][^\n,]*?(?=[ \t]*$|\n|\Z)",
+                Comment.Special.Object,
+                ("#pop", "typed_meta_after_object"),
+            ),
+            (r"[ \t]+", Text),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "typed_meta_after_object": [
+            (r"[ \t]+", Text),
+            (r"\n", Text, "#pop"),
+        ],
+
+        # ─────────── inline metadata (after `,,` on a triple line) ───────────
+        "inline_meta": [
+            (r"[ \t]+", Text),
+            (r"\.{2}", Comment.Special.Operator, ("#pop", "inline_meta_relation")),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "inline_meta_relation": [
+            (
+                r"[^\s.,][^\n.,]*?(?=[ \t]*\.{2}|[ \t]*$|\n|\Z)",
+                Comment.Special.Relation,
+                ("#pop", "inline_meta_after_relation"),
+            ),
+            (r"[ \t]+", Text),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "inline_meta_after_relation": [
+            (r"[ \t]+", Text),
+            (r"\.{2}", Comment.Special.Operator, ("#pop", "inline_meta_object")),
+            (r"\n", Text, "#pop"),
+        ],
+
+        "inline_meta_object": [
+            (
+                r"[^\s,][^\n,]*?(?=[ \t]*$|\n|\Z)",
+                Comment.Special.Object,
+                ("#pop", "after_object"),
+            ),
+            (r"[ \t]+", Text),
+            (r"\n", Text, "#pop"),
+        ],
+    }

pygments_ddot-0.1.0/pygments_ddot.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: pygments-ddot
+Version: 0.1.0
+Summary: Pygments lexer for ddot.it (Knowledge Graph Notation).
+Author-email: Calpano <hello@calpano.com>
+License: MIT
+Project-URL: Homepage, https://ddot.it
+Project-URL: Source, https://github.com/Calpano/ddot.it-syntax-tools
+Keywords: pygments,ddot.it,syntax-highlighting,knowledge-graph
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Pygments>=2.10
+
+# pygments-ddot
+
+[Pygments](https://pygments.org) lexer for **ddot.it** — a minimal text
+format for typed knowledge graphs.
+
+## Install
+
+```sh
+pip install pygments-ddot
+```
+
+The package registers itself via the `pygments.lexers` entry point, so
+both `pygmentize` and any tool that uses `pygments.lexers.get_lexer_by_name`
+will pick up `ddot` automatically.
+
+## Use
+
+### From the command line
+
+```sh
+pygmentize -l ddot -f html sample.ddot > sample.html
+pygmentize -l ddot -f terminal sample.ddot
+```
+
+### From Python
+
+```python
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+
+code = open("sample.ddot").read()
+lexer = get_lexer_by_name("ddot")
+print(highlight(code, lexer, HtmlFormatter()))
+```
+
+Aliases registered: `ddot.it`, `ddot`, `ddotit`. File pattern: `*.ddot`.
+
+## Token mapping
+
+The lexer emits Pygments tokens chosen to map cleanly onto the canonical
+token vocabulary at
+[`ddot.it/test-data/tokens.md`](https://github.com/Calpano/ddot.it/blob/main/test-data/tokens.md).
+
+| Pygments token              | Canonical name |
+|-----------------------------|----------------|
+| `Name.Class`                | `subject`      |
+| `Name.Function`             | `relation`     |
+| `Literal.String.Symbol`     | `object`       |
+| `Operator`                  | `operator`     |
+| `Keyword.Pseudo`            | `command`      |
+| `Comment.Preproc`           | `meta-delim`   |
+| `Comment.Special.Operator`  | `meta-operator`|
+| `Comment.Special.Relation`  | `meta-relation`|
+| `Comment.Special.Object`    | `meta-object`  |
+| `Comment.Multiline`         | `meta-text`    |
+| `Comment.Single`            | `disabled`     |
+
+## Conformance
+
+The lexer is verified against the cross-implementation golden corpus —
+identical to the TextMate, Shiki, and Rouge ports. See
+[`tools/conformance-pygments.py`](https://github.com/Calpano/ddot.it-syntax-tools/blob/main/tools/conformance-pygments.py).
+
+## License
+
+MIT

pygments_ddot-0.1.0/pygments_ddot.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+pygments_ddot/__init__.py
+pygments_ddot/lexer.py
+pygments_ddot.egg-info/PKG-INFO
+pygments_ddot.egg-info/SOURCES.txt
+pygments_ddot.egg-info/dependency_links.txt
+pygments_ddot.egg-info/entry_points.txt
+pygments_ddot.egg-info/requires.txt
+pygments_ddot.egg-info/top_level.txt

pygments_ddot-0.1.0/pygments_ddot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pygments_ddot-0.1.0/pygments_ddot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pygments.lexers]
+ddot = pygments_ddot:DdotLexer

pygments_ddot-0.1.0/pygments_ddot.egg-info/requires.txt

@@ -0,0 +1 @@
+Pygments>=2.10

pygments_ddot-0.1.0/pygments_ddot.egg-info/top_level.txt

@@ -0,0 +1 @@
+pygments_ddot

pygments_ddot-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pygments-ddot"
+version = "0.1.0"
+description = "Pygments lexer for ddot.it (Knowledge Graph Notation)."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Calpano", email = "hello@calpano.com" }]
+requires-python = ">=3.8"
+dependencies = ["Pygments>=2.10"]
+keywords = ["pygments", "ddot.it", "syntax-highlighting", "knowledge-graph"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Text Processing :: Markup",
+]
+
+[project.urls]
+Homepage = "https://ddot.it"
+Source = "https://github.com/Calpano/ddot.it-syntax-tools"
+
+# Pygments discovers third-party lexers via this entry point.
+# After `pip install pygments-ddot`, `pygmentize -l ddot file.ddot` works.
+[project.entry-points."pygments.lexers"]
+ddot = "pygments_ddot:DdotLexer"
+
+[tool.setuptools.packages.find]
+include = ["pygments_ddot*"]

pygments_ddot-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+