rxiv-maker 1.16.7__tar.gz → 1.16.8__tar.gz

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/CHANGELOG.md

@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.16.8] - 2025-12-19
+
+### Added
+
+- **Automatic Poppler Installation**: Interactive installation prompt for DOCX export on macOS
+  - Detects missing poppler utilities when exporting to DOCX with PDF figures
+  - Offers automatic installation via Homebrew with user confirmation
+  - Shows clear installation instructions for Linux (apt) and other platforms
+  - Gracefully falls back to placeholders when poppler unavailable
+- **DOI Resolution Implementation**: `--resolve-dois` flag now fully functional for DOCX export
+  - Resolves missing DOIs using CrossRef API with intelligent title matching
+  - Cleans LaTeX commands from titles for accurate search results
+  - Validates matches using year information when available
+  - Handles network failures and timeouts gracefully
+  - Logs resolved DOIs for transparency
+- **Poppler Dependency Tracking**: Registered poppler in DependencyManager
+  - Added as system binary dependency with alternatives (pdftoppm, pdfinfo)
+  - Included in `rxiv check-installation` output
+  - Provides platform-specific installation hints
+
+### Fixed
+
+- **BST File Regex Bug**: Corrected bibliography style file generation to only modify `format.names`
+  - Previous regex matched both `format.names` and `format.full.names` functions
+  - Now specifically targets only `format.names` function using DOTALL flag
+  - Prevents corruption of citation labels in natbib
+  - Eliminates warning: "Found 2 format string patterns in .bst file"
+  - Raises error if unexpected matches found (defensive programming)
+- **PDF to Image Conversion**: Improved error handling for missing poppler utilities
+  - Distinguishes between poppler not installed, corrupted PDFs, and other errors
+  - Uses proper logging instead of print statements
+  - Re-raises poppler errors to allow CLI to offer installation
+  - Provides specific error messages for different failure types
+
+### Changed
+
+- **DOCX Export Experience**: Enhanced PDF figure embedding workflow
+  - Pre-flight check detects poppler availability before attempting conversion
+  - Caches poppler status to avoid repeated checks
+  - Shows helpful warnings with installation instructions
+  - PDF figures embed correctly when poppler is installed
+- **Homebrew Formula**: Added poppler as dependency
+  - Users installing via `brew install rxiv-maker` now get poppler automatically
+  - Ensures DOCX export works out of the box for Homebrew users
+
 ## [1.16.7] - 2025-12-18
 
 ### Changed

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rxiv-maker
-Version: 1.16.7
+Version: 1.16.8
 Summary: Write scientific preprints in Markdown. Generate publication-ready PDFs efficiently.
 Project-URL: Homepage, https://github.com/HenriquesLab/rxiv-maker
 Project-URL: Documentation, https://github.com/HenriquesLab/rxiv-maker#readme

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/src/rxiv_maker/__version__.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "1.16.7"
+__version__ = "1.16.8"

rxiv_maker-1.16.8/src/rxiv_maker/cli/commands/docx.py

@@ -0,0 +1,177 @@
+"""DOCX export command for rxiv-maker CLI."""
+
+import platform
+import shutil
+import subprocess
+
+import rich_click as click
+from rich.console import Console
+
+from ...core.logging_config import get_logger
+from ...core.managers.dependency_manager import DependencyStatus, get_dependency_manager
+from ...exporters.docx_exporter import DocxExporter
+
+logger = get_logger()
+console = Console()
+
+
+def _check_and_offer_poppler_installation(console: Console, quiet: bool, verbose: bool) -> None:
+    """Check poppler availability and offer automatic installation via brew.
+
+    Args:
+        console: Rich console for output
+        quiet: Whether to suppress output
+        verbose: Whether verbose mode is enabled
+    """
+    # Check if poppler is installed
+    manager = get_dependency_manager()
+    result = manager.check_dependency("pdftoppm")
+
+    if result.status == DependencyStatus.AVAILABLE:
+        if verbose:
+            console.print("[dim]✓ Poppler utilities available[/dim]")
+        return
+
+    # Poppler is missing - offer to install
+    system = platform.system()
+
+    if system == "Darwin" and shutil.which("brew"):
+        # macOS with Homebrew
+        if not quiet:
+            console.print("[yellow]⚠️  Poppler not found[/yellow]")
+            console.print("   Poppler is needed to embed PDF figures in DOCX files.")
+            console.print("   Without it, PDF figures will appear as placeholders.")
+            console.print()
+
+        if click.confirm("   Would you like to install poppler now via Homebrew?", default=True):
+            console.print("[cyan]Installing poppler...[/cyan]")
+            try:
+                result = subprocess.run(
+                    ["brew", "install", "poppler"],
+                    capture_output=True,
+                    text=True,
+                    timeout=300,
+                )
+
+                if result.returncode == 0:
+                    console.print("[green]✅ Poppler installed successfully![/green]")
+                    # Clear dependency cache so it gets re-checked
+                    manager.clear_cache()
+                else:
+                    console.print(f"[red]❌ Installation failed:[/red] {result.stderr}")
+                    console.print("   You can install manually with: brew install poppler")
+            except subprocess.TimeoutExpired:
+                console.print("[red]❌ Installation timed out[/red]")
+            except Exception as e:
+                console.print(f"[red]❌ Installation error:[/red] {e}")
+        else:
+            console.print("   [dim]Skipping poppler installation. PDF figures will show as placeholders.[/dim]")
+
+    elif system == "Linux":
+        # Linux
+        if not quiet:
+            console.print("[yellow]⚠️  Poppler not found[/yellow]")
+            console.print("   Install with: sudo apt install poppler-utils")
+            console.print()
+    else:
+        # Other platforms or brew not available
+        if not quiet:
+            console.print("[yellow]⚠️  Poppler not found[/yellow]")
+            console.print(f"   Install instructions: {result.resolution_hint}")
+            console.print()
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument(
+    "manuscript_path",
+    type=click.Path(exists=True, file_okay=False),
+    required=False,
+    metavar="[MANUSCRIPT_PATH]",
+)
+@click.option(
+    "--resolve-dois",
+    "-r",
+    is_flag=True,
+    help="Attempt to resolve missing DOIs from metadata",
+)
+@click.option(
+    "--no-footnotes",
+    is_flag=True,
+    help="Disable references section (citations only)",
+)
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-essential output")
+def docx(
+    manuscript_path: str | None,
+    resolve_dois: bool,
+    no_footnotes: bool,
+    verbose: bool,
+    quiet: bool,
+) -> None:
+    """Export manuscript to DOCX format for collaborative review.
+
+    Generates a Word document with numbered citations, embedded figures,
+    and a complete references section with DOI links. Output is automatically
+    saved to the manuscript directory with the same naming pattern as the PDF.
+
+    **MANUSCRIPT_PATH**: Directory containing manuscript files.
+    Defaults to MANUSCRIPT/
+
+    **Output**: Automatically saved to MANUSCRIPT/YEAR__lastname_et_al__rxiv.docx
+
+    ## Examples
+
+    **Basic export:**
+
+        $ rxiv docx
+
+    **Export from custom directory:**
+
+        $ rxiv docx MY_PAPER/
+
+    **With DOI resolution for missing entries:**
+
+        $ rxiv docx --resolve-dois
+
+    **Without references section (citations only):**
+
+        $ rxiv docx --no-footnotes
+    """
+    try:
+        # Configure logging
+        if verbose:
+            logger.set_level("DEBUG")
+        elif quiet:
+            logger.set_level("WARNING")
+
+        # Set manuscript path
+        manuscript_path = manuscript_path or "MANUSCRIPT"
+
+        # Create exporter
+        if not quiet:
+            console.print("[cyan]📄 Exporting manuscript to DOCX...[/cyan]")
+
+        exporter = DocxExporter(
+            manuscript_path=manuscript_path,
+            resolve_dois=resolve_dois,
+            include_footnotes=not no_footnotes,
+        )
+
+        # Pre-flight check for poppler (if manuscript contains PDF figures)
+        _check_and_offer_poppler_installation(console, quiet, verbose)
+
+        # Perform export
+        docx_path = exporter.export()
+
+        # Success message
+        if not quiet:
+            console.print(f"[green]✅ DOCX exported:[/green] {docx_path}")
+
+    except FileNotFoundError as e:
+        console.print(f"[red]❌ Error:[/red] {e}")
+        raise click.Abort() from e
+    except Exception as e:
+        if verbose:
+            logger.error(f"DOCX export failed: {e}")
+        console.print(f"[red]❌ Export failed:[/red] {e}")
+        raise click.Abort() from e

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/src/rxiv_maker/core/managers/dependency_manager.py

@@ -487,6 +487,18 @@ class DependencyManager:
                 )
             )
 
+        # Poppler utilities for PDF to image conversion (DOCX export)
+        self.register_dependency(
+            DependencySpec(
+                name="pdftoppm",
+                type=DependencyType.SYSTEM_BINARY,
+                required=False,  # Only needed for DOCX export with PDF figures
+                alternatives=["pdfinfo"],
+                contexts={"docx", "export"},
+                install_hint="macOS: brew install poppler | Linux: sudo apt install poppler-utils",
+            )
+        )
+
     def register_dependency(self, spec: DependencySpec) -> None:
         """Register a dependency specification.
 

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/src/rxiv_maker/exporters/docx_exporter.py

@@ -318,9 +318,13 @@ class DocxExporter:
             # Get DOI from entry
             doi = entry.fields.get("doi")
 
-            # TODO: Implement DOI resolution if requested and DOI missing
-            # if self.resolve_dois and not doi:
-            #     doi = self._resolve_doi_from_metadata(entry)
+            # Attempt DOI resolution if requested and DOI missing
+            if self.resolve_dois and not doi:
+                doi = self._resolve_doi_from_metadata(entry)
+                if doi:
+                    # Store in entry for this export
+                    entry.fields["doi"] = doi
+                    logger.info(f"Resolved DOI for {key}: {doi}")
 
             # Format entry (full format for DOCX bibliography)
             formatted = format_bibliography_entry(entry, doi, slim=False, author_format=self.author_format)
@@ -332,6 +336,99 @@ class DocxExporter:
 
         return bibliography
 
+    def _resolve_doi_from_metadata(self, entry) -> str | None:
+        """Resolve DOI from entry metadata using CrossRef API.
+
+        Args:
+            entry: Bibliography entry to resolve DOI for
+
+        Returns:
+            Resolved DOI if found, None otherwise
+        """
+        import requests
+
+        # Try to construct a search query from available fields
+        title = entry.fields.get("title", "").strip()
+        year = entry.fields.get("year", "").strip()
+
+        if not title:
+            logger.debug(f"Cannot resolve DOI for {entry.key}: no title")
+            return None
+
+        # Clean title for search (remove LaTeX commands, braces, etc.)
+        search_title = self._clean_title_for_search(title)
+
+        # Try CrossRef search API
+        try:
+            url = "https://api.crossref.org/works"
+            params = {
+                "query.title": search_title,
+                "rows": 5,  # Get top 5 results
+            }
+
+            response = requests.get(url, params=params, timeout=10)
+
+            if response.status_code == 200:
+                data = response.json()
+                items = data.get("message", {}).get("items", [])
+
+                # Find best match
+                for item in items:
+                    item_title = item.get("title", [""])[0].lower()
+                    search_title_lower = search_title.lower()
+
+                    # Simple similarity check - titles should be very similar
+                    if item_title and (search_title_lower in item_title or item_title in search_title_lower):
+                        # Verify year matches if available
+                        if year:
+                            item_year = item.get("published", {}).get("date-parts", [[None]])[0][0]
+                            if item_year and str(item_year) != year:
+                                continue
+
+                        doi = item.get("DOI")
+                        if doi:
+                            logger.info(f"Resolved DOI for {entry.key}: {doi}")
+                            return doi
+
+            logger.debug(f"Could not resolve DOI for {entry.key} via CrossRef")
+            return None
+
+        except requests.exceptions.Timeout:
+            logger.debug(f"CrossRef API timeout resolving DOI for {entry.key}")
+            return None
+        except requests.exceptions.ConnectionError:
+            logger.debug(f"CrossRef API connection error for {entry.key}")
+            return None
+        except Exception as e:
+            logger.debug(f"Error resolving DOI for {entry.key}: {e}")
+            return None
+
+    def _clean_title_for_search(self, title: str) -> str:
+        """Clean title for CrossRef search by removing LaTeX commands.
+
+        Args:
+            title: Raw title from BibTeX entry
+
+        Returns:
+            Cleaned title suitable for search
+        """
+        import re
+
+        # Remove LaTeX commands
+        title = re.sub(r"\\[a-zA-Z]+\{([^}]*)\}", r"\1", title)  # \textit{foo} -> foo
+        title = re.sub(r"\\[a-zA-Z]+", "", title)  # \LaTeX -> LaTeX
+
+        # Remove braces
+        title = title.replace("{", "").replace("}", "")
+
+        # Remove special characters
+        title = re.sub(r"[^a-zA-Z0-9\s\-]", " ", title)
+
+        # Normalize whitespace
+        title = " ".join(title.split())
+
+        return title.strip()
+
     def _get_metadata(self) -> Dict[str, Any]:
         """Extract metadata for title page.
 

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/src/rxiv_maker/exporters/docx_writer.py

@@ -404,6 +404,19 @@ class DocxWriter:
         paragraph_format = paragraph.paragraph_format
         paragraph_format.left_indent = Pt(36)  # Indent code blocks
 
+    def _check_poppler_availability(self) -> bool:
+        """Check if poppler is available for PDF conversion.
+
+        Returns:
+            True if poppler is available, False otherwise
+        """
+        from ..core.managers.dependency_manager import DependencyStatus, get_dependency_manager
+
+        manager = get_dependency_manager()
+        result = manager.check_dependency("pdftoppm")
+
+        return result.status == DependencyStatus.AVAILABLE
+
     def _add_figure(self, doc: Document, section: Dict[str, Any], figure_number: int = None):
         """Add figure to document with caption.
 
@@ -425,9 +438,31 @@ class DocxWriter:
         if not figure_path.exists():
             logger.warning(f"Figure file not found: {figure_path}")
         elif figure_path.suffix.lower() == ".pdf":
-            # Convert PDF to image
-            img_source = convert_pdf_to_image(figure_path)
-            logger.debug(f"  PDF converted: {img_source is not None}")
+            # Check poppler availability first (cached after first check)
+            if not hasattr(self, "_poppler_checked"):
+                self._poppler_available = self._check_poppler_availability()
+                self._poppler_checked = True
+
+                if not self._poppler_available:
+                    logger.warning(
+                        "Poppler not installed - PDF figures will be shown as placeholders. "
+                        "Install with: brew install poppler (macOS) or sudo apt install poppler-utils (Linux)"
+                    )
+
+            if self._poppler_available:
+                # Convert PDF to image
+                try:
+                    from pdf2image.exceptions import PDFInfoNotInstalledError, PopplerNotInstalledError
+
+                    img_source = convert_pdf_to_image(figure_path)
+                    logger.debug(f"  PDF converted: {img_source is not None}")
+                except (PopplerNotInstalledError, PDFInfoNotInstalledError) as e:
+                    logger.error(f"Poppler utilities not found: {e}")
+                    img_source = None
+                    # Update our cached status
+                    self._poppler_available = False
+            else:
+                img_source = None
         elif figure_path.suffix.lower() in [".png", ".jpg", ".jpeg", ".gif", ".bmp"]:
             # Use image file directly
             img_source = str(figure_path)

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/src/rxiv_maker/utils/bst_generator.py

@@ -81,21 +81,41 @@ def generate_bst_file(format_type: str, output_dir: Path) -> Path:
     except IOError as e:
         raise IOError(f"Failed to read template .bst file: {e}") from e
 
-    # Replace the format string on line 222
+    # Replace the format string in the format.names function (line ~222)
     # The line looks like: s nameptr "{ff~}{vv~}{ll}{, jj}" format.name$ 't :=
-    # We need to replace the format string in quotes
-    pattern = r'(s\s+nameptr\s+")([^"]+)("\s+format\.name\$)'
+    # We need to replace ONLY in format.names, NOT in format.full.names
+    #
+    # Strategy: Match the FUNCTION {format.names} block specifically
+    # This ensures we don't modify format.full.names which is used for citation labels
+    #
+    # Pattern explanation:
+    # 1. Match "FUNCTION {format.names}" to find the start of the function
+    # 2. Use non-greedy match (.*?) to capture until we find our target line
+    # 3. Match and capture the format string in quotes
+    # 4. This avoids matching format.full.names which appears later in the file
+    pattern = r'(FUNCTION\s+\{format\.names\}.*?s\s+nameptr\s+")([^"]+)("\s+format\.name\$)'
     replacement = rf"\1{format_string}\3"
 
-    modified_content, num_subs = re.subn(pattern, replacement, bst_content)
+    modified_content, num_subs = re.subn(pattern, replacement, bst_content, flags=re.DOTALL)
 
     if num_subs == 0:
-        logger.warning("No format string pattern found in .bst file. The .bst file may have been modified.")
+        logger.warning(
+            "No format string pattern found in format.names function. "
+            "The .bst file structure may have changed. "
+            "Citation formatting may not work as expected."
+        )
         # Still write the file but log a warning
     elif num_subs > 1:
-        logger.warning(
-            f"Found {num_subs} format string patterns in .bst file. Expected only 1. All have been replaced."
+        # This should never happen with the new pattern, but keep the check
+        logger.error(
+            f"Found {num_subs} matches in .bst file. Expected exactly 1. "
+            "This indicates an unexpected .bst file structure. "
+            "Please report this issue."
         )
+        raise ValueError(f"Unexpected .bst file structure: found {num_subs} matches for format.names, expected 1")
+    else:
+        # Success - exactly one match
+        logger.debug(f"Successfully updated format.names function with format '{format_type}'")
 
     # Create output directory if it doesn't exist
     output_dir = Path(output_dir)

{rxiv_maker-1.16.7 → rxiv_maker-1.16.8}/src/rxiv_maker/utils/docx_helpers.py

@@ -8,6 +8,7 @@ This module provides utility functions for DOCX generation including:
 """
 
 import io
+import logging
 import re
 from pathlib import Path
 from typing import Optional
@@ -18,6 +19,8 @@ from rxiv_maker.utils.author_name_formatter import format_author_list
 
 from ..utils.bibliography_parser import BibEntry
 
+logger = logging.getLogger(__name__)
+
 
 def remove_yaml_header(content: str) -> str:
     r"""Remove YAML frontmatter from markdown content.
@@ -395,6 +398,12 @@ def convert_pdf_to_image(pdf_path: Path, dpi: int = 150, max_width: int = 6) ->
     """
     try:
         from pdf2image import convert_from_path
+        from pdf2image.exceptions import (
+            PDFInfoNotInstalledError,
+            PDFPageCountError,
+            PDFSyntaxError,
+            PopplerNotInstalledError,
+        )
 
         # Convert first page of PDF to image
         images = convert_from_path(
@@ -427,7 +436,19 @@ def convert_pdf_to_image(pdf_path: Path, dpi: int = 150, max_width: int = 6) ->
 
         return img_bytes
 
+    except (PopplerNotInstalledError, PDFInfoNotInstalledError):
+        # Re-raise poppler errors so caller can handle them appropriately
+        # (e.g., CLI can offer to install poppler)
+        raise
+    except PDFSyntaxError as e:
+        # PDF file is malformed/corrupted
+        logger.warning(f"PDF file appears to be corrupted: {pdf_path.name} - {e}")
+        return None
+    except PDFPageCountError as e:
+        # Issue getting page count
+        logger.warning(f"Could not determine PDF page count for {pdf_path.name}: {e}")
+        return None
     except Exception as e:
-        # Log error but don't crash - return None to indicate failure
-        print(f"Warning: Failed to convert PDF to image: {e}")
+        # Other unexpected errors
+        logger.warning(f"Failed to convert {pdf_path.name} to image: {e}")
         return None

rxiv_maker-1.16.8/tests/unit/test_bst_generator.py

@@ -0,0 +1,132 @@
+"""Unit tests for BST generator functionality."""
+
+import re
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from rxiv_maker.utils.bst_generator import generate_bst_file
+
+
+@pytest.mark.unit
+class TestBSTGenerator:
+    """Test BST file generation and format string replacement."""
+
+    def extract_function_section(self, content: str, function_name: str) -> str:
+        """Extract a specific FUNCTION block from BST content.
+
+        Args:
+            content: BST file content
+            function_name: Name of the function to extract
+
+        Returns:
+            The function block content
+        """
+        pattern = rf"FUNCTION\s+\{{{function_name}\}}.*?(?=FUNCTION|\Z)"
+        match = re.search(pattern, content, re.DOTALL)
+        return match.group(0) if match else ""
+
+    def test_bst_generator_only_modifies_format_names(self):
+        """Ensure format.full.names is not modified (regression test for #XXX)."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Generate BST with lastname_initials format
+            output_path = generate_bst_file("lastname_initials", temp_dir)
+
+            # Read generated file
+            content = output_path.read_text()
+
+            # Verify format.names was modified (should have new format)
+            format_names_section = self.extract_function_section(content, "format.names")
+            assert "{vv~}{ll}{, f.}" in format_names_section, "format.names should have lastname_initials format"
+
+            # Verify format.full.names was NOT modified (should have original format)
+            format_full_names_section = self.extract_function_section(content, "format.full.names")
+            assert "{vv~}{ll}" in format_full_names_section, "format.full.names should keep original format"
+            assert "{vv~}{ll}{, f.}" not in format_full_names_section, (
+                "format.full.names should NOT have our modified format"
+            )
+
+    def test_bst_generator_lastname_initials_format(self):
+        """Test BST generation with lastname_initials format."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_path = generate_bst_file("lastname_initials", temp_dir)
+
+            assert output_path.exists()
+            content = output_path.read_text()
+
+            # Should contain the lastname_initials format: {vv~}{ll}{, f.}
+            format_names_section = self.extract_function_section(content, "format.names")
+            assert "{vv~}{ll}{, f.}" in format_names_section
+
+    def test_bst_generator_lastname_firstname_format(self):
+        """Test BST generation with lastname_firstname format."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_path = generate_bst_file("lastname_firstname", temp_dir)
+
+            assert output_path.exists()
+            content = output_path.read_text()
+
+            # Should contain the lastname_firstname format: {vv~}{ll}{, ff}
+            format_names_section = self.extract_function_section(content, "format.names")
+            assert "{vv~}{ll}{, ff}" in format_names_section
+
+    def test_bst_generator_firstname_lastname_format(self):
+        """Test BST generation with firstname_lastname format."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_path = generate_bst_file("firstname_lastname", temp_dir)
+
+            assert output_path.exists()
+            content = output_path.read_text()
+
+            # Should contain the firstname_lastname format: {ff~}{vv~}{ll}
+            format_names_section = self.extract_function_section(content, "format.names")
+            assert "{ff~}{vv~}{ll}" in format_names_section
+
+    def test_bst_generator_creates_output_directory(self):
+        """Test that BST generator creates output directory if it doesn't exist."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            nested_dir = Path(temp_dir) / "nested" / "output"
+            output_path = generate_bst_file("lastname_initials", str(nested_dir))
+
+            assert nested_dir.exists()
+            assert output_path.exists()
+
+    def test_bst_generator_file_name(self):
+        """Test that generated BST file has correct name."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_path = generate_bst_file("lastname_initials", temp_dir)
+
+            assert output_path.name == "rxiv_maker_style.bst"
+
+    def test_bst_generator_invalid_format_type(self):
+        """Test that invalid format type raises appropriate error."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with pytest.raises(ValueError, match="Invalid bibliography author format"):
+                generate_bst_file("invalid_format", temp_dir)
+
+    def test_bst_both_functions_exist_in_template(self):
+        """Verify the BST template contains both format.names and format.full.names."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_path = generate_bst_file("lastname_initials", temp_dir)
+            content = output_path.read_text()
+
+            # Both functions should exist
+            assert "FUNCTION {format.names}" in content
+            assert "FUNCTION {format.full.names}" in content
+
+    def test_bst_regex_matches_exactly_once(self):
+        """Verify that the regex pattern matches exactly once (not multiple times)."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_path = generate_bst_file("lastname_initials", temp_dir)
+            content = output_path.read_text()
+
+            # Count occurrences of our modified format
+            format_names_section = self.extract_function_section(content, "format.names")
+            format_full_names_section = self.extract_function_section(content, "format.full.names")
+
+            # Should appear once in format.names
+            assert format_names_section.count("{vv~}{ll}{, f.}") == 1
+
+            # Should NOT appear in format.full.names
+            assert format_full_names_section.count("{vv~}{ll}{, f.}") == 0