fix: remove placeholder strings (#24), use exceptions (#13), add --google-scholar (#10)

- #24: remove 'Unknown Title'/'Unknown University'/'Unknown Author' placeholders
  - _detect_thesis: thesis fallback returns None if no title extracted
  - _convert_search_metadata: school defaults to empty string, not placeholder
- #13: raise FormatError for unsupported output formats (was silent bibtex fallback)
  - Import ValidationError/FormatError in pipeline.py
  - process_references(): raise ValidationError on empty input_content
- #10: add --google-scholar CLI flag, pass use_google_scholar to process_references()
- Update tests: 87 passing

Closes #24
Closes #13
Closes #10

Author: Ang

onecite/cli.py

@@ -105,6 +105,12 @@ def create_parser() -> argparse.ArgumentParser:
         action='store_true',
         help='Suppress verbose logging output'
     )
+    process_parser.add_argument(
+        '--google-scholar',
+        action='store_true',
+        default=False,
+        help='Enable Google Scholar as an additional data source (requires scholarly package)'
+    )
 
     return parser
 
@@ -167,7 +173,8 @@ def interactive_callback(candidates: List[Dict]) -> int:
             input_type=args.input_type,
             template_name=args.template,
             output_format=args.output_format,
-            interactive_callback=interactive_callback
+            interactive_callback=interactive_callback,
+            use_google_scholar=args.google_scholar,
         )
 
         output_content = '\n\n'.join(result['results'])

onecite/core.py

@@ -186,7 +186,8 @@ def process_references(
     input_type: str,
     template_name: str,
     output_format: str,
-    interactive_callback: Callable[[List[Dict]], int]
+    interactive_callback: Callable[[List[Dict]], int],
+    use_google_scholar: bool = False,
 ) -> Dict[str, Any]:
     """Process references and return formatted citations with a report.
 
@@ -216,5 +217,7 @@ def process_references(
         ParseError: If the input cannot be parsed.
         ResolverError: If no data source can resolve a reference.
     """
-    pipeline = PipelineController(use_google_scholar=False)
+    if not input_content or not input_content.strip():
+        raise ValidationError("input_content must not be empty.")
+    pipeline = PipelineController(use_google_scholar=use_google_scholar)
     return pipeline.process(input_content, input_type, template_name, output_format, interactive_callback)

onecite/pipeline.py

@@ -19,7 +19,7 @@
 from html import unescape
 
 from .core import RawEntry, IdentifiedEntry, CompletedEntry
-from .exceptions import ParseError, ResolverError
+from .exceptions import ParseError, ResolverError, ValidationError, FormatError
 import urllib.parse
 
 
@@ -635,7 +635,7 @@ def _detect_thesis(self, text: str) -> Optional[Dict]:
 
             # Pattern: Author (Year). Title. Type. University.
             author_match = re.match(r'^([^(]+?)\s*\(', text)
-            author = author_match.group(1).strip() if author_match else 'Unknown Author'
+            author = author_match.group(1).strip() if author_match else None
 
             year_match = re.search(r'\((\d{4})\)', text)
             year = int(year_match.group(1)) if year_match else None
@@ -677,7 +677,7 @@ def _detect_thesis(self, text: str) -> Optional[Dict]:
                 if openaire_metadata:
                     openaire_metadata['thesis_type'] = thesis_type
                     openaire_metadata['is_thesis'] = True
-                    if author and author != 'Unknown Author':
+                    if author:
                         openaire_metadata['authors'] = [author]
                     if school:
                         openaire_metadata['school'] = school
@@ -688,23 +688,27 @@ def _detect_thesis(self, text: str) -> Optional[Dict]:
                 if base_metadata:
                     base_metadata['thesis_type'] = thesis_type
                     base_metadata['is_thesis'] = True
-                    if author and author != 'Unknown Author':
+                    if author:
                         base_metadata['authors'] = [author]
                     if school:
                         base_metadata['school'] = school
                     return base_metadata
 
-            # Fallback: create basic metadata from extraction
-            return {
+            # Fallback: create basic metadata from extraction (only if we have a title)
+            if not title:
+                return None
+            result = {
                 'source': 'manual',
                 'type': thesis_type,
                 'is_thesis': True,
                 'thesis_type': thesis_type,
-                'title': title or 'Unknown Title',
+                'title': title,
                 'authors': [author] if author else [],
                 'year': year,
-                'school': school or 'Unknown University'
             }
+            if school:
+                result['school'] = school
+            return result
 
         except Exception as e:
             self.logger.warning(f"Failed to detect thesis: {str(e)}")
@@ -2687,7 +2691,7 @@ def _convert_search_metadata(self, metadata: Dict) -> Optional[Dict]:
                 result = {
                     'title': metadata.get('title', ''),
                     'author': formatted_authors,
-                    'school': metadata.get('school', 'Unknown University'),
+                    'school': metadata.get('school', ''),
                     'year': str(metadata.get('year', '')),
                 }
                 if metadata.get('url'):
@@ -3124,8 +3128,7 @@ def format(self, completed_entries: List[CompletedEntry],
                     elif output_format.lower() == 'mla':
                         formatted_string = self._format_mla(entry)
                     else:
-                        # Default to BibTeX
-                        formatted_string = self._format_bibtex(entry)
+                        raise FormatError(f"Unsupported output format: {output_format!r}. Choose 'bibtex', 'apa', or 'mla'.")
 
                     formatted_strings.append(formatted_string)
 

tests/test_cli.py

@@ -87,12 +87,26 @@ def _ns(**overrides):
             output=None,
             interactive=False,
             quiet=False,
+            google_scholar=False,
         )
         defaults.update(overrides)
         return argparse.Namespace(**defaults)
 
     # -- Missing / bad input --------------------------------------------------
 
+    def test_google_scholar_flag_passed_through(self, capsys):
+        """fix #10: --google-scholar flag must be forwarded to process_references."""
+        captured = {}
+
+        def _fake(*, use_google_scholar, **kw):
+            captured['gs'] = use_google_scholar
+            return {"results": ["OK"], "report": {"total": 1, "succeeded": 1, "failed_entries": []}}
+
+        with patch("onecite.cli.process_references", side_effect=_fake):
+            cli.process_command(self._ns(input_file="10.1/x", quiet=True, google_scholar=True))
+
+        assert captured['gs'] is True
+
     def test_string_input_passed_directly(self, capsys):
         """fix #36: non-file argument is treated as inline reference content."""
         captured = {}
@@ -131,7 +145,7 @@ def test_quiet_writes_to_file(self, tmp_path, capsys):
         outf = tmp_path / "out.bib"
 
         def _fake(*, input_content, input_type, template_name,
-                  output_format, interactive_callback):
+                  output_format, interactive_callback, **kw):
             # quiet mode → callback should auto-skip
             assert interactive_callback(
                 [{"title": "T", "authors": [], "journal": "", "year": 2020, "match_score": 75}]
@@ -154,7 +168,7 @@ def test_interactive_selects_first(self, tmp_path, capsys):
         inf.write_text("query", encoding="utf-8")
 
         def _fake(*, input_content, input_type, template_name,
-                  output_format, interactive_callback):
+                  output_format, interactive_callback, **kw):
             choice = interactive_callback([
                 {"title": "A", "authors": ["X"], "journal": "J", "year": 2020, "match_score": 75},
                 {"title": "B", "authors": ["Y"], "journal": "J", "year": 2021, "match_score": 74},
@@ -177,7 +191,7 @@ def test_interactive_invalid_then_skip(self, tmp_path, capsys):
         inf.write_text("query", encoding="utf-8")
 
         def _fake(*, input_content, input_type, template_name,
-                  output_format, interactive_callback):
+                  output_format, interactive_callback, **kw):
             choice = interactive_callback([
                 {"title": "A", "authors": [], "journal": "", "year": 2020, "match_score": 75},
             ])
@@ -196,7 +210,7 @@ def test_interactive_ctrl_c(self, tmp_path, capsys):
         inf.write_text("query", encoding="utf-8")
 
         def _fake(*, input_content, input_type, template_name,
-                  output_format, interactive_callback):
+                  output_format, interactive_callback, **kw):
             assert interactive_callback([
                 {"title": "A", "authors": [], "journal": "", "year": 2020, "match_score": 75},
             ]) == -1
@@ -229,7 +243,7 @@ def test_output_saved_message_and_failures(self, tmp_path, capsys):
         outf = tmp_path / "out.bib"
 
         def _fake(*, input_content, input_type, template_name,
-                  output_format, interactive_callback):
+                  output_format, interactive_callback, **kw):
             return {
                 "results": ["OK"],
                 "report": {"total": 2, "succeeded": 1,

tests/test_pipeline_unit.py

@@ -1025,7 +1025,43 @@ def test_mla_single_author(self):
         }
         assert "Solo, Han." in fmt._format_mla(entry)
 
-    def test_unknown_format_defaults_to_bibtex(self):
+    def test_unsupported_format_raises_format_error(self):
+        """fix #13: unsupported output_format must raise FormatError, not silently use bibtex."""
+        from onecite.exceptions import FormatError
+        fmt = FormatterModule()
+        entry = {
+            "id": 1, "doi": "10.1/x", "status": "completed",
+            "bib_key": "K", "bib_data": {"ENTRYTYPE": "article", "ID": "K", "title": "T"},
+        }
+        r = fmt.format([entry], "ris")
+        assert len(r["report"]["failed_entries"]) == 1
+        assert "Unsupported output format" in r["report"]["failed_entries"][0]["error"]
+
+    def test_no_placeholder_in_thesis_fallback(self):
+        """fix #24: manual thesis fallback must not inject Unknown Title/University."""
+        ident = IdentifierModule()
+        with patch.object(ident, "_search_openaire_for_thesis", return_value=None), \
+             patch.object(ident, "_search_base_for_thesis", return_value=None):
+            result = ident._detect_thesis(
+                "Smith, J. (2020). Neural Architecture Search. PhD Thesis. Stanford University."
+            )
+        if result:
+            assert result.get("title") != "Unknown Title"
+            assert result.get("school") != "Unknown University"
+            assert "Unknown Author" not in str(result.get("authors", []))
+
+    def test_process_references_empty_input_raises(self):
+        """fix #13/#24: empty input_content raises ValidationError."""
+        from onecite.exceptions import ValidationError
+        from onecite.core import process_references
+        import pytest
+        with pytest.raises(ValidationError):
+            process_references("", "txt", "journal_article_full", "bibtex", lambda c: -1)
+        with pytest.raises(ValidationError):
+            process_references("   ", "txt", "journal_article_full", "bibtex", lambda c: -1)
+
+    def test_unknown_format_raises_in_failed_entries(self):
+        """fix #13: unknown format results in failed entry, not silent bibtex fallback."""
         fmt = FormatterModule()
         entry = {
             "id": 1, "doi": "10.1234/x", "status": "completed",
@@ -1034,7 +1070,8 @@ def test_unknown_format_defaults_to_bibtex(self):
                          "author": "Author, A", "year": "2020"},
         }
         r = fmt.format([entry], "unknown_format")
-        assert "@article{Test2020" in r["results"][0]
+        assert r["report"]["succeeded"] == 0
+        assert len(r["report"]["failed_entries"]) == 1
 
 
 # ===================================================================