just save

Author: SilverRainZ

src/sphinxnotes/data/data.py

@@ -215,14 +215,22 @@ class RawData:
     attrs: dict[str, str]
     content: str | None
 
+@dataclass(frozen=True)
+class PendingData:
+    raw: RawData
+    schema: Schema
+
+    def parse(self) -> Data:
+        return self.schema.parse(self.raw)
+
 
 @dataclass
 class Data:
     name: Value
     attrs: dict[str, Value]
     content: Value
 
-    def ascontext(self, lift_attrs: bool = True) -> dict[str, Any]:
+    def ascontext(self) -> dict[str, Any]:
         """
         Convert Data to a dict for usage of Jinja2 context.
 
@@ -236,10 +244,9 @@ def ascontext(self, lift_attrs: bool = True) -> dict[str, Any]:
             the variable name is taken by ``Data.name``.
             """
         ctx = asdict(self)
-        if lift_attrs:
-            for k, v in self.attrs:
-                if k not in ctx:
-                    ctx[k] = v
+        for k, v in self.attrs.items():
+            if k not in ctx:
+                ctx[k] = v
         return ctx
 
 

src/sphinxnotes/data/extra_contexts.py src/sphinxnotes/data/extractxs.pysrc/sphinxnotes/data/extra_contexts.py renamed to src/sphinxnotes/data/extractxs.py

@@ -9,6 +9,7 @@
 """
 
 from __future__ import annotations
+from os import wait
 from typing import TYPE_CHECKING, override, final
 from abc import abstractmethod, ABC
 from dataclasses import dataclass
@@ -20,12 +21,13 @@
 from sphinx.transforms import SphinxTransform
 from sphinx.transforms.post_transforms import ReferencesResolver
 
-from .data import Field, Schema, RawData, Data
-from .template import Template, Phase
-from . import extra_contexts
+from .data import Field, Schema, RawData, Data, PendingData
+from .template import Template, Phase, Context
+from . import extractx
 from . import utils
 
 if TYPE_CHECKING:
+    from typing import Any
     from sphinx.application import Sphinx
     from sphinx.environment import BuildEnvironment
     from .template import MarkupParser
@@ -34,7 +36,6 @@
 
 
 # Possible caller of :meth:`pending_node.render`.
-# TODO: support Any?
 type Caller = SphinxDirective | SphinxRole | SphinxTransform
 
 
@@ -97,7 +98,7 @@ class BaseNode(nodes.Element): ...
 
 
 class RenderedNode(BaseNode):
-    data: Data
+    data: Data # FIXME
     external_name: nodes.Node | None
     external_content: list[nodes.Node]
 
@@ -108,57 +109,53 @@ class rendered_node(RenderedNode, nodes.container): ...
 class rendered_inline_node(RenderedNode, nodes.inline): ...
 
 
-class pending_node(BaseNode, nodes.Invisible, nodes.Element):
-    data: RawData
+class pending_node(BaseNode, nodes.Invisible):
+    #: The context.
+    ctx: Context
+    #: Template for rendering the context.
     template: Template
-    schema: Schema
+    #: Extra context, as a supplement to data.
+    extra: list[dict[str, Any]]
 
     inline: bool = False
     need_external_name: bool = False
     need_external_content: bool = False
 
+    # extra ctx: markup(before paring) relation(just after ReferencesResolver)
+    # all: env config doctree
+
+    def __init__(self, data: Context, tmpl: Template, rawsource='', *children, **attributes):
+        super().__init__(rawsource, *children, **attributes)
+        self.ctx = data
+        self.template = tmpl
+        self.extra = []
+
+
     def render(self, caller: Caller, replace: bool = False) -> RenderedNode:
         rendered = rendered_inline_node() if self.inline else rendered_node()
         rendered.update_all_atts(self)
 
         _caller = _Caller(caller)
-        # Resolve external name and content.
-        if not self.data.name and self.need_external_name:
-            if ns := self._resolve_external_name(_caller.parent_node):
-                self.data.name = ns.astext()
-                rendered.external_name = ns
-        if not self.data.content and self.need_external_content:
-            if ns := self._resolve_external_content():
-                self.data.content = '\n\n'.join([x.astext() for x in ns])
-                rendered.external_content = ns
-
-        try:
-            data = self.schema.parse(self.data)
-        except ValueError as e:
-            if isinstance(caller, SphinxDirective):
-                raise caller.error(str(e))
-            else:
-                raise e
-            # raise self._caller_exception_hanlder(caller, e)
-        else:
-            rendered.data = data
 
-        rendered += self.template.render(
-            _caller.markup_parser,
-            data,
-            {
-                **extra_contexts.sphinx(caller),
-                **extra_contexts.doctree(self),
-                **extra_contexts.markup(self),
-            },
-        )
+        if isinstance(self.ctx, PendingData):
+            self._resolve_external(self.ctx.raw, _caller)
+
+        rendered += self.template.render(_caller.markup_parser, self.ctx)
         # TODO: check tmpl schema line no
 
         if replace:
             self.replace_self(rendered)
 
         return rendered
 
+    def _resolve_external(self, data: RawData, caller: _Caller) -> None:
+        if not data.name and self.need_external_name:
+            if ns := self._resolve_external_name(caller.parent_node):
+                data.name = ns.astext()
+        if not data.content and self.need_external_content:
+            if ns := self._resolve_external_content():
+                data.content = '\n\n'.join([x.astext() for x in ns])
+
     def _resolve_external_name(
         self, caller_parent: nodes.Element | None
     ) -> nodes.Node | None:
@@ -217,8 +214,7 @@ def build_pending_node(self) -> pending_node:
 
         self.process_raw_data(data)
 
-        pending = pending_node()
-        pending.data, pending.template, pending.schema = data, tmpl, schema
+        pending = pending_node(PendingData(data, schema), tmpl)
         self.process_pending_node(pending)
 
         return pending
@@ -368,7 +364,7 @@ def _insert_parsed_hook(app, docname, content):
 
 class _ResolvingHook(SphinxTransform):
     # After resolving pending_xref.
-    default_priority = (ReferencesResolver.default_priority or 10) + 1
+    default_priority = (ReferencesResolver.default_priority or 10) + 5
 
     def apply(self, **kwargs):
         logger.warning(f'running resolving hook for doc {self.env.docname}...')

src/sphinxnotes/data/render.py

@@ -9,10 +9,10 @@
 from sphinx.util import logging
 from sphinx.application import Sphinx
 from sphinx.builders import Builder
-
 from jinja2.sandbox import SandboxedEnvironment
+from jinja2 import StrictUndefined, DebugUndefined
 
-from .data import Data
+from .data import Data, PendingData
 from .utils import Reporter
 
 logger = logging.getLogger(__name__)
@@ -34,6 +34,7 @@ def option_spec(cls, arg):
         choice = directives.choice(arg, [x.value for x in cls])
         return cls[choice.title()]
 
+type Context = PendingData | Data | dict[str, Any]
 
 @dataclass
 class Template(object):
@@ -42,31 +43,74 @@ class Template(object):
     debug: bool
 
     def render(
-        self, parser: MarkupParser, data: Data, extractx: dict[str, Any]
+        self, parser: MarkupParser, ctx: Context, extractxs: list[Context] = []
     ) -> list[nodes.Node]:
-        ctx = data.ascontext()
-        ctx.update(**extractx)
-        text = self._render(ctx)
 
+        mainctx = self._resolve(ctx)
+        finalctx = mainctx.copy()
+
+        dropped_keys = set()
+        for extra in extractxs:
+            for k, v in self._resolve(extra):
+                if k in mainctx:
+                    dropped_keys.add(k)
+                    continue
+                finalctx[k] = v
+
+        text = self._render(mainctx)
         ns = parser(text)
 
         if self.debug:
             reporter = Reporter('Template debug report')
-            reporter.append_text('Data:')
-            reporter.append_code(pformat(data), lang='python')
-            reporter.append_text(
+
+            reporter.text('Data:')
+            reporter.code(pformat(ctx), lang='python')
+
+            reporter.text('Main context:')
+            reporter.code(pformat(mainctx), lang='python')
+
+            reporter.text('Extra context keys:')
+            reporter.list(set(finalctx.keys()) - set(mainctx.keys()))
+
+            reporter.text('Dropped extra conetxt keys:')
+            reporter.list(dropped_keys)
+
+            reporter.text(
                 f'Template (phase: {self.phase}, debug: {self.debug}):'
             )
-            reporter.append_code(self.text, lang='jinja')
-            reporter.append_text('Rendered ndoes:')
-            reporter.append_code('\n'.join(n.pformat() for n in ns), lang='xml')
+            reporter.code(self.text, lang='jinja')
+
+            reporter.text('Rendered ndoes:')
+            reporter.code('\n'.join(n.pformat() for n in ns), lang='xml')
 
             ns.append(reporter)
 
         return ns
 
+
+    def _resolve(self, ctx: Context) -> dict[str, Any]:
+        if isinstance(ctx, PendingData):
+            return ctx.parse().ascontext()
+        elif isinstance(ctx, Data):
+            return ctx.ascontext()
+        elif isinstance(ctx, dict):
+            return ctx
+
+
     def _render(self, ctx: dict[str, Any]) -> str:
-        return _JinjaEnv().from_string(self.text).render(ctx)
+        extensions=[
+            'jinja2.ext.loopcontrols',  # enable {% break %}, {% continue %}
+        ]
+        if self.debug:
+            extensions.append('jinja2.ext.debug')
+
+        env = _JinjaEnv(
+            undefined=DebugUndefined if self.debug else StrictUndefined,
+            extensions=extensions,
+        )
+        # TODO: cache jinja env
+
+        return env.from_string(self.text).render(ctx)
 
 
 class _JinjaEnv(SandboxedEnvironment):
@@ -103,13 +147,8 @@ def is_safe_attribute(self, obj, attr, value=None):
             return False
         return super().is_safe_attribute(obj, attr, value)
 
-    def __init__(self):
-        super().__init__(
-            extensions=[
-                'jinja2.ext.loopcontrols',  # enable {% break %}, {% continue %}
-            ]
-        )
-        logger.warning
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         for name, factory in self._filter_factories.items():
             self.filters[name] = factory(self._builder.env)
 

src/sphinxnotes/data/template.py

@@ -1,12 +1,16 @@
-from typing import TypeVar, cast, Literal
+from __future__ import annotations
+from typing import TYPE_CHECKING, TypeVar, cast
 
 from docutils import nodes
 from docutils.frontend import get_default_settings
 from docutils.parsers.rst import Parser
 from docutils.parsers.rst.states import Struct
 from docutils.utils import new_document
 from sphinx.util import logging
-from sphinx.util.docutils import SphinxRole
+
+if TYPE_CHECKING:
+    from typing import Literal, Iterable
+    from sphinx.util.docutils import SphinxRole
 
 logger = logging.getLogger(__name__)
 
@@ -84,15 +88,28 @@ def __init__(
         level: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR'] = 'DEBUG',
     ) -> None:
         super().__init__(title + ':', type=level, level=2, source='')
-        # logger.warning(f'creating a new report: {title}')
 
-    def append_text(self, text: str) -> None:
-        self += nodes.paragraph(text, text)
-        # logger.warning(f'report append text: {text}')
+    def report(self, node: nodes.Node) -> None:
+        self += node
+        # TODO: print log here
+
+    def text(self, text: str) -> None:
+        self.report(nodes.paragraph(text, text))
 
-    def append_code(self, code: str, lang: str | None = None) -> None:
+    def code(self, code: str, lang: str | None = None) -> None:
         blk = nodes.literal_block(code, code)
         if lang:
             blk['language'] = lang
-        self += blk
-        # logger.warning(f'report append code: {code}')
+        self.report(blk)
+
+    def list(self, lines: Iterable[str]) -> None:
+        bullet_list = nodes.bullet_list(bullet='*')
+        
+        for line in lines:
+            list_item = nodes.list_item()
+            para = nodes.paragraph()
+            para += nodes.Text(line)
+            list_item += para
+            bullet_list += list_item
+            
+        self.report(bullet_list)