PyPI - lhtml-markup - Versions diffs - 2.3.0__tar.gz → 2.4.1__tar.gz - Mend

lhtml-markup 2.3.0tar.gz → 2.4.1tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

{lhtml_markup-2.3.0 → lhtml_markup-2.4.1}/PKG-INFO RENAMED Viewed

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: lhtml-markup
-Version: 2.3.0
+Version: 2.4.1
 Summary: Lightweight HTML markup language — simplifies HTML authoring with shorthand syntax
 License: MIT
 Project-URL: Homepage, https://github.com/drohmer/lhtml
 Project-URL: Repository, https://github.com/drohmer/lhtml
 Project-URL: Issues, https://github.com/drohmer/lhtml/issues
+Project-URL: Changelog, https://github.com/drohmer/lhtml/blob/main/CHANGELOG.md
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
@@ -14,18 +15,19 @@ Requires-Dist: pygments>=2.15
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
-Requires-Dist: ansicolors; extra == "dev"
 Dynamic: license-file
 # LHTML — Lightweight HTML
-[![Tests](https://github.com/drohmer/lhtml/actions/workflows/tests.yml/badge.svg?branch=feature/lhtml-v2)](https://github.com/drohmer/lhtml/actions/workflows/tests.yml)
+[![Tests](https://github.com/drohmer/lhtml/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/drohmer/lhtml/actions/workflows/tests.yml)
 [![PyPI](https://img.shields.io/pypi/v/lhtml-markup)](https://pypi.org/project/lhtml-markup/)
 LHTML is a markup language that simplifies HTML authoring with embedded CSS styling. It is designed to be **HTML-first**: raw HTML passes through untouched, and only a few shorthand symbols (`::`, `*`, `=`, `**`, `__`) trigger conversions.
 LHTML is used to build static websites and presentation slides, typically combined with Jinja2 templates.
+See the [examples](examples/) and the [changelog](CHANGELOG.md).
 ## Installation
 From PyPI:
@@ -58,14 +60,44 @@ Dependencies (`lark`, `pygments`, `pyyaml`) are installed automatically.
 ```bash
 lhtml input.l.html                    # Convert to stdout
 lhtml input.l.html -o output.html     # Convert to file
-lhtml input.l.html -w                 # Wrap in full HTML document
-lhtml input.l.html -b                 # Render source line breaks as <br>
+lhtml input.l.html -w                 # Wrap in full HTML document (--wrapAuto)
+lhtml input.l.html -b                 # Render source line breaks as <br> (--line-breaks)
 lhtml a.l.html b.l.html               # Several files: a.html, b.html next to sources
 lhtml a.l.html b.l.html -o build/     # Several files into a directory
 python -m lhtml input.l.html          # Alternative invocation
+lhtml --version                       # Show the version (also lhtml.__version__)
 ```
-Files are read and written as UTF-8 (a BOM is accepted). Errors and warnings are reported on stderr with the file name, the remaining files are still processed, and the exit code is non-zero if any file failed. An input file is never overwritten (e.g. `lhtml page.html` without `-o`). Includes are looked up in the input file's directory first, then in the current directory.
+Without `-o`, `page.l.html` is written to `page.html` next to its source.
+- Files are read and written as UTF-8 (a BOM is accepted).
+- Errors and warnings are reported on stderr with the file name. The remaining files are still processed, and the exit code is non-zero if any file failed.
+- An input file is never overwritten: `lhtml page.html` (output `page.html`) is an error, as is an output that is another input of the batch, or a symbolic or hard link to one.
+- Includes are looked up in the input file's directory first, then in the current directory.
+With `-w`, the result is wrapped in a minimal HTML document using the `title`, `css` and `js` of the front matter:
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<title>My Page</title>
+	<link rel="stylesheet" type="text/css" href="style.css">
+	<script src="app.js" defer></script>
+</head>
+<body>
+<h1>Hello</h1>
+</body>
+</html>
+```
 ### Python API
@@ -114,13 +146,33 @@ With classes/IDs:
 ```
 * First item
 * Second item
-** Nested item A
-** Nested item B
-*** Deep nested
+** Nested item
 * Back to top level
 ```
-Produces nested `<ul><li>` structures.
+Output (a nested list is placed in its own `<li>`):
+```html
+<ul>
+<li>
+First item
+</li>
+<li>
+Second item
+</li>
+<li>
+<ul>
+<li>
+Nested item
+</li>
+</ul>
+</li>
+<li>
+Back to top level
+</li>
+</ul>
+```
+Each `*` adds one level (`***` is level 3). A list ends at the first line that is not an item.
 ### Inline Formatting
@@ -155,7 +207,7 @@ Tag names start with a letter and may contain letters, digits, `_` and `-` (usef
 A closing `::` may be directly followed by punctuation or HTML (`**span::[c] x ::**`, `important ::,`). In a run of colons, `::` markers are the pairs ending the run: `::::[...]` is a closing `::` followed by `::[...]`, and `x:::nl` is `x:` followed by `::nl`. A `::` between two HTML tags (as in pre-highlighted code `<span>::</span>`) is left untouched.
-A tag that is opened but never closed, or a `::` without matching opening tag, produces an `LHTMLWarning` quoting the beginning of the tag.
+A tag that is opened but never closed, or a `::` without matching opening tag, produces an `LHTMLWarning` quoting the beginning of the tag. An unmatched `::` is kept as text in the output.
 #### Div / Span with Styles
@@ -219,10 +271,29 @@ Output:
 <div style="color:blue;"> short text </div>
 ```
+#### Explicit Closing Tags
+A bare `::` closes the last opened tag. To make long or nested blocks easier to read, name the tag you close with `::name[-]` (`::[-]` closes the last one, like `::`):
+```
+div::[color:red;]
+Red **text**
+::div[-]
+```
+Output:
+```html
+<div style="color:red;">
+Red <strong>text</strong>
+</div>
+```
+If the name does not match the last opened tag, a `LHTMLWarning` is emitted and the last opened tag is closed.
 ### Links
-The URL of `link::`, `img::`, `video::` and `videoplay::` is never modified (`__`, `**`, `$` are kept). Parentheses that are part of the URL are kept (`Mercury_(planet)`, `fig(1).png`), while a group starting with `.` or `#` is a class/id group.
+The URL of `link::`, `img::`, `video::` and `videoplay::` is never modified (`__`, `**`, `$` are kept). Parentheses that are part of the URL are kept (`Mercury_(planet)`, `fig(1).png`), while a group starting with `.` or `#` is a class/id group. The URL may contain Jinja expressions (`img::{{ base }}/photo.jpg`, `link::{{ url_for('page') }}[Home]`), which are kept unchanged.
 ```
 link::https://example.com[Click here]
@@ -267,7 +338,22 @@ def hello():
 code::[-]
 ````
-`include::file` directives inside a code block insert the file as raw code. Syntax highlighting is powered by Pygments. Any language supported by Pygments can be used. An empty language (`code::[]`) renders plain text; an unknown language renders plain text with a warning.
+Output (Pygments HTML inside `<div class="code">`):
+```html
+<div class="code"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">hello</span><span class="p">():</span>
+...
+</pre></div>
+```
+Syntax highlighting is powered by Pygments: any language supported by Pygments can be used, case-insensitively. An empty language (`code::[]`) renders plain text; an unknown language renders plain text with a warning. The built-in `c++` language is C++ with the types of the [CGP library](https://github.com/drohmer/cgp) highlighted; other languages can be added (see [Custom Code Lexers](#custom-code-lexers)).
+The colors come from a Pygments stylesheet, which you must include in your page. Generate one for the `.code` class (any [Pygments style](https://pygments.org/styles/) can replace `default`):
+```bash
+pygmentize -S default -f html -a .code > code.css
+```
+`include::file` directives inside a code block insert the file as raw code.
 ### Spacer
@@ -355,6 +441,50 @@ Supported metadata keys:
 | `directory_include` | list | Directories to search for includes |
+## Using LHTML with Jinja2
+LHTML leaves Jinja2 untouched, so a template can be written in LHTML: convert it to HTML first, then render it with Jinja2 (`pip install jinja2`).
+`blog.l.html`:
+```
+= {{ page.title }}
+{% for post in posts %}
+div::(.post)
+== link::{{ post.url }}[{{ post.title }}]
+{{ post.summary }} **Read more**
+::
+{% endfor %}
+```
+```python
+import jinja2
+import lhtml
+with open('blog.l.html', encoding='utf-8') as f:
+    template = jinja2.Template(lhtml.run(f.read()))
+html = template.render(page={'title': 'Blog'},
+                       posts=[{'url': 'first.html', 'title': 'First post', 'summary': 'Hello.'}])
+```
+`lhtml.run()` produces the Jinja2 template:
+```html
+<h1>{{ page.title }}</h1>
+{% for post in posts %}
+<div class="post">
+<h2><a href="{{ post.url }}">{{ post.title }}</a></h2>
+{{ post.summary }} <strong>Read more</strong>
+</div>
+{% endfor %}
+```
+Jinja2 expressions can also be used in URLs (`img::{{ base }}/photo.jpg`) and in tag groups (`div::[color:{{ color }};]`).
 ## Plugin System
 ### Custom Tag Handlers
@@ -421,7 +551,7 @@ All keys for the `meta` dict passed to `lhtml.run()`:
     'title': 'Webpage',        # Document title
     'css': [],                 # CSS files (string or list)
     'js': [],                  # JS files (string or list)
-    'directory_include': [],   # Search paths for include::
+    'directory_include': [cwd],  # Search paths for include:: (default: current directory)
     'current_directory': '',   # Base directory for video codec detection
 }
 ```
@@ -429,7 +559,9 @@ All keys for the `meta` dict passed to `lhtml.run()`:
 ## Design Principles
-- **HTML-first**: Raw HTML is never modified. Only LHTML syntax triggers conversions. In particular, the following are never transformed (not even by `include::` or `::#`): HTML tags and their attributes (URLs containing `__`, quoted values containing `>`, ...), `<script>` and `<style>` blocks (CSS `::before`, ...), HTML comments, and math (`$...$`, `$$...$$`, `\(...\)`, `\[...\]`, so that `$x**2$` reaches MathJax/KaTeX intact). Text between HTML tags is still processed.
+- **HTML-first**: Raw HTML is never modified. Only LHTML syntax triggers conversions. In particular, the following are never transformed (not even by `include::` or `::#`): HTML tags and their attributes, including tags spanning multiple lines (URLs containing `__`, quoted values containing `>`, ...), `<script>` and `<style>` blocks (CSS `::before`, ...), HTML comments, and math (`$...$`, `$$...$$`, `\(...\)`, `\[...\]`, so that `$x**2$` reaches MathJax/KaTeX intact). Text between HTML tags is still processed.
+- **Attributes stay literal**: styles, classes/IDs and HTML attributes in LHTML tag groups and headings are preserved without inline formatting (`div::(.my__class__)` keeps `my__class__`). Link labels still support formatting.
+- **Template-friendly**: Jinja2 expressions (`{{ ... }}`), statements (`{% ... %}`) and comments (`{# ... #}`) pass through unchanged (see [Using LHTML with Jinja2](#using-lhtml-with-jinja2)).
 - **Island grammar**: LHTML syntax "islands" float in a sea of opaque content (HTML, Jinja2 templates, LaTeX, etc.) that passes through untouched.
 - **Minimal**: A few symbols (`::`, `=`, `*`, `**`, `__`, `` ` ``) cover most needs. No complex configuration required.
 - **Composable**: LHTML works seamlessly with Jinja2 templates, making it suitable for static site generators.
@@ -440,20 +572,27 @@ All keys for the `meta` dict passed to `lhtml.run()`:
 ```
 src/lhtml/
   __init__.py          # Public API: run(), analyse_tag(), read_yaml()
+  __main__.py          # python -m lhtml
   cli.py               # Command-line interface
   pipeline.py          # ProcessingPipeline, TagRegistry, LexerRegistry
   process.py           # Core transformation functions
   patterns.py          # Centralized regex patterns and utilities
   tag_parser.py        # Lark-based parser for :: bracket syntax
   tag_element.lark     # Lark grammar definition
+  element_extract.py   # extract_bracket_elements() (entry point of the tag parser)
   export_html.py       # HTML generation for tag elements
   listing.py           # List processing
   code.py              # Code syntax highlighting (Pygments)
   wrap_html.py         # HTML document wrapping
   errors.py            # Structured error types
+  insert_in_text.py    # Store/restore helpers kept for backward compatibility
+test/                  # pytest suite and .l.html / -out.html reference pairs
+examples/              # Example sources (see examples/README.md)
 ```
+Run the tests with `pytest` (after `pip install -e ".[dev]"`).
 ## License
-MIT
+MIT, see [LICENSE.md](LICENSE.md).

{lhtml_markup-2.3.0 → lhtml_markup-2.4.1}/README.md RENAMED Viewed

@@ -1,12 +1,14 @@
 # LHTML — Lightweight HTML
-[![Tests](https://github.com/drohmer/lhtml/actions/workflows/tests.yml/badge.svg?branch=feature/lhtml-v2)](https://github.com/drohmer/lhtml/actions/workflows/tests.yml)
+[![Tests](https://github.com/drohmer/lhtml/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/drohmer/lhtml/actions/workflows/tests.yml)
 [![PyPI](https://img.shields.io/pypi/v/lhtml-markup)](https://pypi.org/project/lhtml-markup/)
 LHTML is a markup language that simplifies HTML authoring with embedded CSS styling. It is designed to be **HTML-first**: raw HTML passes through untouched, and only a few shorthand symbols (`::`, `*`, `=`, `**`, `__`) trigger conversions.
 LHTML is used to build static websites and presentation slides, typically combined with Jinja2 templates.
+See the [examples](examples/) and the [changelog](CHANGELOG.md).
 ## Installation
 From PyPI:
@@ -39,14 +41,44 @@ Dependencies (`lark`, `pygments`, `pyyaml`) are installed automatically.
 ```bash
 lhtml input.l.html                    # Convert to stdout
 lhtml input.l.html -o output.html     # Convert to file
-lhtml input.l.html -w                 # Wrap in full HTML document
-lhtml input.l.html -b                 # Render source line breaks as <br>
+lhtml input.l.html -w                 # Wrap in full HTML document (--wrapAuto)
+lhtml input.l.html -b                 # Render source line breaks as <br> (--line-breaks)
 lhtml a.l.html b.l.html               # Several files: a.html, b.html next to sources
 lhtml a.l.html b.l.html -o build/     # Several files into a directory
 python -m lhtml input.l.html          # Alternative invocation
+lhtml --version                       # Show the version (also lhtml.__version__)
 ```
-Files are read and written as UTF-8 (a BOM is accepted). Errors and warnings are reported on stderr with the file name, the remaining files are still processed, and the exit code is non-zero if any file failed. An input file is never overwritten (e.g. `lhtml page.html` without `-o`). Includes are looked up in the input file's directory first, then in the current directory.
+Without `-o`, `page.l.html` is written to `page.html` next to its source.
+- Files are read and written as UTF-8 (a BOM is accepted).
+- Errors and warnings are reported on stderr with the file name. The remaining files are still processed, and the exit code is non-zero if any file failed.
+- An input file is never overwritten: `lhtml page.html` (output `page.html`) is an error, as is an output that is another input of the batch, or a symbolic or hard link to one.
+- Includes are looked up in the input file's directory first, then in the current directory.
+With `-w`, the result is wrapped in a minimal HTML document using the `title`, `css` and `js` of the front matter:
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<title>My Page</title>
+	<link rel="stylesheet" type="text/css" href="style.css">
+	<script src="app.js" defer></script>
+</head>
+<body>
+<h1>Hello</h1>
+</body>
+</html>
+```
 ### Python API
@@ -95,13 +127,33 @@ With classes/IDs:
 ```
 * First item
 * Second item
-** Nested item A
-** Nested item B
-*** Deep nested
+** Nested item
 * Back to top level
 ```
-Produces nested `<ul><li>` structures.
+Output (a nested list is placed in its own `<li>`):
+```html
+<ul>
+<li>
+First item
+</li>
+<li>
+Second item
+</li>
+<li>
+<ul>
+<li>
+Nested item
+</li>
+</ul>
+</li>
+<li>
+Back to top level
+</li>
+</ul>
+```
+Each `*` adds one level (`***` is level 3). A list ends at the first line that is not an item.
 ### Inline Formatting
@@ -136,7 +188,7 @@ Tag names start with a letter and may contain letters, digits, `_` and `-` (usef
 A closing `::` may be directly followed by punctuation or HTML (`**span::[c] x ::**`, `important ::,`). In a run of colons, `::` markers are the pairs ending the run: `::::[...]` is a closing `::` followed by `::[...]`, and `x:::nl` is `x:` followed by `::nl`. A `::` between two HTML tags (as in pre-highlighted code `<span>::</span>`) is left untouched.
-A tag that is opened but never closed, or a `::` without matching opening tag, produces an `LHTMLWarning` quoting the beginning of the tag.
+A tag that is opened but never closed, or a `::` without matching opening tag, produces an `LHTMLWarning` quoting the beginning of the tag. An unmatched `::` is kept as text in the output.
 #### Div / Span with Styles
@@ -200,10 +252,29 @@ Output:
 <div style="color:blue;"> short text </div>
 ```
+#### Explicit Closing Tags
+A bare `::` closes the last opened tag. To make long or nested blocks easier to read, name the tag you close with `::name[-]` (`::[-]` closes the last one, like `::`):
+```
+div::[color:red;]
+Red **text**
+::div[-]
+```
+Output:
+```html
+<div style="color:red;">
+Red <strong>text</strong>
+</div>
+```
+If the name does not match the last opened tag, a `LHTMLWarning` is emitted and the last opened tag is closed.
 ### Links
-The URL of `link::`, `img::`, `video::` and `videoplay::` is never modified (`__`, `**`, `$` are kept). Parentheses that are part of the URL are kept (`Mercury_(planet)`, `fig(1).png`), while a group starting with `.` or `#` is a class/id group.
+The URL of `link::`, `img::`, `video::` and `videoplay::` is never modified (`__`, `**`, `$` are kept). Parentheses that are part of the URL are kept (`Mercury_(planet)`, `fig(1).png`), while a group starting with `.` or `#` is a class/id group. The URL may contain Jinja expressions (`img::{{ base }}/photo.jpg`, `link::{{ url_for('page') }}[Home]`), which are kept unchanged.
 ```
 link::https://example.com[Click here]
@@ -248,7 +319,22 @@ def hello():
 code::[-]
 ````
-`include::file` directives inside a code block insert the file as raw code. Syntax highlighting is powered by Pygments. Any language supported by Pygments can be used. An empty language (`code::[]`) renders plain text; an unknown language renders plain text with a warning.
+Output (Pygments HTML inside `<div class="code">`):
+```html
+<div class="code"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">hello</span><span class="p">():</span>
+...
+</pre></div>
+```
+Syntax highlighting is powered by Pygments: any language supported by Pygments can be used, case-insensitively. An empty language (`code::[]`) renders plain text; an unknown language renders plain text with a warning. The built-in `c++` language is C++ with the types of the [CGP library](https://github.com/drohmer/cgp) highlighted; other languages can be added (see [Custom Code Lexers](#custom-code-lexers)).
+The colors come from a Pygments stylesheet, which you must include in your page. Generate one for the `.code` class (any [Pygments style](https://pygments.org/styles/) can replace `default`):
+```bash
+pygmentize -S default -f html -a .code > code.css
+```
+`include::file` directives inside a code block insert the file as raw code.
 ### Spacer
@@ -336,6 +422,50 @@ Supported metadata keys:
 | `directory_include` | list | Directories to search for includes |
+## Using LHTML with Jinja2
+LHTML leaves Jinja2 untouched, so a template can be written in LHTML: convert it to HTML first, then render it with Jinja2 (`pip install jinja2`).
+`blog.l.html`:
+```
+= {{ page.title }}
+{% for post in posts %}
+div::(.post)
+== link::{{ post.url }}[{{ post.title }}]
+{{ post.summary }} **Read more**
+::
+{% endfor %}
+```
+```python
+import jinja2
+import lhtml
+with open('blog.l.html', encoding='utf-8') as f:
+    template = jinja2.Template(lhtml.run(f.read()))
+html = template.render(page={'title': 'Blog'},
+                       posts=[{'url': 'first.html', 'title': 'First post', 'summary': 'Hello.'}])
+```
+`lhtml.run()` produces the Jinja2 template:
+```html
+<h1>{{ page.title }}</h1>
+{% for post in posts %}
+<div class="post">
+<h2><a href="{{ post.url }}">{{ post.title }}</a></h2>
+{{ post.summary }} <strong>Read more</strong>
+</div>
+{% endfor %}
+```
+Jinja2 expressions can also be used in URLs (`img::{{ base }}/photo.jpg`) and in tag groups (`div::[color:{{ color }};]`).
 ## Plugin System
 ### Custom Tag Handlers
@@ -402,7 +532,7 @@ All keys for the `meta` dict passed to `lhtml.run()`:
     'title': 'Webpage',        # Document title
     'css': [],                 # CSS files (string or list)
     'js': [],                  # JS files (string or list)
-    'directory_include': [],   # Search paths for include::
+    'directory_include': [cwd],  # Search paths for include:: (default: current directory)
     'current_directory': '',   # Base directory for video codec detection
 }
 ```
@@ -410,7 +540,9 @@ All keys for the `meta` dict passed to `lhtml.run()`:
 ## Design Principles
-- **HTML-first**: Raw HTML is never modified. Only LHTML syntax triggers conversions. In particular, the following are never transformed (not even by `include::` or `::#`): HTML tags and their attributes (URLs containing `__`, quoted values containing `>`, ...), `<script>` and `<style>` blocks (CSS `::before`, ...), HTML comments, and math (`$...$`, `$$...$$`, `\(...\)`, `\[...\]`, so that `$x**2$` reaches MathJax/KaTeX intact). Text between HTML tags is still processed.
+- **HTML-first**: Raw HTML is never modified. Only LHTML syntax triggers conversions. In particular, the following are never transformed (not even by `include::` or `::#`): HTML tags and their attributes, including tags spanning multiple lines (URLs containing `__`, quoted values containing `>`, ...), `<script>` and `<style>` blocks (CSS `::before`, ...), HTML comments, and math (`$...$`, `$$...$$`, `\(...\)`, `\[...\]`, so that `$x**2$` reaches MathJax/KaTeX intact). Text between HTML tags is still processed.
+- **Attributes stay literal**: styles, classes/IDs and HTML attributes in LHTML tag groups and headings are preserved without inline formatting (`div::(.my__class__)` keeps `my__class__`). Link labels still support formatting.
+- **Template-friendly**: Jinja2 expressions (`{{ ... }}`), statements (`{% ... %}`) and comments (`{# ... #}`) pass through unchanged (see [Using LHTML with Jinja2](#using-lhtml-with-jinja2)).
 - **Island grammar**: LHTML syntax "islands" float in a sea of opaque content (HTML, Jinja2 templates, LaTeX, etc.) that passes through untouched.
 - **Minimal**: A few symbols (`::`, `=`, `*`, `**`, `__`, `` ` ``) cover most needs. No complex configuration required.
 - **Composable**: LHTML works seamlessly with Jinja2 templates, making it suitable for static site generators.
@@ -421,20 +553,27 @@ All keys for the `meta` dict passed to `lhtml.run()`:
 ```
 src/lhtml/
   __init__.py          # Public API: run(), analyse_tag(), read_yaml()
+  __main__.py          # python -m lhtml
   cli.py               # Command-line interface
   pipeline.py          # ProcessingPipeline, TagRegistry, LexerRegistry
   process.py           # Core transformation functions
   patterns.py          # Centralized regex patterns and utilities
   tag_parser.py        # Lark-based parser for :: bracket syntax
   tag_element.lark     # Lark grammar definition
+  element_extract.py   # extract_bracket_elements() (entry point of the tag parser)
   export_html.py       # HTML generation for tag elements
   listing.py           # List processing
   code.py              # Code syntax highlighting (Pygments)
   wrap_html.py         # HTML document wrapping
   errors.py            # Structured error types
+  insert_in_text.py    # Store/restore helpers kept for backward compatibility
+test/                  # pytest suite and .l.html / -out.html reference pairs
+examples/              # Example sources (see examples/README.md)
 ```
+Run the tests with `pytest` (after `pip install -e ".[dev]"`).
 ## License
-MIT
+MIT, see [LICENSE.md](LICENSE.md).

{lhtml_markup-2.3.0 → lhtml_markup-2.4.1}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "lhtml-markup"
-version = "2.3.0"
+dynamic = ["version"]
 description = "Lightweight HTML markup language — simplifies HTML authoring with shorthand syntax"
 readme = "README.md"
 license = {text = "MIT"}
@@ -19,16 +19,19 @@ dependencies = [
 Homepage = "https://github.com/drohmer/lhtml"
 Repository = "https://github.com/drohmer/lhtml"
 Issues = "https://github.com/drohmer/lhtml/issues"
+Changelog = "https://github.com/drohmer/lhtml/blob/main/CHANGELOG.md"
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0",
-    "ansicolors",
 ]
 [project.scripts]
 lhtml = "lhtml:main"
+[tool.setuptools.dynamic]
+version = {attr = "lhtml.__version__"}
 [tool.setuptools.packages.find]
 where = ["src"]

{lhtml_markup-2.3.0 → lhtml_markup-2.4.1}/src/lhtml/__init__.py RENAMED Viewed

@@ -9,6 +9,8 @@ Usage:
     html = lhtml.run(text, {'wrap-auto': True, 'title': 'My Page'})
 """
+__version__ = '2.4.1'
 from .element_extract import extract_bracket_elements
 from .insert_in_text import insert_element_from_index, remove_element_to_index
 from .wrap_html import wrap_auto
@@ -70,7 +72,7 @@ def main():
 __all__ = [
     # Core API
-    'run', 'analyse_tag', 'read_yaml', 'main',
+    '__version__', 'run', 'analyse_tag', 'read_yaml', 'main',
     # Processing functions
     'extract_bracket_elements',
     'process_yaml', 'process_verbatim_to_index', 'process_verbatim_back_from_index',

{lhtml_markup-2.3.0 → lhtml_markup-2.4.1}/src/lhtml/cli.py RENAMED Viewed

@@ -6,6 +6,7 @@ Usage:
     lhtml [-w] a.l.html b.l.html                  # Multiple files → .html next to sources
     lhtml [-w] a.l.html b.l.html -o build/        # Multiple files → output directory
     lhtml -b file.l.html                          # Source line breaks rendered as <br>
+    lhtml --version
     python -m lhtml [same options]
 """
@@ -14,6 +15,7 @@ import sys
 import argparse
 import warnings
+from . import __version__
 from .errors import LHTMLError
 from .pipeline import ProcessingPipeline
 from .process import read_source
@@ -84,6 +86,8 @@ def main():
                         action='store_true')
     parser.add_argument('-o', '--output',
                         help='Output file (single input) or directory (multiple inputs)')
+    parser.add_argument('-V', '--version', action='version',
+                        version=f'lhtml {__version__}')
     args = parser.parse_args()
     meta = {'directory_include': [os.getcwd() + '/']}
@@ -118,7 +122,10 @@ def main():
                 continue
             out_path = _output_path_for(f_in, args.output)
-            if os.path.abspath(out_path) == os.path.abspath(f_in):
+            if any(os.path.realpath(out_path) == os.path.realpath(source)
+                   or (os.path.exists(out_path) and os.path.exists(source)
+                       and os.path.samefile(out_path, source))
+                   for source in args.inputFiles):
                 raise ValueError(f'output file would overwrite the input file [{out_path}]')
             out_dir = os.path.dirname(out_path)
             if out_dir:

{lhtml_markup-2.3.0 → lhtml_markup-2.4.1}/src/lhtml/export_html.py RENAMED Viewed

@@ -9,6 +9,8 @@ import html
 import os
 import re
+from .patterns import JINJA_RE
 # ---------------------------------------------------------------------------
 # Attribute helpers
@@ -24,8 +26,15 @@ def _build_attrs(elements):
 def _attr(value):
-    """Escape the double quotes of a value placed inside a double-quoted HTML attribute."""
-    return value.replace('"', '&quot;')
+    """Escape the double quotes of a value placed inside a double-quoted HTML
+    attribute (Jinja zones are kept as is, they are rendered before HTML)."""
+    parts, prev = [], 0
+    for m in JINJA_RE.finditer(value):
+        parts.append(value[prev:m.start()].replace('"', '&quot;'))
+        parts.append(m.group(0))
+        prev = m.end()
+    parts.append(value[prev:].replace('"', '&quot;'))
+    return ''.join(parts)
 def export_html_element_style(text):
@@ -115,7 +124,7 @@ def export_html_video(elements, default_inline='', current_directory=''):
     parts = ['<video']
     parts.append(export_html_element_inline(elements['{}']))
     if default_inline:
-        parts.append(f' {default_inline} ')
+        parts.append(f' {default_inline}')
     parts.append(export_html_element_class_and_id(elements['()']))
     parts.append(export_html_element_style(elements['[]']))
     if os.path.isfile(os.path.join(current_directory, poster_candidate)):

lhtml-markup 2.3.0__tar.gz → 2.4.1__tar.gz

lhtml-markup 2.3.0tar.gz → 2.4.1tar.gz