Finish transition to pydantic

Major reshuffling.
Tests are all passing again.

Author: dannyadair

src/pdfbaker/baker.py

@@ -10,10 +10,8 @@
 
 from pydantic import BaseModel, ValidationError
 
-from .config import (
-    BakerConfig,
-    PathSpec,
-)
+from .config import PathSpec
+from .config.baker import BakerConfig
 from .document import Document
 from .errors import DocumentNotFoundError
 from .logging import LoggingMixin, setup_logging
@@ -54,63 +52,84 @@ def __init__(
         self.log_debug_section("Loading main configuration: %s", config_file)
         self.config = BakerConfig(
             config_file=config_file,
-            keep_build=options and options.keep_build or False,
+            keep_build=options.keep_build,
             **kwargs,
         )
         self.log_trace(self.config.readable())
 
-    def _get_documents_to_process(
-        self, selected_document_names: tuple[str, ...] | None = None
-    ) -> list[PathSpec]:
-        """Get the document paths to process based on optional filtering.
+    def bake(self, document_names: tuple[str, ...] | None = None) -> None:
+        """Bake the documents."""
+        docs = self._get_selected_documents(document_names)
+        self.log_debug_subsection("Documents to process:")
+        self.log_debug(docs)
+
+        pdfs_created, failed_docs = self._process_documents(docs)
 
-        Args:
-            document_names: Optional tuple of document names to process
+        if pdfs_created:
+            self.log_info("Successfully created PDFs:")
+            for pdf in pdfs_created:
+                self.log_info("  ✅ %s", pdf)
+        else:
+            self.log_warning("No PDFs were created.")
 
-        Returns:
-            List of document paths to process
-        """
-        if not selected_document_names:
+        if not self.config.keep_build:
+            self.teardown()
+
+        if failed_docs:
+            self.log_warning(
+                "Failed to process %d document%s:",
+                len(failed_docs),
+                "" if len(failed_docs) == 1 else "s",
+            )
+            for failed_doc, error_message in failed_docs:
+                name = failed_doc.name
+                if isinstance(failed_doc, Document) and failed_doc.is_variant:
+                    name += f' variant "{failed_doc.variant["name"]}"'
+                self.log_error("  %s: %s", name, error_message)
+
+        return not failed_docs
+
+    def _get_selected_documents(
+        self, selected_names: tuple[str, ...] | None = None
+    ) -> list[PathSpec]:
+        """Return the document paths to actually process as selected."""
+        if not selected_names:
             return self.config.documents
 
-        available_doc_names = [doc.name for doc in self.config.documents]
-        missing_docs = [
-            name for name in selected_document_names if name not in available_doc_names
-        ]
-        if missing_docs:
-            available_str = ", ".join([f'"{name}"' for name in available_doc_names])
+        available = [doc.name for doc in self.config.documents]
+        missing = [name for name in selected_names if name not in available]
+        if missing:
+            available_str = ", ".join([f'"{name}"' for name in available])
             self.log_info(
                 f"Documents in {self.config.config_file.name}: {available_str}"
             )
-            missing_str = ", ".join([f'"{name}"' for name in missing_docs])
+            missing_str = ", ".join([f'"{name}"' for name in missing])
             raise DocumentNotFoundError(
-                f"Document{'s' if len(missing_docs) != 1 else ''} not found "
-                f"in configuration: {missing_str}."
+                f"Document{'s' if len(missing) != 1 else ''} not found "
+                f"in configuration file: {missing_str}."
             )
 
-        return [
-            doc for doc in self.config.documents if doc.name in selected_document_names
-        ]
+        return [doc for doc in self.config.documents if doc.name in selected_names]
 
-    def bake(self, document_names: tuple[str, ...] | None = None) -> None:
-        """Bake the documents."""
+    def _process_documents(
+        self, docs: list[PathSpec]
+    ) -> tuple[list[Path], list[tuple[PathSpec, str]]]:
         pdfs_created: list[Path] = []
         failed_docs: list[tuple[PathSpec, str]] = []
 
-        doc_configs = self._get_documents_to_process(document_names)
-
-        self.log_debug_subsection("Documents to process:")
-        self.log_debug(doc_configs)
-        for doc_config in doc_configs:
+        for config_path in docs:
             try:
                 document = Document(
-                    config_path=doc_config, **self.config.document_settings
+                    config_path=config_path, **self.config.document_settings
                 )
             except ValidationError as e:
-                self.log_error(f'Invalid config for document "{doc_config.name}": {e}')
+                error_message = f'Invalid config for document "{config_path.name}": {e}'
+                self.log_error(error_message)
+                failed_docs.append((config_path, error_message))
                 continue
 
             pdf_files, error_message = document.process_document()
+
             if error_message:
                 self.log_error(
                     "Failed to process document '%s': %s",
@@ -125,26 +144,7 @@ def bake(self, document_names: tuple[str, ...] | None = None) -> None:
             if not self.config.keep_build:
                 document.teardown()
 
-        if pdfs_created:
-            self.log_info("Successfully created PDFs:")
-            for pdf in pdfs_created:
-                self.log_info("  %s", pdf)
-        else:
-            self.log_warning("No PDFs were created.")
-
-        if failed_docs:
-            self.log_warning(
-                "Failed to process %d document%s:",
-                len(failed_docs),
-                "" if len(failed_docs) == 1 else "s",
-            )
-            for doc_name, error in failed_docs:
-                self.log_error("  %s: %s", doc_name, error)
-
-        if not self.config.keep_build:
-            self.teardown()
-
-        return not failed_docs
+        return pdfs_created, failed_docs
 
     def teardown(self) -> None:
         """Clean up (top-level) build directory after processing."""