Allow specifying document names to bake only those

Author: dannyadair

src/pdfbaker/__main__.py

@@ -8,7 +8,7 @@
 
 from pdfbaker import __version__
 from pdfbaker.baker import PDFBaker, PDFBakerOptions
-from pdfbaker.errors import PDFBakerError
+from pdfbaker.errors import DocumentNotFoundError, PDFBakerError
 
 logger = logging.getLogger(__name__)
 
@@ -24,6 +24,7 @@ def cli() -> None:
     "config_file",
     type=click.Path(exists=True, dir_okay=False, path_type=Path),
 )
+@click.argument("documents", nargs=-1)
 @click.option("-q", "--quiet", is_flag=True, help="Show errors only")
 @click.option("-v", "--verbose", is_flag=True, help="Show debug information")
 @click.option(
@@ -37,13 +38,17 @@ def cli() -> None:
 # pylint: disable=too-many-arguments,too-many-positional-arguments
 def bake(
     config_file: Path,
+    documents: tuple[str, ...],
     quiet: bool,
     verbose: bool,
     trace: bool,
     keep_build: bool,
     debug: bool,
 ) -> int:
-    """Parse config file and bake PDFs."""
+    """Parse config file and bake PDFs.
+
+    Optionally specify one or more document names to only process those documents.
+    """
     if debug:
         verbose = True
         keep_build = True
@@ -56,8 +61,11 @@ def bake(
             keep_build=keep_build,
         )
         baker = PDFBaker(config_file, options=options)
-        success = baker.bake()
+        success = baker.bake(document_names=documents if documents else None)
         sys.exit(0 if success else 1)
+    except DocumentNotFoundError as exc:
+        logger.error(str(exc))
+        sys.exit(2)
     except PDFBakerError as exc:
         logger.error(str(exc))
         sys.exit(1)

src/pdfbaker/baker.py

@@ -12,7 +12,7 @@
 
 from .config import PDFBakerConfiguration, deep_merge
 from .document import PDFBakerDocument
-from .errors import ConfigurationError
+from .errors import ConfigurationError, DocumentNotFoundError
 from .logging import LoggingMixin, setup_logging
 
 __all__ = ["PDFBaker", "PDFBakerOptions"]
@@ -59,6 +59,7 @@ def __init__(
         ) -> None:
             """Initialize baker configuration (needs documents)."""
             self.baker = baker
+            self.name = config_file.name
             self.baker.log_debug_section("Loading main configuration: %s", config_file)
             super().__init__(base_config, config_file)
             self.baker.log_trace(self.pretty())
@@ -67,10 +68,12 @@ def __init__(
                     'Key "documents" missing - is this the main configuration file?'
                 )
             self.build_dir = self["directories"]["build"]
-            self.documents = [
-                self.resolve_path(doc_spec, directory=self["directories"]["documents"])
-                for doc_spec in self["documents"]
-            ]
+            self.documents = []
+            for doc_spec in self["documents"]:
+                doc_path = self.resolve_path(
+                    doc_spec, directory=self["directories"]["documents"]
+                )
+                self.documents.append({"name": doc_path.name, "path": doc_path})
 
     def __init__(
         self,
@@ -99,22 +102,61 @@ def __init__(
             config_file=config_file,
         )
 
-    def bake(self) -> None:
-        """Create PDFs for all documents.
+    def _get_documents_to_process(
+        self, selected_document_names: tuple[str, ...] | None = None
+    ) -> list[Path]:
+        """Get the document paths to process based on optional filtering.
+
+        Args:
+            document_names: Optional tuple of document names to process
+
+        Returns:
+            List of document paths to process
+        """
+        if not selected_document_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:
+            self.log_info(
+                f"Documents in {self.config.name}: %s",
+                ", ".join(f'"{name}"' for name in available_doc_names),
+            )
+            raise DocumentNotFoundError(
+                f"{'Document' if len(missing_docs) == 1 else 'Documents'} not found in "
+                f"configuration: {', '.join(f'"{name}"' for name in missing_docs)}."
+            )
+
+        return [
+            doc
+            for doc in self.config.documents
+            if doc["name"] in selected_document_names
+        ]
+
+    def bake(self, document_names: tuple[str, ...] | None = None) -> bool:
+        """Create PDFs for all documents or only the specified ones.
+
+        Args:
+            document_names: Optional tuple of document names to process
 
         Returns:
         bool: True if all documents were processed successfully, False if any failed
         """
         pdfs_created: list[Path] = []
         failed_docs: list[tuple[str, str]] = []
 
+        documents = self._get_documents_to_process(document_names)
+
         self.log_debug_subsection("Documents to process:")
-        self.log_debug(self.config.documents)
-        for doc_config in self.config.documents:
+        self.log_debug(documents)
+        for doc_config in documents:
             doc = PDFBakerDocument(
                 baker=self,
                 base_config=self.config,
-                config_path=doc_config,
+                config_path=doc_config["path"],
             )
             pdf_files, error_message = doc.process_document()
             if error_message:

src/pdfbaker/errors.py

@@ -16,6 +16,10 @@ class PDFBakerError(Exception):
     """Base exception for PDF baking errors."""
 
 
+class DocumentNotFoundError(PDFBakerError):
+    """Document not found in main configuration."""
+
+
 class ConfigurationError(PDFBakerError):
     """Failed to load or parse configuration."""