plain-parser 0.1.3.dev8__py3-none-any.whl → 0.1.4.dev9__py3-none-any.whl

plain_parser/plain_file.py

@@ -709,19 +709,31 @@ def parse_plain_file(
     )
 
 
+@dataclass
+class RequiredModule:
+    """A required module as parsed by the requires walk; validated once the top module is complete."""
+
+    parse_result: PlainFileParseResult
+    # Definitions exported to this module by the modules it requires.
+    ancestor_exported_definitions: list[mistletoe.block_token.token]
+    code_variables: dict
+    # Definitions this module exports to the modules that require it.
+    exported_definitions: list[mistletoe.block_token.token]
+    # Marshalled plain source tree, set once the module is validated.
+    tree: dict | None = None
+
+
 def process_required_modules(
     required_modules: list[str],
     template_dirs: list[str],
     all_required_modules: list[str],
     modules_trace: list[str],
-    chain: list[tuple[str, dict]],
-    module_exports: dict[str, list[mistletoe.block_token.token]],
+    required: dict[str, RequiredModule],
 ) -> list[mistletoe.block_token.token]:
-    """Parse and fully validate every required module, deepest first.
+    """Parse every required module, deepest first, without validating it.
 
-    Appends ``(module name, marshalled plain source tree)`` to ``chain`` for each module not already in it,
-    records each module's exported definitions in ``module_exports``, and returns the exported definitions
-    of the directly required modules.
+    Records each module in ``required`` the first time it is reached (deepest ancestors first) and returns
+    the exported definitions of the directly required modules.
     """
     exported_definitions = list[mistletoe.block_token.token]()
     for module_name in required_modules:
@@ -730,7 +742,7 @@ def process_required_modules(
 
         if len(all_required_modules) > 0 and module_name == all_required_modules[-1]:
             # Already processed as an earlier entry; its exports are still visible to this module.
-            exported_definitions.extend(module_exports[module_name])
+            exported_definitions.extend(required[module_name].exported_definitions)
             continue
 
         code_variables: dict = {}
@@ -753,8 +765,7 @@ def process_required_modules(
                 template_dirs,
                 all_required_modules,
                 modules_trace + [module_name],
-                chain,
-                module_exports,
+                required,
             )
 
         own_exported_definitions = list[mistletoe.block_token.token]()
@@ -770,20 +781,32 @@ def process_required_modules(
                             exported_concept, plain_file_parse_result.plain_source, renderer
                         )
                     )
-        module_exports[module_name] = own_exported_definitions
-        exported_definitions.extend(own_exported_definitions)
-
-        marshalled_plain_source = validate_and_marshall_module(
-            plain_file_parse_result, module_name, ancestor_exported_definitions, code_variables, template_dirs
+        required[module_name] = RequiredModule(
+            plain_file_parse_result, ancestor_exported_definitions, code_variables, own_exported_definitions
         )
-        if module_name not in (chain_module_name for chain_module_name, _ in chain):
-            chain.append((module_name, marshalled_plain_source))
+        exported_definitions.extend(own_exported_definitions)
 
         all_required_modules.append(module_name)
 
     return exported_definitions
 
 
+def validate_required_modules(
+    required_modules: list[str], required: dict[str, RequiredModule], template_dirs: list[str]
+) -> None:
+    """Validate recorded required modules top-down, in listed order, each module once."""
+    for module_name in required_modules:
+        module = required[module_name]
+        if module.tree is not None:
+            continue
+
+        validate_module_structure(module.parse_result, module_name)
+        module.tree = validate_and_build_module_tree(
+            module.parse_result, module_name, module.ancestor_exported_definitions, module.code_variables, template_dirs
+        )
+        validate_required_modules(module.parse_result.required_modules, required, template_dirs)
+
+
 def process_exported_definitions(plain_source: dict, exported_definitions: list[mistletoe.block_token.token]) -> None:
     if len(exported_definitions) == 0:
         return
@@ -806,14 +829,8 @@ def process_exported_definitions(plain_source: dict, exported_definitions: list[
                 plain_source[plain_spec.DEFINITIONS].children.append(exported_definition)
 
 
-def validate_and_marshall_module(
-    plain_file_parse_result: PlainFileParseResult,
-    module_name: str,
-    exported_definitions: list[mistletoe.block_token.token],
-    code_variables: dict,
-    template_dirs: list[str],
-) -> dict:
-    """Every check a module must pass after parsing, and its marshalled plain source tree."""
+def validate_module_structure(plain_file_parse_result: PlainFileParseResult, module_name: str) -> None:
+    """Required concepts defined, functional specs present and non-empty, implementation reqs present."""
     if len(plain_file_parse_result.required_concepts) > 0:
         missing_required_concepts_msg = "Missing required concepts: "
         missing_required_concepts_msg += ", ".join(plain_file_parse_result.required_concepts)
@@ -841,6 +858,16 @@ def validate_and_marshall_module(
         has_requires=bool(plain_file_parse_result.required_modules),
     )
 
+
+def validate_and_build_module_tree(
+    plain_file_parse_result: PlainFileParseResult,
+    module_name: str,
+    exported_definitions: list[mistletoe.block_token.token],
+    code_variables: dict,
+    template_dirs: list[str],
+) -> dict:
+    """Merge exported definitions, validate acceptance tests, linked resources and concepts, and return the
+    marshalled plain source tree."""
     process_exported_definitions(plain_file_parse_result.plain_source, exported_definitions)
 
     process_acceptance_tests(plain_file_parse_result.plain_source)
@@ -890,20 +917,27 @@ def _parse_module(
         modules_trace=[],
     )
 
-    chain: list[tuple[str, dict]] = []
+    # Check the top module's structure, walk its requires, finish the top module's checks, then validate
+    # every required module top-down.
+    validate_module_structure(plain_file_parse_result, module_name)
+
+    required: dict[str, RequiredModule] = {}
     exported_definitions = process_required_modules(
         plain_file_parse_result.required_modules,
         template_dirs=template_dirs,
         all_required_modules=[],
         modules_trace=[],
-        chain=chain,
-        module_exports={},
+        required=required,
     )
 
-    marshalled_plain_source = validate_and_marshall_module(
+    marshalled_plain_source = validate_and_build_module_tree(
         plain_file_parse_result, module_name, exported_definitions, code_variables, template_dirs
     )
 
+    validate_required_modules(plain_file_parse_result.required_modules, required, template_dirs)
+    # The walk records modules deepest first, which is the chain order.
+    chain = [(chain_module_name, module.tree) for chain_module_name, module in required.items()]
+
     return module_name, marshalled_plain_source, plain_file_parse_result.required_modules, chain
 
 

{plain_parser-0.1.3.dev8.dist-info → plain_parser-0.1.4.dev9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: plain-parser
-Version: 0.1.3.dev8
+Version: 0.1.4.dev9
 Summary: Parser for ***plain specification files
 License-Expression: MIT
 License-File: LICENSE

{plain_parser-0.1.3.dev8.dist-info → plain_parser-0.1.4.dev9.dist-info}/RECORD

@@ -5,10 +5,10 @@ plain_parser/exceptions.py,sha256=WcHK5g9K6bsE-ZZBKWl0lZtiMTQ6fif8-zdEx9qjmRw,79
 plain_parser/graph.py,sha256=xZfgzAXoL_hMfqre0Vj4kdvCC8vzfxZgvYptEK9W0Ho,6843
 plain_parser/liquid_nodes.py,sha256=CYmujdPJMK9hLjfFPmnSoKL3Ps4sb-2OOhH-fZUssis,3917
 plain_parser/loaders.py,sha256=o-I7u1NL8hZdTWztqwO7zw072aGxXTBBYSAFDBRG4q0,5136
-plain_parser/plain_file.py,sha256=7QCIh2PlGZoltilLgNirwjm0fdcvDJIMlk9NfR8ViKI,40431
+plain_parser/plain_file.py,sha256=NlcuSbVHS4dbwWEOETv5xY9-mg5y7yZEAvHI6P5maL8,42064
 plain_parser/plain_spec.py,sha256=Z79Vi8bdRiOiM53QyWS8OLNSlGPrQObSZx11Eh8i8Mk,15308
-plain_parser-0.1.3.dev8.dist-info/METADATA,sha256=NI7l_hkUjP8fFa1qcvg-qICxofIM-EAq3yENX6xOeKQ,2647
-plain_parser-0.1.3.dev8.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-plain_parser-0.1.3.dev8.dist-info/entry_points.txt,sha256=pA31GGUyYrmZSpH1CuSzhjrv8pX5ac5HI5hFop1B4eI,55
-plain_parser-0.1.3.dev8.dist-info/licenses/LICENSE,sha256=QClWKncxgRjNUVOW8Axi7zK9HtsMdJEtUSMA4LEe8fo,1071
-plain_parser-0.1.3.dev8.dist-info/RECORD,,
+plain_parser-0.1.4.dev9.dist-info/METADATA,sha256=zTBbXnaNNkU7xZwFrONlUU9iOCOT0a9gnXGOBBIkzRQ,2647
+plain_parser-0.1.4.dev9.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+plain_parser-0.1.4.dev9.dist-info/entry_points.txt,sha256=pA31GGUyYrmZSpH1CuSzhjrv8pX5ac5HI5hFop1B4eI,55
+plain_parser-0.1.4.dev9.dist-info/licenses/LICENSE,sha256=QClWKncxgRjNUVOW8Axi7zK9HtsMdJEtUSMA4LEe8fo,1071
+plain_parser-0.1.4.dev9.dist-info/RECORD,,