favro-sync/favro_sync/favro_markdown.py

import dataclasses
import re

import frontmatter
import marko
import marko.md_renderer


@dataclasses.dataclass(frozen=True)
class CardContents:
    identifier: str | None
    name: str | None
    description: str | None
    tags: list[str]
    assignments: list[str]
    card_dependencies: list[str]
    url: str


def format_obsidian_link(text: str) -> str:
    return f'[[{text}]]'


def parse_obsidian_link(text: str) -> str:
    if m := re.match(r'^\[\[(.*)\]\]$', text):
        return m.group(1)
    return text


class CardFileFormatter:
    """Component for formatting and parsing card files."""

    def __init__(self, obsidian_mode=True):
        self.obsidian_mode = obsidian_mode
        self.markdown = marko.Markdown()
        self.renderer = marko.md_renderer.MarkdownRenderer()

    def format_card_contents(self, card: CardContents) -> str:
        # Choose frontmatter data
        frontmatter_data = {}
        if self.obsidian_mode:
            aliases = []
            if card.name:
                aliases.append(card.name)
            if card.identifier and card.name:
                aliases.append(f'{card.identifier}: {card.name}')
            if aliases:
                frontmatter_data['aliases'] = aliases
            del aliases
        if card.tags:
            frontmatter_data['tags'] = card.tags
        if card.url and self.obsidian_mode:
            frontmatter_data['url'] = card.url
        if card.assignments:
            frontmatter_data['assignments'] = card.assignments
            if self.obsidian_mode:
                frontmatter_data['assignments'] = [
                    format_obsidian_link(name)
                    for name in frontmatter_data['assignments']
                ]
        if card.card_dependencies:
            frontmatter_data['dependencies'] = card.card_dependencies
            if self.obsidian_mode:
                frontmatter_data['dependencies'] = [
                    format_obsidian_link(name)
                    for name in frontmatter_data['dependencies']
                ]

        # Card name
        ls = []
        if card.name:
            ls.append('# ')
            ls.append(card.name)
            ls.append('\n\n')

        # Card contents
        if card.description:
            ls.append(card.description)
        fm = frontmatter.Post(''.join(ls), **frontmatter_data)
        return frontmatter.dumps(fm)

    def parse_card_contents(self, contents: str) -> CardContents:
        """Parses card contents.

        1. Strips frontmatter and parses certain fields from the header.
        2. Parses header
        3. Finds content.
        """
        fm = frontmatter.loads(contents)
        del contents

        document = self.markdown.parse(fm.content.strip())
        name = None
        for elem in document.children:
            if isinstance(elem, marko.block.Heading):
                name = self.renderer.render_children(elem)
                document.children.remove(elem)
                break

        tags: list[str] = fm.metadata.get('tags', [])

        assignments: list[str] = fm.metadata.get('assignments', [])
        assignments = [parse_obsidian_link(text) for text in assignments]

        card_dependencies: list[str] = fm.metadata.get('dependencies', [])
        card_dependencies = [parse_obsidian_link(text) for text in card_dependencies]

        url: list[str] = fm.metadata.get('url')

        description = self.renderer.render_children(document).strip()
        return CardContents(
            None,
            name,
            description,
            tags=tags,
            assignments=assignments,
            card_dependencies=card_dependencies,
            url=url,
        )