todoosy 0.1.0__tar.gz

todoosy-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: todoosy
+Version: 0.1.0
+Summary: Todoosy - Markdown-based todo system parser, formatter, linter, and query engine
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+
+# Todoosy Python Library
+
+Python implementation of the Todoosy format parser, formatter, linter, and query engine.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+For development:
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage
+
+```python
+from todoosy import parse, format, lint, query_upcoming, query_misc, parse_scheme
+
+# Parse a document
+result = parse('''
+# Work
+
+- Task (due 2026-01-15 p1 2h)
+
+# Misc
+''')
+
+# Access the AST
+for item in result.ast.items:
+    print(f"{item.title_text}: due={item.metadata.due}")
+
+# Format a document
+formatted = format(input_text)
+
+# Lint a document
+warnings = lint(input_text)
+for w in warnings.warnings:
+    print(f"{w.code}: {w.message}")
+
+# Query upcoming items
+scheme = parse_scheme(scheme_text)
+upcoming = query_upcoming(input_text, scheme)
+for item in upcoming.items:
+    print(f"{item.path}: {item.due}")
+
+# Query misc items
+misc = query_misc(input_text)
+for item in misc.items:
+    print(item.title_text)
+```
+
+## Running Tests
+
+```bash
+pytest
+```

todoosy-0.1.0/README.md

@@ -0,0 +1,58 @@
+# Todoosy Python Library
+
+Python implementation of the Todoosy format parser, formatter, linter, and query engine.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+For development:
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage
+
+```python
+from todoosy import parse, format, lint, query_upcoming, query_misc, parse_scheme
+
+# Parse a document
+result = parse('''
+# Work
+
+- Task (due 2026-01-15 p1 2h)
+
+# Misc
+''')
+
+# Access the AST
+for item in result.ast.items:
+    print(f"{item.title_text}: due={item.metadata.due}")
+
+# Format a document
+formatted = format(input_text)
+
+# Lint a document
+warnings = lint(input_text)
+for w in warnings.warnings:
+    print(f"{w.code}: {w.message}")
+
+# Query upcoming items
+scheme = parse_scheme(scheme_text)
+upcoming = query_upcoming(input_text, scheme)
+for item in upcoming.items:
+    print(f"{item.path}: {item.due}")
+
+# Query misc items
+misc = query_misc(input_text)
+for item in misc.items:
+    print(item.title_text)
+```
+
+## Running Tests
+
+```bash
+pytest
+```

todoosy-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "todoosy"
+version = "0.1.0"
+description = "Todoosy - Markdown-based todo system parser, formatter, linter, and query engine"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

todoosy-0.1.0/setup.cfg

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

todoosy-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+# Tests package

todoosy-0.1.0/tests/test_golden.py

@@ -0,0 +1,226 @@
+"""
+Todoosy Golden Tests - Using shared test files
+"""
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from todoosy import (
+    parse,
+    format,
+    lint,
+    query_upcoming,
+    query_misc,
+    parse_scheme,
+)
+
+# Get test data directory
+TEST_DIR = Path(__file__).parent.parent.parent / 'testdata'
+
+
+def get_test_cases():
+    """Get all test case directories."""
+    if not TEST_DIR.exists():
+        return []
+    return sorted([d.name for d in TEST_DIR.iterdir() if d.is_dir()])
+
+
+def load_file(test_case: str, filename: str) -> str | None:
+    """Load a file from a test case directory."""
+    file_path = TEST_DIR / test_case / filename
+    if file_path.exists():
+        return file_path.read_text()
+    return None
+
+
+def load_json(test_case: str, filename: str):
+    """Load a JSON file from a test case directory."""
+    content = load_file(test_case, filename)
+    if content:
+        return json.loads(content)
+    return None
+
+
+class TestParser:
+    @pytest.mark.parametrize('test_case', get_test_cases())
+    def test_parse(self, test_case):
+        input_md = load_file(test_case, 'input.md')
+        expected_ast = load_json(test_case, 'expected_ast.json')
+
+        if not input_md or not expected_ast:
+            pytest.skip(f'Missing input or expected_ast for {test_case}')
+
+        result = parse(input_md)
+        ast = result.ast
+
+        # Compare items count
+        assert len(ast.items) == len(expected_ast['items'])
+
+        # Compare each item's essential properties
+        for i, (actual, expected) in enumerate(zip(ast.items, expected_ast['items'])):
+            assert actual.type == expected['type'], f"Item {i} type mismatch"
+            assert actual.title_text == expected['title_text'], f"Item {i} title_text mismatch"
+            assert actual.metadata.due == expected['metadata']['due'], f"Item {i} due mismatch"
+            assert actual.metadata.priority == expected['metadata']['priority'], f"Item {i} priority mismatch"
+            assert actual.metadata.estimate_minutes == expected['metadata']['estimate_minutes'], f"Item {i} estimate mismatch"
+            assert actual.comments == expected['comments'], f"Item {i} comments mismatch"
+            assert len(actual.children) == len(expected['children']), f"Item {i} children count mismatch"
+
+        # Compare root_ids count
+        assert len(ast.root_ids) == len(expected_ast['root_ids'])
+
+
+class TestFormatter:
+    @pytest.mark.parametrize('test_case', get_test_cases())
+    def test_format(self, test_case):
+        input_md = load_file(test_case, 'input.md')
+        expected_formatted = load_file(test_case, 'expected_formatted.md')
+
+        if not input_md or not expected_formatted:
+            pytest.skip(f'Missing input or expected_formatted for {test_case}')
+
+        formatted = format(input_md)
+        assert formatted == expected_formatted
+
+
+class TestLinter:
+    @pytest.mark.parametrize('test_case', get_test_cases())
+    def test_lint(self, test_case):
+        input_md = load_file(test_case, 'input.md')
+        expected_warnings = load_json(test_case, 'expected_warnings.json')
+        scheme_text = load_file(test_case, 'scheme.md')
+        scheme = parse_scheme(scheme_text) if scheme_text else None
+
+        if not input_md or not expected_warnings:
+            pytest.skip(f'Missing input or expected_warnings for {test_case}')
+
+        result = lint(input_md, scheme)
+
+        actual_codes = sorted([w.code for w in result.warnings])
+        expected_codes = sorted([w['code'] for w in expected_warnings.get('warnings', [])])
+        assert actual_codes == expected_codes
+
+
+class TestQueryUpcoming:
+    @pytest.mark.parametrize('test_case', get_test_cases())
+    def test_query_upcoming(self, test_case):
+        input_md = load_file(test_case, 'input.md')
+        expected_upcoming = load_json(test_case, 'expected_upcoming.json')
+        scheme_text = load_file(test_case, 'scheme.md')
+        scheme = parse_scheme(scheme_text) if scheme_text else None
+
+        if not input_md or not expected_upcoming:
+            pytest.skip(f'Missing input or expected_upcoming for {test_case}')
+
+        result = query_upcoming(input_md, scheme)
+
+        assert len(result.items) == len(expected_upcoming['items'])
+
+        for actual, expected in zip(result.items, expected_upcoming['items']):
+            assert actual.due == expected['due']
+            assert actual.priority == expected['priority']
+            if 'priority_label' in expected:
+                assert actual.priority_label == expected['priority_label']
+
+
+class TestQueryMisc:
+    @pytest.mark.parametrize('test_case', get_test_cases())
+    def test_query_misc(self, test_case):
+        input_md = load_file(test_case, 'input.md')
+        expected_misc = load_json(test_case, 'expected_misc.json')
+
+        if not input_md or not expected_misc:
+            pytest.skip(f'Missing input or expected_misc for {test_case}')
+
+        result = query_misc(input_md)
+
+        assert len(result.items) == len(expected_misc['items'])
+
+        for actual, expected in zip(result.items, expected_misc['items']):
+            assert actual.title_text == expected['title_text']
+
+
+class TestSchemeParser:
+    @pytest.mark.parametrize('test_case', get_test_cases())
+    def test_parse_scheme(self, test_case):
+        scheme_text = load_file(test_case, 'scheme.md')
+        expected_scheme = load_json(test_case, 'expected_scheme.json')
+
+        if not scheme_text or not expected_scheme:
+            return  # Scheme is optional
+
+        scheme = parse_scheme(scheme_text)
+
+        assert scheme.timezone == expected_scheme['timezone']
+        assert scheme.priorities == expected_scheme['priorities']
+
+
+class TestEdgeCases:
+    def test_empty_document(self):
+        result = parse('')
+        assert len(result.ast.items) == 0
+        assert len(result.ast.root_ids) == 0
+
+    def test_whitespace_only(self):
+        result = parse('   \n\n   ')
+        assert len(result.ast.items) == 0
+
+    def test_numbered_lists(self):
+        result = parse('# Tasks\n\n1. First task\n2. Second task')
+        assert len(result.ast.items) == 3
+        assert result.ast.items[1].title_text == 'First task'
+        assert result.ast.items[2].title_text == 'Second task'
+
+    def test_asterisk_lists(self):
+        result = parse('# Tasks\n\n* Task one\n* Task two')
+        assert len(result.ast.items) == 3
+        assert result.ast.items[1].title_text == 'Task one'
+
+    def test_2digit_year_dates(self):
+        result = parse('- Task (due 01/15/26)')
+        assert result.ast.items[0].metadata.due == '2026-01-15'
+
+    def test_estimate_days(self):
+        result = parse('- Task (2d)')
+        assert result.ast.items[0].metadata.estimate_minutes == 960
+
+    def test_formatter_adds_misc(self):
+        formatted = format('# Work\n\n- Task')
+        assert '# Misc' in formatted
+
+    def test_formatter_preserves_non_metadata_parens(self):
+        formatted = format('# Work\n\n- Call John (CEO)\n\n# Misc\n')
+        assert '(CEO)' in formatted
+
+    def test_linter_warns_missing_misc(self):
+        result = lint('# Work\n\n- Task')
+        assert any(w.code == 'MISC_MISSING' for w in result.warnings)
+
+    def test_linter_no_warnings_valid_doc(self):
+        result = lint('# Work\n\n- Task (due 2026-01-15 p1 2h)\n\n# Misc\n')
+        assert len(result.warnings) == 0
+
+    def test_scheme_empty(self):
+        scheme = parse_scheme('')
+        assert scheme.timezone is None
+        assert scheme.priorities == {}
+
+    def test_scheme_timezone_only(self):
+        scheme = parse_scheme('# Timezone\n\nEurope/London')
+        assert scheme.timezone == 'Europe/London'
+        assert scheme.priorities == {}
+
+    def test_scheme_various_bullets(self):
+        scheme = parse_scheme('''
+# Priorities
+
+- P0 - Critical
+* P1 - High
+P2 - Medium
+''')
+        assert scheme.priorities['0'] == 'Critical'
+        assert scheme.priorities['1'] == 'High'
+        assert scheme.priorities['2'] == 'Medium'

todoosy-0.1.0/todoosy/__init__.py

@@ -0,0 +1,40 @@
+"""
+Todoosy - Markdown-based todo system
+"""
+
+from .parser import parse, ParseResult
+from .formatter import format
+from .linter import lint, LintResult
+from .query import query_upcoming, query_misc, UpcomingResult, MiscResult
+from .scheme import parse_scheme
+from .types import (
+    AST,
+    ItemNode,
+    ItemMetadata,
+    Warning,
+    UpcomingItem,
+    MiscItem,
+    Scheme,
+)
+
+__all__ = [
+    'parse',
+    'ParseResult',
+    'format',
+    'lint',
+    'LintResult',
+    'query_upcoming',
+    'query_misc',
+    'UpcomingResult',
+    'MiscResult',
+    'parse_scheme',
+    'AST',
+    'ItemNode',
+    'ItemMetadata',
+    'Warning',
+    'UpcomingItem',
+    'MiscItem',
+    'Scheme',
+]
+
+__version__ = '0.1.0'

todoosy-0.1.0/todoosy/formatter.py

@@ -0,0 +1,136 @@
+"""
+Todoosy Formatter
+"""
+
+from .parser import parse
+from .types import ItemNode, ItemMetadata
+
+
+def format_metadata(metadata: ItemMetadata) -> str:
+    """Format metadata as a canonical string."""
+    parts: list[str] = []
+
+    if metadata.due:
+        parts.append(f"due {metadata.due}")
+
+    if metadata.priority is not None:
+        parts.append(f"p{metadata.priority}")
+
+    if metadata.estimate_minutes is not None:
+        minutes = metadata.estimate_minutes
+        if minutes % 480 == 0 and minutes >= 480:
+            parts.append(f"{minutes // 480}d")
+        elif minutes % 60 == 0 and minutes >= 60:
+            parts.append(f"{minutes // 60}h")
+        else:
+            parts.append(f"{minutes}m")
+
+    return f"({' '.join(parts)})" if parts else ''
+
+
+def format_item_line(item: ItemNode, indent: int = 0) -> str:
+    """Format a single item line."""
+    indent_str = '  ' * indent
+    meta_str = format_metadata(item.metadata)
+    title_with_meta = f"{item.title_text} {meta_str}" if meta_str else item.title_text
+
+    if item.type == 'heading':
+        hashes = '#' * (item.level or 1)
+        return f"{hashes} {title_with_meta}"
+
+    return f"{indent_str}- {title_with_meta}"
+
+
+def format_comments(comments: list[str], is_list_item: bool, indent: int) -> list[str]:
+    """Format comments with proper indentation."""
+    if not comments:
+        return []
+
+    if is_list_item:
+        indent_str = '  ' * (indent + 1)
+        return [f"{indent_str}{c}" for c in comments]
+
+    return list(comments)
+
+
+def format(text: str) -> str:
+    """Format a todoosy document."""
+    result = parse(text)
+    ast = result.ast
+    lines: list[str] = []
+    item_map = {item.id: item for item in ast.items}
+
+    # Track Misc section
+    misc_section_id = None
+    for item in ast.items:
+        if item.type == 'heading' and item.title_text == 'Misc' and item.level == 1:
+            misc_section_id = item.id
+            break
+
+    def format_item(item_id: str, list_indent: int = 0, is_under_misc: bool = False) -> None:
+        item = item_map[item_id]
+
+        # Skip Misc section during normal iteration
+        if item.id == misc_section_id and not is_under_misc:
+            return
+
+        # Add blank line before headings (except at start)
+        if item.type == 'heading' and lines and lines[-1] != '':
+            lines.append('')
+
+        lines.append(format_item_line(item, list_indent))
+
+        # Add blank line after heading before comments or children
+        if item.type == 'heading':
+            lines.append('')
+
+        # Add comments
+        formatted_comments = format_comments(
+            item.comments,
+            item.type == 'list',
+            list_indent
+        )
+        lines.extend(formatted_comments)
+
+        # Add blank line after heading comments before children
+        if item.type == 'heading' and item.comments and item.children:
+            lines.append('')
+
+        # Format children
+        for child_id in item.children:
+            child = item_map[child_id]
+            if child.type == 'list':
+                next_indent = 0 if item.type == 'heading' else list_indent + 1
+                format_item(child_id, next_indent, is_under_misc)
+            else:
+                format_item(child_id, 0, is_under_misc)
+
+    # Format all root items except Misc
+    for root_id in ast.root_ids:
+        if root_id != misc_section_id:
+            format_item(root_id, 0, False)
+
+    # Add Misc section at the end
+    if lines and lines[-1] != '':
+        lines.append('')
+    lines.append('# Misc')
+
+    # Add Misc items if they exist
+    if misc_section_id:
+        misc_item = item_map[misc_section_id]
+        if misc_item.comments:
+            lines.append('')
+            lines.extend(misc_item.comments)
+        if misc_item.children:
+            lines.append('')
+            for child_id in misc_item.children:
+                child = item_map[child_id]
+                lines.append(format_item_line(child, 0))
+                formatted_comments = format_comments(
+                    child.comments,
+                    child.type == 'list',
+                    0
+                )
+                lines.extend(formatted_comments)
+
+    return '\n'.join(lines) + '\n'