fetchbib 0.1.0__tar.gz

fetchbib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew R. DeVerna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fetchbib-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: fetchbib
+Version: 0.1.0
+Summary: Resolve DOIs and search queries into formatted BibTeX entries.
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file

fetchbib-0.1.0/README.md

@@ -0,0 +1,130 @@
+# fetchbib
+
+A command-line tool to resolve DOIs and free-text search queries into formatted BibTeX entries.
+Powered by [doi.org](https://www.doi.org/) and the [Crossref API](https://api.crossref.org/).
+
+## Installation
+
+```bash
+pip install fetchbib
+```
+
+Requires Python 3.9+.
+
+## Quick start
+
+Fetch BibTeX by DOI (bare or full URL):
+
+```bash
+fbib 10.2196/jmir.1933
+fbib https://doi.org/10.2196/jmir.1933
+```
+
+```bibtex
+@article{Eysenbach2011,
+  author = {Eysenbach, Gunther},
+  doi = {10.2196/jmir.1933},
+  journal = {Journal of Medical Internet Research},
+  title = {Can Tweets Predict Citations? Metrics of Social Impact Based on Twitter and Correlation with Traditional Metrics of Scientific Impact},
+  year = {2011}
+}
+```
+
+Search by free text:
+
+```bash
+fbib "Eysenbach JMIR 2011"
+```
+
+## Usage
+
+```
+fbib [-h] [-f FILE] [-o OUTPUT] [-a] [-v] [--config-email EMAIL]
+     [inputs ...]
+```
+
+### Flexible input
+
+`fbib` accepts DOIs in any format — bare, full URL, or free-text search queries — and you can mix them freely.
+Inputs are comma-separated, so all of the following work:
+
+```bash
+# Multiple positional arguments
+fbib 10.2196/jmir.1933 10.1038/nature12373
+
+# Comma-separated string
+fbib "10.2196/jmir.1933, 10.1038/nature12373"
+
+# Full DOI URLs
+fbib "https://doi.org/10.2196/jmir.1933, https://doi.org/10.1038/nature12373"
+
+# Mix DOIs, URLs, and search queries
+fbib 10.2196/jmir.1933 "Eysenbach JMIR 2011"
+```
+
+From a file (`--file`), each line is treated the same way — one entry per line, or comma-separated on a single line:
+
+```bash
+fbib --file dois.txt
+```
+
+Duplicate inputs are automatically removed.
+
+### Write to a file
+
+Overwrite (default):
+
+```bash
+fbib --output refs.bib 10.2196/jmir.1933
+```
+
+Append to an existing `.bib` file:
+
+```bash
+fbib --append --output refs.bib 10.1038/nature12373
+```
+
+### Verbose mode
+
+See which DOI was matched when searching by free text:
+
+```bash
+fbib -v "Eysenbach JMIR 2011"
+# stderr: Searching for: "Eysenbach JMIR 2011" -> DOI: 10.2196/jmir.1933
+```
+
+### Configure email
+
+Crossref gives better rate limits to requests that include a contact email. Set yours once and it will be used for all future requests:
+
+```bash
+fbib --config-email you@example.com
+```
+
+The email is stored in `~/.config/fetchbib/config.json`. If not set, a default placeholder is used.
+
+## Development
+
+Clone the repo and sync dependencies with [uv](https://docs.astral.sh/uv/):
+
+```bash
+git clone https://github.com/mr-devs/fetchbib.git
+cd fetchbib
+uv sync
+```
+
+Run unit tests:
+
+```bash
+uv run pytest
+```
+
+Run integration tests (hits live APIs):
+
+```bash
+uv run pytest -m integration
+```
+
+## License
+
+MIT

fetchbib-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fetchbib"
+version = "0.1.0"
+description = "Resolve DOIs and search queries into formatted BibTeX entries."
+requires-python = ">=3.9"
+dependencies = ["requests"]
+
+[project.scripts]
+fbib = "fetchbib.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[dependency-groups]
+dev = ["pytest"]
+
+[tool.pytest.ini_options]
+markers = ["integration: tests that hit live APIs (deselect with '-m not integration')"]
+addopts = "-m 'not integration'"

fetchbib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fetchbib-0.1.0/src/fetchbib/cli.py

@@ -0,0 +1,149 @@
+"""Command-line interface for fetchbib.
+
+Entry point: ``fbib``
+"""
+
+import argparse
+import sys
+
+from fetchbib import config
+from fetchbib.formatter import format_bibtex
+from fetchbib.resolver import (
+    ResolverError,
+    is_doi,
+    normalize_doi_input,
+    resolve_doi,
+    search_crossref,
+)
+
+
+def main() -> None:
+    """Parse arguments and resolve each input to formatted BibTeX."""
+    parser = argparse.ArgumentParser(
+        prog="fbib",
+        description="Resolve DOIs or search queries into formatted BibTeX.",
+    )
+    parser.add_argument(
+        "inputs",
+        nargs="*",
+        help="DOIs or search queries (comma-separated values are split)",
+    )
+    parser.add_argument(
+        "-f",
+        "--file",
+        help="Path to a text file with one input per line",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Write results to this file instead of stdout",
+    )
+    parser.add_argument(
+        "-a",
+        "--append",
+        action="store_true",
+        help="Append to the output file instead of overwriting (requires --output)",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Print which DOI was selected for search queries",
+    )
+    parser.add_argument(
+        "--config-email",
+        metavar="EMAIL",
+        help="Set the email used in the User-Agent header and exit",
+    )
+
+    args = parser.parse_args()
+
+    # --config-email: save and exit immediately
+    if args.config_email:
+        config.set_email(args.config_email)
+        sys.exit(0)
+
+    # Collect inputs
+    queries = _collect_inputs(args)
+    if not queries:
+        print(
+            "Error: no inputs provided. Pass DOIs/queries as arguments or use --file.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Resolve each input
+    results: list[str] = []
+    had_error = False
+
+    for query in queries:
+        try:
+            bibtex = _resolve_single(query, verbose=args.verbose)
+            results.append(bibtex)
+        except ResolverError as exc:
+            print(f"Error resolving '{query}': {exc}", file=sys.stderr)
+            had_error = True
+
+    output_text = "\n\n".join(results)
+    if results:
+        output_text += "\n"
+
+    # Write output
+    if args.output:
+        mode = "a" if args.append else "w"
+        with open(args.output, mode) as f:
+            f.write(output_text)
+    else:
+        print(output_text, end="")
+
+    if had_error:
+        sys.exit(1)
+
+
+def _collect_inputs(args: argparse.Namespace) -> list[str]:
+    """Gather inputs from positional args and --file, deduplicate."""
+    raw: list[str] = []
+
+    # Positional args (each may be comma-separated)
+    for arg in args.inputs or []:
+        raw.extend(_split_and_strip(arg))
+
+    # File input (each line may also be comma-separated)
+    if args.file:
+        try:
+            with open(args.file) as f:
+                for line in f:
+                    raw.extend(_split_and_strip(line))
+        except FileNotFoundError:
+            print(f"Error: file not found: {args.file}", file=sys.stderr)
+            sys.exit(1)
+
+    # Deduplicate preserving order
+    seen: set[str] = set()
+    unique: list[str] = []
+    for item in raw:
+        if item not in seen:
+            seen.add(item)
+            unique.append(item)
+    return unique
+
+
+def _split_and_strip(value: str) -> list[str]:
+    """Split a string on commas and return non-empty stripped parts."""
+    return [part.strip() for part in value.split(",") if part.strip()]
+
+
+def _resolve_single(query: str, *, verbose: bool) -> str:
+    """Resolve a single query to formatted BibTeX."""
+    query = normalize_doi_input(query)
+    if is_doi(query):
+        raw = resolve_doi(query)
+    else:
+        doi = search_crossref(query)
+        if verbose:
+            print(
+                f'Searching for: "{query}" -> DOI: {doi}',
+                file=sys.stderr,
+            )
+        raw = resolve_doi(doi)
+    return format_bibtex(raw)

fetchbib-0.1.0/src/fetchbib/config.py

@@ -0,0 +1,40 @@
+"""User configuration for fetchbib.
+
+Reads and writes a JSON config file at ~/.config/fetchbib/config.json.
+"""
+
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "fetchbib"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULT_EMAIL = "fetchbib@example.com"
+
+
+def get_email() -> str:
+    """Return the configured email, or the default if none is set."""
+    cfg = _read_config()
+    return cfg.get("email", DEFAULT_EMAIL)
+
+
+def set_email(email: str) -> None:
+    """Persist the email to the config file."""
+    cfg = _read_config()
+    cfg["email"] = email
+    _write_config(cfg)
+
+
+def _read_config() -> dict:
+    """Read the config file, returning an empty dict if it doesn't exist."""
+    if not CONFIG_FILE.exists():
+        return {}
+    with open(CONFIG_FILE) as f:
+        return json.load(f)
+
+
+def _write_config(cfg: dict) -> None:
+    """Write the config dict to disk, creating the directory if needed."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(cfg, f, indent=2)

fetchbib-0.1.0/src/fetchbib/formatter.py

@@ -0,0 +1,102 @@
+"""BibTeX string formatter.
+
+Transforms raw (often single-line) BibTeX into a clean, readable format
+with alphabetized fields, 2-space indentation, and proper line breaks.
+"""
+
+
+def format_bibtex(raw: str) -> str:
+    """Format a raw BibTeX entry into a clean, readable string.
+
+    Rules:
+        - Entry header (@type{key,) stays on the first line.
+        - Each field is on its own line with 2-space indentation.
+        - Fields are alphabetized.
+        - Closing brace is on its own line.
+        - Trailing commas are removed.
+
+    Commas inside braced values (e.g. author names) are preserved — only
+    top-level commas are treated as field separators.
+    """
+    header, fields_block = _split_header(raw.strip())
+    fields = _parse_fields(fields_block)
+    fields.sort(key=lambda kv: kv[0].lower())
+
+    field_lines = [f"  {key} = {value}" for key, value in fields]
+    return header + "\n" + ",\n".join(field_lines) + "\n}"
+
+
+def _split_header(entry: str) -> tuple[str, str]:
+    """Split a BibTeX entry into header and fields block.
+
+    The header is everything up to and including the first top-level comma
+    after the citation key (e.g. '@article{Key2020,').
+    The fields block is the rest, minus the final closing '}'.
+    """
+    # Find the first comma that is not inside braces — this ends the key.
+    depth = 0
+    for i, ch in enumerate(entry):
+        if ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+        elif ch == "," and depth == 1:
+            header = entry[: i + 1]
+            rest = entry[i + 1 :]
+            # Strip the outermost closing brace from the rest
+            rest = rest.strip()
+            if rest.endswith("}"):
+                rest = rest[:-1].strip()
+            return header, rest
+    # Fallback: no fields found
+    return entry, ""
+
+
+def _parse_fields(block: str) -> list[tuple[str, str]]:
+    """Parse a block of BibTeX fields into (key, value) pairs.
+
+    Splits on top-level commas only (not commas inside braces).
+    """
+    if not block.strip():
+        return []
+
+    fields = []
+    for raw_field in _split_top_level(block, ","):
+        raw_field = raw_field.strip()
+        if not raw_field:
+            continue
+        # Split on the first '=' to get key and value
+        eq_pos = raw_field.find("=")
+        if eq_pos == -1:
+            continue
+        key = raw_field[:eq_pos].strip()
+        value = raw_field[eq_pos + 1 :].strip()
+        fields.append((key, value))
+    return fields
+
+
+def _split_top_level(text: str, delimiter: str) -> list[str]:
+    """Split text on a delimiter, but only at brace depth 0."""
+    parts = []
+    depth = 0
+    current: list[str] = []
+
+    for ch in text:
+        if ch == "{":
+            depth += 1
+            current.append(ch)
+        elif ch == "}":
+            depth -= 1
+            current.append(ch)
+        elif ch == delimiter and depth == 0:
+            parts.append("".join(current))
+            current = []
+        else:
+            current.append(ch)
+
+    # Append whatever is left
+    trailing = "".join(current).strip()
+    if trailing:
+        parts.append(trailing)
+
+    return parts

fetchbib-0.1.0/src/fetchbib/resolver.py

@@ -0,0 +1,95 @@
+"""DOI resolution and Crossref search.
+
+Provides functions to check if a string is a DOI, resolve a DOI to BibTeX,
+search Crossref for a DOI, and an orchestrator that combines them.
+"""
+
+import re
+
+import requests
+
+from fetchbib import config
+
+DOI_PATTERN = re.compile(r"^10\.\d{4,9}/[-._;()/:A-Z0-9]+$", re.IGNORECASE)
+DOI_URL_PREFIXES = (
+    "https://doi.org/",
+    "http://doi.org/",
+    "https://dx.doi.org/",
+    "http://dx.doi.org/",
+)
+
+DOI_BASE_URL = "https://doi.org/"
+CROSSREF_API_URL = "https://api.crossref.org/works"
+
+
+class ResolverError(Exception):
+    """Raised when DOI resolution or Crossref search fails."""
+
+
+def normalize_doi_input(value: str) -> str:
+    """Strip common DOI URL prefixes, returning a bare DOI if possible.
+
+    For example, ``https://doi.org/10.2196/jmir.1933`` becomes
+    ``10.2196/jmir.1933``. Non-URL strings are returned unchanged.
+    """
+    for prefix in DOI_URL_PREFIXES:
+        if value.startswith(prefix):
+            return value[len(prefix) :]
+    return value
+
+
+def is_doi(value: str) -> bool:
+    """Return True if *value* looks like a bare DOI (e.g. 10.xxxx/yyyy)."""
+    return bool(DOI_PATTERN.match(value))
+
+
+def get_user_agent() -> str:
+    """Build the User-Agent string using the configured email."""
+    email = config.get_email()
+    return f"fetchbib/1.0 (mailto:{email})"
+
+
+def resolve_doi(doi: str) -> str:
+    """Fetch BibTeX for a DOI from doi.org.
+
+    Raises ResolverError on non-200 responses.
+    """
+    headers = {
+        "Accept": "text/bibliography; style=bibtex",
+        "User-Agent": get_user_agent(),
+    }
+    resp = requests.get(f"{DOI_BASE_URL}{doi}", headers=headers)
+    if resp.status_code != 200:
+        raise ResolverError(
+            f"DOI resolution failed for '{doi}': HTTP {resp.status_code}"
+        )
+    return resp.text
+
+
+def search_crossref(query: str) -> str:
+    """Search Crossref and return the DOI of the first result.
+
+    Raises ResolverError on non-200 responses or empty results.
+    """
+    headers = {"User-Agent": get_user_agent()}
+    resp = requests.get(CROSSREF_API_URL, params={"query": query}, headers=headers)
+    if resp.status_code != 200:
+        raise ResolverError(f"Crossref search failed: HTTP {resp.status_code}")
+    items = resp.json()["message"]["items"]
+    if not items:
+        raise ResolverError(f"No results found for query: '{query}'")
+    return items[0]["DOI"]
+
+
+def resolve(query: str) -> str:
+    """Resolve a DOI, DOI URL, or free-text query to raw BibTeX.
+
+    DOI URLs (e.g. https://doi.org/10.xxxx/yyyy) are normalized to bare
+    DOIs before resolution. If the input is a DOI, fetches directly.
+    Otherwise searches Crossref for the top result and resolves that DOI.
+    """
+    query = normalize_doi_input(query)
+    if is_doi(query):
+        return resolve_doi(query)
+    doi = search_crossref(query)
+    return resolve_doi(doi)

fetchbib-0.1.0/src/fetchbib.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: fetchbib
+Version: 0.1.0
+Summary: Resolve DOIs and search queries into formatted BibTeX entries.
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file

fetchbib-0.1.0/src/fetchbib.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/fetchbib/__init__.py
+src/fetchbib/cli.py
+src/fetchbib/config.py
+src/fetchbib/formatter.py
+src/fetchbib/resolver.py
+src/fetchbib.egg-info/PKG-INFO
+src/fetchbib.egg-info/SOURCES.txt
+src/fetchbib.egg-info/dependency_links.txt
+src/fetchbib.egg-info/entry_points.txt
+src/fetchbib.egg-info/requires.txt
+src/fetchbib.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_formatter.py
+tests/test_integration.py
+tests/test_resolver.py

fetchbib-0.1.0/src/fetchbib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fetchbib-0.1.0/src/fetchbib.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fbib = fetchbib.cli:main

fetchbib-0.1.0/src/fetchbib.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

fetchbib-0.1.0/src/fetchbib.egg-info/top_level.txt

@@ -0,0 +1 @@
+fetchbib

fetchbib-0.1.0/tests/test_cli.py

@@ -0,0 +1,257 @@
+"""Tests for the CLI (Phase 3).
+
+All resolver calls are mocked — no network access needed.
+"""
+
+import json
+import sys
+import tempfile
+from io import StringIO
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from fetchbib.resolver import ResolverError
+
+# Sample raw BibTeX that the mock resolver returns (unformatted).
+RAW_BIBTEX_A = "@article{Key1,author={Alice},year={2020}}"
+RAW_BIBTEX_B = "@article{Key2,author={Bob},year={2021}}"
+
+
+def run_cli(args: list[str]) -> tuple[int, str, str]:
+    """Run the CLI main() with the given args, returning (exit_code, stdout, stderr)."""
+    from fetchbib.cli import main
+
+    old_argv = sys.argv
+    sys.argv = ["fbib"] + args
+
+    stdout_capture = StringIO()
+    stderr_capture = StringIO()
+
+    exit_code = 0
+    try:
+        with patch("sys.stdout", stdout_capture), patch("sys.stderr", stderr_capture):
+            main()
+    except SystemExit as e:
+        exit_code = e.code if e.code is not None else 0
+    finally:
+        sys.argv = old_argv
+
+    return exit_code, stdout_capture.getvalue(), stderr_capture.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Input parsing
+# ---------------------------------------------------------------------------
+
+
+class TestInputParsing:
+    """Tests for how the CLI collects and processes inputs."""
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_A)
+    def test_single_positional_doi(self, mock_resolve):
+        code, stdout, _ = run_cli(["10.2196/jmir.1933"])
+
+        mock_resolve.assert_called_once_with("10.2196/jmir.1933")
+        assert "@article{Key1," in stdout
+        assert code == 0
+
+    @patch("fetchbib.cli.resolve_doi", side_effect=[RAW_BIBTEX_A, RAW_BIBTEX_B])
+    def test_multiple_positional_arguments(self, mock_resolve):
+        code, stdout, _ = run_cli(["10.2196/jmir.1933", "10.1000/xyz123"])
+
+        assert mock_resolve.call_count == 2
+        assert "Key1" in stdout
+        assert "Key2" in stdout
+        assert code == 0
+
+    @patch("fetchbib.cli.resolve_doi", side_effect=[RAW_BIBTEX_A, RAW_BIBTEX_B])
+    def test_comma_separated_string_is_split(self, mock_resolve):
+        code, stdout, _ = run_cli(["10.2196/jmir.1933, 10.1000/xyz123"])
+
+        assert mock_resolve.call_count == 2
+        calls = [c.args[0] for c in mock_resolve.call_args_list]
+        assert "10.2196/jmir.1933" in calls
+        assert "10.1000/xyz123" in calls
+        assert code == 0
+
+    @patch("fetchbib.cli.resolve_doi", side_effect=[RAW_BIBTEX_A, RAW_BIBTEX_B])
+    def test_file_input_reads_lines(self, mock_resolve):
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("10.2196/jmir.1933\n\n10.1000/xyz123\n")
+            f.flush()
+            code, stdout, _ = run_cli(["--file", f.name])
+
+        assert mock_resolve.call_count == 2
+        assert code == 0
+
+    @patch("fetchbib.cli.resolve_doi", side_effect=[RAW_BIBTEX_A, RAW_BIBTEX_B])
+    def test_file_input_splits_comma_separated_line(self, mock_resolve):
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("10.2196/jmir.1933, 10.1000/xyz123\n")
+            f.flush()
+            code, stdout, _ = run_cli(["--file", f.name])
+
+        assert mock_resolve.call_count == 2
+        calls = [c.args[0] for c in mock_resolve.call_args_list]
+        assert "10.2196/jmir.1933" in calls
+        assert "10.1000/xyz123" in calls
+        assert code == 0
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_A)
+    def test_doi_url_is_normalized(self, mock_resolve):
+        code, stdout, _ = run_cli(["https://doi.org/10.2196/jmir.1933"])
+
+        mock_resolve.assert_called_once_with("10.2196/jmir.1933")
+        assert "@article{Key1," in stdout
+        assert code == 0
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_A)
+    def test_duplicate_inputs_are_deduplicated(self, mock_resolve):
+        code, _, _ = run_cli(["10.2196/jmir.1933", "10.2196/jmir.1933"])
+
+        mock_resolve.assert_called_once()
+        assert code == 0
+
+
+# ---------------------------------------------------------------------------
+# Error handling
+# ---------------------------------------------------------------------------
+
+
+class TestErrorHandling:
+    """Tests for error conditions and exit codes."""
+
+    def test_nonexistent_file_exits_1(self):
+        code, _, stderr = run_cli(["--file", "nonexistent_file.txt"])
+
+        assert code == 1
+        assert "nonexistent_file.txt" in stderr
+
+    @patch("fetchbib.cli.resolve_doi")
+    def test_resolution_error_does_not_stop_others(self, mock_resolve):
+        mock_resolve.side_effect = [
+            ResolverError("fail"),
+            RAW_BIBTEX_B,
+        ]
+
+        code, stdout, stderr = run_cli(["10.1234/bad", "10.1234/good"])
+
+        assert "Key2" in stdout
+        assert "fail" in stderr
+        assert code == 1
+
+    def test_no_inputs_exits_1(self):
+        code, _, stderr = run_cli([])
+
+        assert code == 1
+        assert stderr  # should contain some usage hint
+
+
+# ---------------------------------------------------------------------------
+# Verbose mode
+# ---------------------------------------------------------------------------
+
+
+class TestVerbose:
+    """Tests for the --verbose flag."""
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_A)
+    @patch("fetchbib.cli.search_crossref", return_value="10.2196/jmir.1933")
+    def test_verbose_prints_search_mapping(self, mock_search, mock_resolve):
+        code, _, stderr = run_cli(["-v", "Eysenbach JMIR 2011"])
+
+        assert "Eysenbach JMIR 2011" in stderr
+        assert "10.2196/jmir.1933" in stderr
+        assert code == 0
+
+
+# ---------------------------------------------------------------------------
+# Output file
+# ---------------------------------------------------------------------------
+
+
+class TestOutputFile:
+    """Tests for --output and --append flags."""
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_A)
+    def test_output_writes_to_file(self, mock_resolve):
+        with tempfile.NamedTemporaryFile(suffix=".bib", delete=False) as f:
+            path = f.name
+
+        code, stdout, _ = run_cli(["--output", path, "10.1234/test"])
+
+        assert code == 0
+        assert stdout == ""  # nothing to stdout
+        content = Path(path).read_text()
+        assert "Key1" in content
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_A)
+    def test_output_overwrites_by_default(self, mock_resolve):
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".bib", delete=False) as f:
+            f.write("OLD CONTENT\n")
+            path = f.name
+
+        run_cli(["--output", path, "10.1234/test"])
+
+        content = Path(path).read_text()
+        assert "OLD CONTENT" not in content
+        assert "Key1" in content
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_B)
+    def test_append_flag_preserves_existing(self, mock_resolve):
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".bib", delete=False) as f:
+            f.write("EXISTING ENTRY\n\n")
+            path = f.name
+
+        code, stdout, _ = run_cli(["--append", "--output", path, "10.1234/test"])
+
+        assert code == 0
+        assert stdout == ""
+        content = Path(path).read_text()
+        assert "EXISTING ENTRY" in content
+        assert "Key2" in content
+
+
+# ---------------------------------------------------------------------------
+# Config email
+# ---------------------------------------------------------------------------
+
+
+class TestConfigEmail:
+    """Tests for --config-email."""
+
+    def test_config_email_saves_and_exits(self, tmp_path):
+        config_file = tmp_path / "config.json"
+        with (
+            patch("fetchbib.config.CONFIG_FILE", config_file),
+            patch("fetchbib.config.CONFIG_DIR", tmp_path),
+        ):
+            code, _, _ = run_cli(["--config-email", "user@university.edu"])
+
+        assert code == 0
+        saved = json.loads(config_file.read_text())
+        assert saved["email"] == "user@university.edu"
+
+    @patch("fetchbib.cli.resolve_doi", return_value=RAW_BIBTEX_A)
+    def test_config_email_used_by_resolver(self, mock_resolve, tmp_path):
+        config_file = tmp_path / "config.json"
+        config_file.write_text(json.dumps({"email": "custom@uni.edu"}))
+
+        with (
+            patch("fetchbib.config.CONFIG_FILE", config_file),
+            patch("fetchbib.config.CONFIG_DIR", tmp_path),
+        ):
+            run_cli(["10.1234/test"])
+
+        headers = mock_resolve.call_args  # we can't easily check headers here
+        # Instead, verify the user agent function reads the config
+        with (
+            patch("fetchbib.config.CONFIG_FILE", config_file),
+            patch("fetchbib.config.CONFIG_DIR", tmp_path),
+        ):
+            from fetchbib.resolver import get_user_agent
+
+            ua = get_user_agent()
+        assert "custom@uni.edu" in ua

fetchbib-0.1.0/tests/test_formatter.py

@@ -0,0 +1,72 @@
+"""Tests for the BibTeX formatter (Phase 1)."""
+
+from fetchbib.formatter import format_bibtex
+
+
+class TestFormatBibtex:
+    """Tests for format_bibtex()."""
+
+    def test_single_line_is_formatted(self):
+        """Single-line BibTeX is split into indented, alphabetized fields."""
+        raw = (
+            "@article{Eysenbach2011,"
+            "doi={10.2196/jmir.1933},"
+            "title={Can Tweets Predict Citations?},"
+            "author={Eysenbach, Gunther},"
+            "year={2011},"
+            "journal={JMIR}}"
+        )
+        expected = (
+            "@article{Eysenbach2011,\n"
+            "  author = {Eysenbach, Gunther},\n"
+            "  doi = {10.2196/jmir.1933},\n"
+            "  journal = {JMIR},\n"
+            "  title = {Can Tweets Predict Citations?},\n"
+            "  year = {2011}\n"
+            "}"
+        )
+        assert format_bibtex(raw) == expected
+
+    def test_idempotent(self):
+        """Already-formatted BibTeX passes through unchanged."""
+        clean = (
+            "@article{Eysenbach2011,\n"
+            "  author = {Eysenbach, Gunther},\n"
+            "  doi = {10.2196/jmir.1933},\n"
+            "  journal = {JMIR},\n"
+            "  title = {Can Tweets Predict Citations?},\n"
+            "  year = {2011}\n"
+            "}"
+        )
+        assert format_bibtex(clean) == clean
+
+    def test_author_commas_preserved(self):
+        """Commas inside braces (author names) are not treated as field separators."""
+        raw = (
+            "@article{Key2020,"
+            "author={Last, First and Last2, First2},"
+            "title={A Title},"
+            "year={2020}}"
+        )
+        result = format_bibtex(raw)
+        assert "author = {Last, First and Last2, First2}" in result
+
+    def test_trailing_comma_removed(self):
+        """A trailing comma before the closing brace is stripped."""
+        raw = "@article{Key2020," "author={Someone}," "year={2020},}"
+        result = format_bibtex(raw)
+        # The last field line should not end with a comma
+        lines = result.strip().split("\n")
+        last_field_line = lines[-2]  # line before closing '}'
+        assert not last_field_line.rstrip().endswith(",")
+
+    def test_nested_braces_preserved(self):
+        """Nested braces in field values are kept intact."""
+        raw = (
+            "@inproceedings{Key2021,"
+            "title={A {GPU}-Accelerated Approach},"
+            "author={Smith, John},"
+            "year={2021}}"
+        )
+        result = format_bibtex(raw)
+        assert "title = {A {GPU}-Accelerated Approach}" in result

fetchbib-0.1.0/tests/test_integration.py

@@ -0,0 +1,58 @@
+"""Integration tests that hit live APIs.
+
+Skipped by default. Run with:
+    pytest -m integration
+"""
+
+import tempfile
+
+import pytest
+
+from fetchbib.formatter import format_bibtex
+from fetchbib.resolver import resolve, resolve_doi, search_crossref
+
+pytestmark = pytest.mark.integration
+
+
+class TestLiveResolution:
+    """End-to-end tests against doi.org and Crossref."""
+
+    def test_doi_resolution(self):
+        raw = resolve_doi("10.2196/jmir.1933")
+        result = format_bibtex(raw)
+        assert "Eysenbach" in result
+        assert "2011" in result
+
+    def test_free_text_search(self):
+        doi = search_crossref("Eysenbach JMIR 2011")
+        raw = resolve_doi(doi)
+        result = format_bibtex(raw)
+        assert "Eysenbach" in result
+
+    def test_file_input_via_cli(self):
+        """Resolve a DOI through the full CLI path."""
+        import sys
+        from io import StringIO
+        from unittest.mock import patch
+
+        from fetchbib.cli import main
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("10.2196/jmir.1933\n")
+            f.flush()
+            path = f.name
+
+        old_argv = sys.argv
+        sys.argv = ["fbib", "--file", path]
+        stdout_capture = StringIO()
+
+        try:
+            with patch("sys.stdout", stdout_capture):
+                main()
+        except SystemExit:
+            pass
+        finally:
+            sys.argv = old_argv
+
+        output = stdout_capture.getvalue()
+        assert "Eysenbach" in output

fetchbib-0.1.0/tests/test_resolver.py

@@ -0,0 +1,233 @@
+"""Tests for the resolver (Phase 2).
+
+All HTTP calls are mocked — no network access needed.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from fetchbib.resolver import (
+    ResolverError,
+    is_doi,
+    normalize_doi_input,
+    resolve,
+    resolve_doi,
+    search_crossref,
+)
+
+# ---------------------------------------------------------------------------
+# is_doi
+# ---------------------------------------------------------------------------
+
+
+class TestIsDoi:
+    """Tests for DOI pattern matching."""
+
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "10.2196/jmir.1933",
+            "10.1000/xyz123",
+            "10.1234/some-thing_(here)",
+        ],
+    )
+    def test_valid_dois(self, value):
+        assert is_doi(value) is True
+
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "not a doi",
+            "10.12345",  # no suffix after slash
+            "",
+            "http://doi.org/10.2196/jmir.1933",  # full URL
+        ],
+    )
+    def test_invalid_inputs(self, value):
+        assert is_doi(value) is False
+
+
+# ---------------------------------------------------------------------------
+# normalize_doi_input
+# ---------------------------------------------------------------------------
+
+
+class TestNormalizeDOIInput:
+    """Tests for stripping DOI URL prefixes."""
+
+    @pytest.mark.parametrize(
+        "url,expected",
+        [
+            ("https://doi.org/10.2196/jmir.1933", "10.2196/jmir.1933"),
+            ("http://doi.org/10.2196/jmir.1933", "10.2196/jmir.1933"),
+            ("https://dx.doi.org/10.2196/jmir.1933", "10.2196/jmir.1933"),
+            ("http://dx.doi.org/10.2196/jmir.1933", "10.2196/jmir.1933"),
+        ],
+    )
+    def test_strips_doi_url_prefixes(self, url, expected):
+        assert normalize_doi_input(url) == expected
+
+    def test_bare_doi_unchanged(self):
+        assert normalize_doi_input("10.2196/jmir.1933") == "10.2196/jmir.1933"
+
+    def test_non_doi_string_unchanged(self):
+        assert normalize_doi_input("Eysenbach JMIR 2011") == "Eysenbach JMIR 2011"
+
+
+# ---------------------------------------------------------------------------
+# resolve_doi
+# ---------------------------------------------------------------------------
+
+
+class TestResolveDoi:
+    """Tests for fetching BibTeX from doi.org."""
+
+    @patch("fetchbib.resolver.requests.get")
+    def test_returns_bibtex_on_success(self, mock_get):
+        bibtex = "@article{Key, author={Someone}, year={2020}}"
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.text = bibtex
+        mock_get.return_value = mock_resp
+
+        result = resolve_doi("10.1234/test")
+
+        assert result == bibtex
+        # Verify correct headers were sent
+        call_kwargs = mock_get.call_args
+        headers = call_kwargs.kwargs.get("headers") or call_kwargs[1].get("headers", {})
+        assert headers["Accept"] == "text/bibliography; style=bibtex"
+        assert "fetchbib" in headers["User-Agent"]
+
+    @patch("fetchbib.resolver.requests.get")
+    def test_raises_on_http_failure(self, mock_get):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 404
+        mock_get.return_value = mock_resp
+
+        with pytest.raises(ResolverError, match="404"):
+            resolve_doi("10.1234/missing")
+
+
+# ---------------------------------------------------------------------------
+# search_crossref
+# ---------------------------------------------------------------------------
+
+
+class TestSearchCrossref:
+    """Tests for the Crossref search API."""
+
+    @patch("fetchbib.resolver.requests.get")
+    def test_extracts_doi_from_first_result(self, mock_get):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.json.return_value = {
+            "message": {
+                "items": [
+                    {"DOI": "10.2196/jmir.1933"},
+                    {"DOI": "10.9999/other"},
+                ]
+            }
+        }
+        mock_get.return_value = mock_resp
+
+        assert search_crossref("Eysenbach JMIR 2011") == "10.2196/jmir.1933"
+
+    @patch("fetchbib.resolver.requests.get")
+    def test_raises_on_empty_results(self, mock_get):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.json.return_value = {"message": {"items": []}}
+        mock_get.return_value = mock_resp
+
+        with pytest.raises(ResolverError, match="[Nn]o results"):
+            search_crossref("nonexistent gibberish query")
+
+    @patch("fetchbib.resolver.requests.get")
+    def test_raises_on_http_failure(self, mock_get):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 503
+        mock_get.return_value = mock_resp
+
+        with pytest.raises(ResolverError, match="503"):
+            search_crossref("anything")
+
+
+# ---------------------------------------------------------------------------
+# resolve (orchestrator)
+# ---------------------------------------------------------------------------
+
+
+class TestResolve:
+    """Tests for the top-level resolve() orchestrator."""
+
+    @patch("fetchbib.resolver.resolve_doi")
+    @patch("fetchbib.resolver.search_crossref")
+    def test_routes_doi_directly(self, mock_search, mock_resolve_doi):
+        mock_resolve_doi.return_value = "@article{...}"
+
+        resolve("10.2196/jmir.1933")
+
+        mock_resolve_doi.assert_called_once_with("10.2196/jmir.1933")
+        mock_search.assert_not_called()
+
+    @patch("fetchbib.resolver.resolve_doi")
+    @patch("fetchbib.resolver.search_crossref")
+    def test_routes_doi_url_directly(self, mock_search, mock_resolve_doi):
+        mock_resolve_doi.return_value = "@article{...}"
+
+        resolve("https://doi.org/10.2196/jmir.1933")
+
+        mock_resolve_doi.assert_called_once_with("10.2196/jmir.1933")
+        mock_search.assert_not_called()
+
+    @patch("fetchbib.resolver.resolve_doi")
+    @patch("fetchbib.resolver.search_crossref")
+    def test_routes_non_doi_through_search(self, mock_search, mock_resolve_doi):
+        mock_search.return_value = "10.2196/jmir.1933"
+        mock_resolve_doi.return_value = "@article{...}"
+
+        resolve("Eysenbach JMIR 2011")
+
+        mock_search.assert_called_once_with("Eysenbach JMIR 2011")
+        mock_resolve_doi.assert_called_once_with("10.2196/jmir.1933")
+
+
+# ---------------------------------------------------------------------------
+# Config / User-Agent
+# ---------------------------------------------------------------------------
+
+
+class TestUserAgentConfig:
+    """Tests for configurable User-Agent email."""
+
+    @patch("fetchbib.resolver.requests.get")
+    @patch("fetchbib.resolver.config.get_email", return_value="custom@university.edu")
+    def test_custom_email_in_user_agent(self, _mock_email, mock_get):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.text = "@article{...}"
+        mock_get.return_value = mock_resp
+
+        resolve_doi("10.1234/test")
+
+        headers = (
+            mock_get.call_args.kwargs.get("headers") or mock_get.call_args[1]["headers"]
+        )
+        assert "custom@university.edu" in headers["User-Agent"]
+
+    @patch("fetchbib.resolver.requests.get")
+    @patch("fetchbib.resolver.config.get_email", return_value="fetchbib@example.com")
+    def test_default_email_in_user_agent(self, _mock_email, mock_get):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.text = "@article{...}"
+        mock_get.return_value = mock_resp
+
+        resolve_doi("10.1234/test")
+
+        headers = (
+            mock_get.call_args.kwargs.get("headers") or mock_get.call_args[1]["headers"]
+        )
+        assert "fetchbib@example.com" in headers["User-Agent"]