celes 0.1.0__tar.gz

celes-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: celes
+Version: 0.1.0
+Summary: Celes 0.1 — a tag-based markup language toolkit
+License: MIT
+Keywords: markup,language,markdown,parser,celes
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: requires-python
+
+# Celes 0.1
+
+A tag-based markup language and toolkit. Write documents in Celes, convert to HTML, validate, or round-trip with Markdown.
+
+## Install
+
+```bash
+pip install celes
+```
+
+## CLI Usage
+
+```bash
+# Convert a Celes file to HTML
+celes parse doc.celes doc.html
+
+# Validate a Celes file
+celes validate doc.celes
+
+# Convert Markdown to Celes
+celes md README.md README.celes
+
+# Convert Celes to Markdown
+celes tomd doc.celes doc.md
+```
+
+## Python API
+
+```python
+from celes import parse_celes, validate_celes, convert_md_to_celes, convert_celes_to_md
+
+# Parse to HTML
+html = parse_celes(source)
+
+# Validate
+is_valid, errors = validate_celes(source)
+for e in errors:
+    print(e)  # "  ✗ Line 3: <header> is missing required -size attribute"
+
+# Convert
+celes_source = convert_md_to_celes(markdown_source)
+markdown_source = convert_celes_to_md(celes_source)
+```
+
+## Celes Syntax (0.1)
+
+```
+<!Celes-0.1>
+; This is a comment
+<title>{My Page}
+<header -size=1>{Hello, World!}
+<line>{This is <bold>{bold} and <italic>{italic} text.}
+<list -bullet=circle>{Item one}<sublist -bullet=circle>{Sub-item}
+<list -bullet=number>{Numbered item}
+<table>{Name, Age}
+<item>{Alice, 30}
+<codeblock>{print("hello")}
+<image>{photo.png}
+<linkimage -image=photo.png>{https://example.com}
+<blockquote>{A quote <nestquote>{nested}}
+<line -align=center>{Centered}
+<newline>
+<pagebreak>
+<insertspace>
+<empty>{<raw> text with <angle> brackets}
+```

celes-0.1.0/README.md

@@ -0,0 +1,66 @@
+# Celes 0.1
+
+A tag-based markup language and toolkit. Write documents in Celes, convert to HTML, validate, or round-trip with Markdown.
+
+## Install
+
+```bash
+pip install celes
+```
+
+## CLI Usage
+
+```bash
+# Convert a Celes file to HTML
+celes parse doc.celes doc.html
+
+# Validate a Celes file
+celes validate doc.celes
+
+# Convert Markdown to Celes
+celes md README.md README.celes
+
+# Convert Celes to Markdown
+celes tomd doc.celes doc.md
+```
+
+## Python API
+
+```python
+from celes import parse_celes, validate_celes, convert_md_to_celes, convert_celes_to_md
+
+# Parse to HTML
+html = parse_celes(source)
+
+# Validate
+is_valid, errors = validate_celes(source)
+for e in errors:
+    print(e)  # "  ✗ Line 3: <header> is missing required -size attribute"
+
+# Convert
+celes_source = convert_md_to_celes(markdown_source)
+markdown_source = convert_celes_to_md(celes_source)
+```
+
+## Celes Syntax (0.1)
+
+```
+<!Celes-0.1>
+; This is a comment
+<title>{My Page}
+<header -size=1>{Hello, World!}
+<line>{This is <bold>{bold} and <italic>{italic} text.}
+<list -bullet=circle>{Item one}<sublist -bullet=circle>{Sub-item}
+<list -bullet=number>{Numbered item}
+<table>{Name, Age}
+<item>{Alice, 30}
+<codeblock>{print("hello")}
+<image>{photo.png}
+<linkimage -image=photo.png>{https://example.com}
+<blockquote>{A quote <nestquote>{nested}}
+<line -align=center>{Centered}
+<newline>
+<pagebreak>
+<insertspace>
+<empty>{<raw> text with <angle> brackets}
+```

celes-0.1.0/celes/__init__.py

@@ -0,0 +1,17 @@
+"""
+Celes 0.1 — A tag-based markup language.
+"""
+
+from .parser import parse_celes
+from .validator import validate_celes, CelesError
+from .md_to_celes import convert_md_to_celes
+from .celes_to_md import convert_celes_to_md
+
+__version__ = "0.1.0"
+__all__ = [
+    "parse_celes",
+    "validate_celes",
+    "CelesError",
+    "convert_md_to_celes",
+    "convert_celes_to_md",
+]

celes-0.1.0/celes/celes_to_md.py

@@ -0,0 +1,151 @@
+"""
+Celes 0.1 — Celes to Markdown converter.
+"""
+
+import re
+from .core import tokenize, find_matching_brace, parse_attributes
+
+
+def inline_to_md(content):
+    if content is None:
+        return ''
+    result = ''
+    i = 0
+    while i < len(content):
+        tag_start = content.find('<', i)
+        if tag_start == -1:
+            result += content[i:]
+            break
+        result += content[i:tag_start]
+        tag_end = content.find('>', tag_start)
+        if tag_end == -1:
+            result += content[tag_start:]
+            break
+        tag_header = content[tag_start + 1:tag_end]
+        header_match = re.match(r'^([\w+]+)(.*)', tag_header, re.DOTALL)
+        if not header_match:
+            result += content[tag_start:tag_end + 1]
+            i = tag_end + 1
+            continue
+        tagname = header_match.group(1).lower()
+        attrs = parse_attributes(header_match.group(2))
+        after_tag = tag_end + 1
+        inner = ''
+        end = after_tag
+        if after_tag < len(content) and content[after_tag] == '{':
+            close = find_matching_brace(content, after_tag)
+            if close != -1:
+                inner = content[after_tag + 1:close]
+                end = close + 1
+        inner_md = inline_to_md(inner)
+        if tagname == 'bold':              result += f'**{inner_md}**'
+        elif tagname == 'italic':          result += f'*{inner_md}*'
+        elif tagname == 'bold+italic':     result += f'***{inner_md}***'
+        elif tagname == 'underline':       result += f'<u>{inner_md}</u>'
+        elif tagname == 'strike':          result += f'~~{inner_md}~~'
+        elif tagname == 'code':            result += f'`{inner}`'
+        elif tagname == 'link':
+            body = attrs.get('body', inner_md)
+            result += f'[{body}]({inner})'
+        elif tagname == 'newline':         result += '\n'
+        elif tagname == 'empty':           result += inner
+        elif tagname == 'checkmark':
+            checked = 'x' if 'check' in attrs else ' '
+            result += f'[{checked}] {inner_md}'
+        elif tagname == 'nestquote':       result += f'>> {inner_md}'
+        else:                              result += inner_md
+        i = end
+    return result
+
+
+def convert_celes_to_md(source):
+    tokens = tokenize(source)
+    output = []
+    title = None
+    i = 0
+
+    while i < len(tokens):
+        lineno, tagname, attrs, content = tokens[i]
+
+        if tagname == 'declaration':
+            i += 1; continue
+        elif tagname == 'comment':
+            output.append(f'<!-- {content} -->')
+            i += 1
+        elif tagname == 'title':
+            title = content
+            i += 1
+        elif tagname == 'header':
+            size = int(attrs.get('size', 1))
+            output.append(f'{"#" * size} {inline_to_md(content)}')
+            i += 1
+        elif tagname == 'line':
+            align = attrs.get('align', '')
+            text = inline_to_md(content)
+            if align and align != 'left':
+                output.append(f'<div align="{align}">{text}</div>')
+            else:
+                output.append(text)
+            i += 1
+        elif tagname == 'blockquote':
+            text = inline_to_md(content)
+            for bq_line in text.splitlines():
+                output.append(f'> {bq_line}')
+            i += 1
+        elif tagname == 'codeblock':
+            output.append('```')
+            output.append(content or '')
+            output.append('```')
+            i += 1
+        elif tagname == 'image':
+            output.append(f'![image]({content})')
+            i += 1
+        elif tagname == 'linkimage':
+            img = attrs.get('image', '')
+            output.append(f'[![image]({img})]({content})')
+            i += 1
+        elif tagname == 'table':
+            cols = [c.strip() for c in (content or '').split(',')]
+            output.append('| ' + ' | '.join(cols) + ' |')
+            output.append('| ' + ' | '.join(['---'] * len(cols)) + ' |')
+            i += 1
+            while i < len(tokens) and tokens[i][1] == 'item':
+                cells = [c.strip() for c in (tokens[i][3] or '').split(',')]
+                output.append('| ' + ' | '.join(cells) + ' |')
+                i += 1
+        elif tagname == 'list':
+            counter = 1
+            while i < len(tokens) and tokens[i][1] == 'list':
+                t_attrs = tokens[i][2]
+                t_content = tokens[i][3] or ''
+                t_bullet = t_attrs.get('bullet', 'circle')
+                text = inline_to_md(t_content)
+                if t_bullet == 'number':
+                    output.append(f'{counter}. {text}')
+                    counter += 1
+                else:
+                    output.append(f'- {text}')
+                i += 1
+                while i < len(tokens) and tokens[i][1] == 'sublist':
+                    s_attrs = tokens[i][2]
+                    s_content = tokens[i][3] or ''
+                    s_bullet = s_attrs.get('bullet', 'circle')
+                    s_text = inline_to_md(s_content)
+                    if s_bullet == 'number':
+                        output.append(f'   1. {s_text}')
+                    else:
+                        output.append(f'   - {s_text}')
+                    i += 1
+        elif tagname == 'newline':
+            output.append('')
+            i += 1
+        elif tagname in ('pagebreak', 'insertspace'):
+            output.append('\n---\n')
+            i += 1
+        else:
+            i += 1
+
+    if title:
+        output.insert(0, f'---\ntitle: {title}\n---\n')
+
+    return '\n'.join(output)

celes-0.1.0/celes/cli.py

@@ -0,0 +1,115 @@
+"""
+Celes CLI — command line interface for the Celes 0.1 toolkit.
+
+Commands:
+    celes parse    input.celes [output.html]   — convert to HTML
+    celes validate input.celes                 — validate a file
+    celes md       input.md    [output.celes]  — convert Markdown to Celes
+    celes tomd     input.celes [output.md]     — convert Celes to Markdown
+"""
+
+import sys
+import os
+
+
+def read_file(path):
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except FileNotFoundError:
+        print(f'Error: File not found: {path}', file=sys.stderr)
+        sys.exit(1)
+
+
+def write_file(path, content):
+    with open(path, 'w', encoding='utf-8') as f:
+        f.write(content)
+    print(f'✓ Output written to {path}')
+
+
+def cmd_parse(args):
+    if not args:
+        print('Usage: celes parse <input.celes> [output.html]')
+        sys.exit(1)
+    from .parser import parse_celes
+    source = read_file(args[0])
+    result = parse_celes(source)
+    if len(args) >= 2:
+        write_file(args[1], result)
+    else:
+        print(result)
+
+
+def cmd_validate(args):
+    if not args:
+        print('Usage: celes validate <input.celes>')
+        sys.exit(1)
+    from .validator import main_validate
+    source = read_file(args[0])
+    code = main_validate(source, filename=args[0])
+    sys.exit(code)
+
+
+def cmd_md(args):
+    if not args:
+        print('Usage: celes md <input.md> [output.celes]')
+        sys.exit(1)
+    from .md_to_celes import convert_md_to_celes
+    source = read_file(args[0])
+    result = convert_md_to_celes(source)
+    if len(args) >= 2:
+        write_file(args[1], result)
+    else:
+        print(result)
+
+
+def cmd_tomd(args):
+    if not args:
+        print('Usage: celes tomd <input.celes> [output.md]')
+        sys.exit(1)
+    from .celes_to_md import convert_celes_to_md
+    source = read_file(args[0])
+    result = convert_celes_to_md(source)
+    if len(args) >= 2:
+        write_file(args[1], result)
+    else:
+        print(result)
+
+
+COMMANDS = {
+    'parse':    cmd_parse,
+    'validate': cmd_validate,
+    'md':       cmd_md,
+    'tomd':     cmd_tomd,
+}
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] in ('-h', '--help'):
+        print("""Celes 0.1 Toolkit
+
+Usage:
+  celes parse    <input.celes> [output.html]   Convert Celes → HTML
+  celes validate <input.celes>                 Validate a Celes file
+  celes md       <input.md>    [output.celes]  Convert Markdown → Celes
+  celes tomd     <input.celes> [output.md]     Convert Celes → Markdown
+
+Examples:
+  celes parse    doc.celes doc.html
+  celes validate doc.celes
+  celes md       README.md  README.celes
+  celes tomd     doc.celes  doc.md
+""")
+        sys.exit(0)
+
+    command = sys.argv[1]
+    if command not in COMMANDS:
+        print(f'Unknown command: {command!r}')
+        print(f'Available commands: {", ".join(COMMANDS)}')
+        sys.exit(1)
+
+    COMMANDS[command](sys.argv[2:])
+
+
+if __name__ == '__main__':
+    main()

celes-0.1.0/celes/core.py

@@ -0,0 +1,140 @@
+"""
+Celes core utilities — shared across parser, validator, and converters.
+"""
+
+import re
+
+
+SELF_CLOSING_TAGS = {'newline', 'pagebreak', 'insertspace'}
+
+BLOCK_TAGS = {
+    'title', 'header', 'line', 'blockquote', 'codeblock',
+    'image', 'linkimage', 'list', 'sublist', 'table', 'item',
+    'newline', 'pagebreak', 'insertspace',
+}
+
+INLINE_TAGS = {
+    'bold', 'italic', 'bold+italic', 'underline', 'strike',
+    'code', 'link', 'checkmark', 'nestquote', 'empty',
+}
+
+REQUIRED_ATTRS = {
+    'header':    ['size'],
+    'link':      ['body'],
+    'linkimage': ['image'],
+    'checkmark': [],   # needs either -check or -uncheck key
+}
+
+VALID_ATTR_VALUES = {
+    'size':   {'1', '2', '3', '4', '5', '6'},
+    'bullet': {'circle', 'number'},
+    'align':  {'left', 'center', 'right'},
+}
+
+
+def find_matching_brace(s, start):
+    """Return index of closing } matching { at s[start]. Returns -1 if not found."""
+    depth = 0
+    for i in range(start, len(s)):
+        if s[i] == '{':
+            depth += 1
+        elif s[i] == '}':
+            depth -= 1
+            if depth == 0:
+                return i
+    return -1
+
+
+def parse_attributes(attr_str):
+    """Parse '-key=value -flag' strings into a dict."""
+    attrs = {}
+    attr_str = attr_str.strip()
+    pattern = re.compile(r'-(\w+)(?:=(?=\S)(.*?))?(?=\s+-\w|$)', re.DOTALL)
+    for m in pattern.finditer(attr_str):
+        key = m.group(1)
+        val = m.group(2)
+        attrs[key] = val.strip() if val is not None else True
+    return attrs
+
+
+def split_multi_tag_line(line):
+    """
+    Split a line containing multiple adjacent tags into individual tag strings.
+    e.g. '<list>{Item}<sublist>{Sub}' → ['<list>{Item}', '<sublist>{Sub}']
+    """
+    line = line.strip()
+    if line.startswith(';') or line.startswith('<!'):
+        return [line]
+    result = []
+    i = 0
+    while i < len(line):
+        if line[i] != '<':
+            break
+        tag_end = line.find('>', i)
+        if tag_end == -1:
+            result.append(line[i:])
+            break
+        after_tag = tag_end + 1
+        if after_tag < len(line) and line[after_tag] == '{':
+            close = find_matching_brace(line, after_tag)
+            if close != -1:
+                result.append(line[i:close + 1])
+                i = close + 1
+                continue
+        result.append(line[i:after_tag])
+        i = after_tag
+    return result if result else [line]
+
+
+def parse_tag_line(line):
+    """
+    Parse a single tag string into (tagname, attrs, content).
+    Returns ('comment', {}, text) for comments.
+    Returns ('error', {}, message) for parse failures.
+    Self-closing tags return content=None.
+    """
+    line = line.strip()
+    if not line:
+        return None
+    if line.startswith(';'):
+        return ('comment', {}, line[1:].strip())
+    if line.startswith('<!Celes'):
+        return ('declaration', {}, line)
+    if not line.startswith('<'):
+        return ('error', {}, f'Line does not start with a tag: {line!r}')
+    tag_end = line.find('>')
+    if tag_end == -1:
+        return ('error', {}, f'Unclosed tag header: {line!r}')
+    tag_header = line[1:tag_end]
+    header_match = re.match(r'^([\w+]+)(.*)', tag_header, re.DOTALL)
+    if not header_match:
+        return ('error', {}, f'Cannot parse tag name from: {line!r}')
+    tagname = header_match.group(1).lower()
+    attrs = parse_attributes(header_match.group(2))
+    rest = line[tag_end + 1:].strip()
+    if not rest:
+        return (tagname, attrs, None)
+    if not rest.startswith('{'):
+        return ('error', {}, f'Missing {{...}} content after tag in: {line!r}')
+    close = find_matching_brace(rest, 0)
+    if close == -1:
+        return ('error', {}, f'Unclosed brace in: {line!r}')
+    content = rest[1:close]
+    return (tagname, attrs, content)
+
+
+def tokenize(source):
+    """
+    Convert a Celes source string into a list of (line_number, tagname, attrs, content) tuples.
+    """
+    tokens = []
+    for lineno, raw_line in enumerate(source.splitlines(), start=1):
+        if not raw_line.strip():
+            continue
+        for single in split_multi_tag_line(raw_line):
+            if not single.strip():
+                continue
+            result = parse_tag_line(single)
+            if result:
+                tokens.append((lineno, *result))
+    return tokens