lhtml-markup 2.0.1__tar.gz → 2.2.0__tar.gz

{lhtml_markup-2.0.1/src/lhtml_markup.egg-info → lhtml_markup-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lhtml-markup
-Version: 2.0.1
+Version: 2.2.0
 Summary: Lightweight HTML markup language — simplifies HTML authoring with shorthand syntax
 License: MIT
 Project-URL: Homepage, https://github.com/drohmer/lhtml

{lhtml_markup-2.0.1 → lhtml_markup-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lhtml-markup"
-version = "2.0.1"
+version = "2.2.0"
 description = "Lightweight HTML markup language — simplifies HTML authoring with shorthand syntax"
 readme = "README.md"
 license = {text = "MIT"}

lhtml_markup-2.2.0/src/lhtml/cli.py

@@ -0,0 +1,98 @@
+"""LHTML command-line interface.
+
+Usage:
+    lhtml [-w] file.l.html                       # Single file → stdout
+    lhtml [-w] file.l.html -o output.html         # Single file → output file
+    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
+    python -m lhtml [same options]
+"""
+
+import os
+import argparse
+
+from .pipeline import ProcessingPipeline
+
+
+_pipeline = ProcessingPipeline()
+
+
+def _ensure_trailing_newline(text):
+    if text and text[-1] != '\n':
+        return text + '\n'
+    return text
+
+
+def _output_path_for(input_path, output_arg):
+    """Determine the output path for a given input file.
+
+    If output_arg is a directory, write <dir>/<basename>.html.
+    If output_arg is a file path, return it directly (single-file mode).
+    If output_arg is None, derive .html from the input path.
+    """
+    basename = os.path.basename(input_path)
+    name, _ = os.path.splitext(basename)
+    # Strip double extensions like .l.html → .html
+    if name.endswith('.l'):
+        name = name[:-2]
+
+    if output_arg is None:
+        # Write next to source
+        return os.path.join(os.path.dirname(input_path), name + '.html')
+
+    if os.path.isdir(output_arg) or output_arg.endswith('/'):
+        os.makedirs(output_arg, exist_ok=True)
+        return os.path.join(output_arg, name + '.html')
+
+    # Treat as a direct file path (single-file mode)
+    return output_arg
+
+
+def _process_file(f_in, meta_base):
+    """Process a single LHTML file and return the HTML output."""
+    meta = dict(meta_base)
+    dir_to_include = os.path.dirname(os.path.abspath(f_in))
+    if dir_to_include:
+        meta['directory_include'] = meta.get('directory_include', []) + [dir_to_include + '/']
+
+    with open(f_in) as fid:
+        txt = _ensure_trailing_newline(fid.read())
+
+    return _ensure_trailing_newline(_pipeline.run(txt, meta))
+
+
+def main():
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(description='Lightweight HTML')
+    parser.add_argument('inputFiles', nargs='+', help='Input file(s)')
+    parser.add_argument('-w', '--wrapAuto',
+                        help='Wrap content in basic HTML template',
+                        action='store_true')
+    parser.add_argument('-o', '--output',
+                        help='Output file (single input) or directory (multiple inputs)')
+    args = parser.parse_args()
+
+    meta = {'directory_include': [os.getcwd() + '/']}
+    if args.wrapAuto:
+        meta['wrap-auto'] = True
+
+    single_file = len(args.inputFiles) == 1
+    single_to_stdout = single_file and args.output is None
+
+    for f_in in args.inputFiles:
+        if not os.path.isfile(f_in):
+            print(f'Error: file not found [{f_in}]')
+            continue
+
+        html = _process_file(f_in, meta)
+
+        if single_to_stdout:
+            print(html)
+        else:
+            out_path = _output_path_for(f_in, args.output)
+            with open(out_path, 'w') as f_out:
+                f_out.write(html)
+
+
+if __name__ == '__main__':
+    main()

{lhtml_markup-2.0.1 → lhtml_markup-2.2.0}/src/lhtml/export_html.py

@@ -145,3 +145,12 @@ def export_html_video(elements, default_inline='', current_directory=''):
 def check_is_closing_tag(elements):
     """A bare :: (empty tag, span of exactly 2) is a closing tag."""
     return elements['tag'] == '' and elements['index_end'] - elements['index_start'] == 2
+
+
+def check_is_explicit_closing_tag(elements):
+    """A named closing tag like ::div[-] or ::span[-].
+
+    Parsed as: tag='', text='div'/'span', []= '-'
+    (because the tag name appears after ::, not before)
+    """
+    return elements['text'] != '' and elements['[]'] == '-'

{lhtml_markup-2.0.1 → lhtml_markup-2.2.0}/src/lhtml/process.py

@@ -15,7 +15,7 @@ from .element_extract import extract_bracket_elements
 from .export_html import (
     export_html_element_class_and_id, export_html_generic,
     export_html_link, export_html_img, export_html_video,
-    check_is_closing_tag,
+    check_is_closing_tag, check_is_explicit_closing_tag,
 )
 from .listing import process_listing  # noqa: F401 — re-exported
 from .code import export_html_code
@@ -174,6 +174,23 @@ def _dispatch_tag(element, tag_to_close, current_directory, registry=None):
     """
     tag = element['tag']
 
+    # Explicit closing tag: ::div[-], ::span[-], etc.
+    if check_is_explicit_closing_tag(element):
+        closing_name = element['text']
+        if not tag_to_close:
+            warnings.warn(
+                str(LHTMLTagStackError(source_pos=element.get('index_start', -1))),
+                stacklevel=3,
+            )
+            return '::??ERROR', True
+        if tag_to_close[-1] != closing_name:
+            warnings.warn(
+                f'Closing ::{closing_name}[-] but last opened tag is <{tag_to_close[-1]}> '
+                f'(position {element.get("index_start", -1)})',
+                stacklevel=3,
+            )
+        return '</' + tag_to_close.pop() + '>', True
+
     # Try plugin registry first
     if registry is not None:
         handler = registry.get(tag)

{lhtml_markup-2.0.1 → lhtml_markup-2.2.0/src/lhtml_markup.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lhtml-markup
-Version: 2.0.1
+Version: 2.2.0
 Summary: Lightweight HTML markup language — simplifies HTML authoring with shorthand syntax
 License: MIT
 Project-URL: Homepage, https://github.com/drohmer/lhtml

{lhtml_markup-2.0.1 → lhtml_markup-2.2.0}/test/test_lhtml.py

@@ -169,6 +169,43 @@ class TestTags:
         assert 'trick::' in r
 
 
+# ---------------------------------------------------------------------------
+# Explicit closing tags
+# ---------------------------------------------------------------------------
+
+class TestExplicitClosing:
+    def test_explicit_div_close(self):
+        r = lhtml.run('\ndiv::[color:red;]\ncontent\n::div[-]\n')
+        assert '<div style="color:red;">' in r
+        assert '</div>' in r
+        assert '::div' not in r
+
+    def test_explicit_span_close(self):
+        r = lhtml.run('\nspan::[color:blue;] text ::span[-]\n')
+        # span with inline text uses :: self-closing, but ::span[-] is explicit
+        # Actually: span::[color:blue;] text :: is self-closing
+        # Let's test a block span
+        r = lhtml.run('\nspan::[color:blue;]\ntext\n::span[-]\n')
+        assert '<span style="color:blue;">' in r
+        assert '</span>' in r
+
+    def test_nested_explicit_close(self):
+        r = lhtml.run('\ndiv::[padding:10px;]\nspan::[color:red;]\ntext\n::span[-]\n::div[-]\n')
+        assert r.count('</span>') == 1
+        assert r.count('</div>') == 1
+
+    def test_bare_close_still_works(self):
+        r = lhtml.run('\ndiv::[color:green;]\ntext\n::\n')
+        assert '</div>' in r
+
+    def test_mismatch_warning(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+            lhtml.run('\ndiv::[color:red;]\nspan::[color:blue;]\ntext\n::div[-]\n::span[-]\n')
+            mismatches = [x for x in w if 'but last opened' in str(x.message)]
+            assert len(mismatches) >= 1
+
+
 # ---------------------------------------------------------------------------
 # Verbatim tests
 # ---------------------------------------------------------------------------
@@ -207,6 +244,118 @@ class TestPluginSystem:
         assert set(reg.registered_tags()) == {'foo', 'bar'}
 
 
+# ---------------------------------------------------------------------------
+# Code blocks
+# ---------------------------------------------------------------------------
+
+class TestCodeBlocks:
+    def test_python_code_block(self):
+        r = lhtml.run('\ncode::[python]\ndef hello():\n    pass\ncode::[-]\n')
+        assert '<pre>' in r
+        assert 'hello' in r
+
+    def test_cpp_code_block(self):
+        r = lhtml.run('\ncode::[c++]\nint x = 0;\ncode::[-]\n')
+        assert '<pre>' in r
+
+    def test_text_code_block(self):
+        r = lhtml.run('\ncode::[text]\nplain text\ncode::[-]\n')
+        assert 'plain text' in r
+
+
+# ---------------------------------------------------------------------------
+# Unnamed div (::() syntax)
+# ---------------------------------------------------------------------------
+
+class TestUnnamedDiv:
+    def test_unnamed_div_with_class(self):
+        r = lhtml.run('\n::(.highlight)[padding:10px;]\ncontent\n::\n')
+        assert 'class="highlight"' in r
+        assert 'style="padding:10px;"' in r
+        assert 'content' in r
+
+    def test_unnamed_div_style_only(self):
+        r = lhtml.run('\n::[color:red;]\ntext\n::\n')
+        assert '<div style="color:red;">' in r
+
+    def test_unnamed_div_wrapping_list(self):
+        r = lhtml.run('\n::(.box)\n* item one\n* item two\n::\n')
+        assert 'class="box"' in r
+        assert '<ul>' in r
+        assert '<li>' in r
+
+
+# ---------------------------------------------------------------------------
+# Inline close (:: on same line)
+# ---------------------------------------------------------------------------
+
+class TestInlineClose:
+    def test_empty_div_inline_close(self):
+        r = lhtml.run('\ndiv::[height:25px;]::\n')
+        assert '<div style="height:25px;"></div>' in r
+
+    def test_span_inline_close_with_class(self):
+        r = lhtml.run('\nspan::(.tag)[color:white;] label ::\n')
+        assert '<span class="tag" style="color:white;"> label </span>' in r
+
+    def test_unnamed_inline_close(self):
+        r = lhtml.run('\n::[margin:5px;]::\n')
+        assert '<div style="margin:5px;"></div>' in r
+
+
+# ---------------------------------------------------------------------------
+# Complex nesting
+# ---------------------------------------------------------------------------
+
+class TestComplexNesting:
+    def test_nested_divs_three_levels(self):
+        r = lhtml.run('\n::[padding:20px;]\n::[background:#eee;]\ndiv::[color:red;] deep ::\n::\n::\n')
+        assert '<div style="padding:20px;">' in r
+        assert '<div style="background:#eee;">' in r
+        assert '<div style="color:red;"> deep </div>' in r
+        assert r.count('</div>') == 3
+
+    def test_formatting_inside_nested_div(self):
+        r = lhtml.run('\n::[border:1px solid;]\n**bold** and __italic__\n::\n')
+        assert '<strong>bold</strong>' in r
+        assert '<em>italic</em>' in r
+        assert '<div style="border:1px solid;">' in r
+
+    def test_link_inside_div(self):
+        r = lhtml.run('\n::[padding:5px;]\nlink::https://example.com[click]\n::\n')
+        assert '<a href="https://example.com">click</a>' in r
+
+
+# ---------------------------------------------------------------------------
+# Mixed content (real-world patterns)
+# ---------------------------------------------------------------------------
+
+class TestMixedContent:
+    def test_heading_with_bold(self):
+        r = lhtml.run('\n= Title with **bold** word\n')
+        assert '<h1>Title with <strong>bold</strong> word</h1>' in r
+
+    def test_list_with_inline_code(self):
+        r = lhtml.run('\n* Use `printf` to print\n')
+        assert '<li>' in r
+        assert '<code class="code-inline">printf</code>' in r
+
+    def test_list_with_link(self):
+        r = lhtml.run('\n* See link::https://example.com[docs]\n')
+        assert '<li>' in r
+        assert '<a href="https://example.com">docs</a>' in r
+
+    def test_code_inside_styled_div(self):
+        r = lhtml.run('\n::[font-size:80%;]\ncode::[c++]\nint x;\ncode::[-]\n::\n')
+        assert '<div style="font-size:80%;">' in r
+        assert '<pre>' in r
+
+    def test_raw_html_passthrough_with_lhtml(self):
+        r = lhtml.run('\n<p>HTML</p>\ndiv::[color:red;] lhtml ::\n')
+        assert '<p>HTML</p>' in r
+        assert '<div style="color:red;"> lhtml </div>' in r
+
+
 # ---------------------------------------------------------------------------
 # Non-regression: real-world lab_website examples
 # ---------------------------------------------------------------------------

lhtml_markup-2.0.1/src/lhtml/cli.py

@@ -1,62 +0,0 @@
-"""LHTML command-line interface.
-
-Usage:
-    lhtml [-w] inputFile [-o outputFile]
-    python -m lhtml [-w] inputFile [-o outputFile]
-"""
-
-import os
-import argparse
-
-from .pipeline import ProcessingPipeline
-
-
-_pipeline = ProcessingPipeline()
-
-
-def _ensure_trailing_newline(text):
-    if text and text[-1] != '\n':
-        return text + '\n'
-    return text
-
-
-def main():
-    """CLI entry point."""
-    parser = argparse.ArgumentParser(description='Lightweight HTML')
-    parser.add_argument('inputFile', help='Input filepath')
-    parser.add_argument('-w', '--wrapAuto',
-                        help='Wrap content in basic HTML template',
-                        action='store_true')
-    parser.add_argument('-o', '--outputFile', help='Output filepath')
-    args = parser.parse_args()
-
-    meta = {}
-    if args.wrapAuto:
-        meta['wrap-auto'] = True
-
-    meta['directory_include'] = [os.getcwd() + '/']
-    f_in = args.inputFile
-
-    if os.path.isfile(f_in):
-        dir_to_include = os.path.dirname(f_in)
-        if dir_to_include:
-            meta['directory_include'].append(
-                os.path.join(os.getcwd(), dir_to_include) + '/'
-            )
-
-        with open(f_in) as fid:
-            txt = _ensure_trailing_newline(fid.read())
-
-        html = _ensure_trailing_newline(_pipeline.run(txt, meta))
-
-        if args.outputFile:
-            with open(args.outputFile, 'w') as f_out:
-                f_out.write(html)
-        else:
-            print(html)
-    else:
-        print(f'Error: unrecognized input file [{f_in}]')
-
-
-if __name__ == '__main__':
-    main()