Merge pull request #126 from bugzmanov/pre039

Bugs: -c overrites history, djvu filtering, pdf/djvu support in non g…

Author: bugzmanov

src/book_manager.rs

@@ -18,6 +18,8 @@ pub struct BookManager {
     pub books: Vec<BookInfo>,
     scan_directory: String,
     pub library_mode: LibraryMode,
+    #[cfg(feature = "pdf")]
+    pub supports_graphics: bool,
 }
 
 /// Format of a book file
@@ -71,6 +73,8 @@ impl BookManager {
             books,
             scan_directory,
             library_mode,
+            #[cfg(feature = "pdf")]
+            supports_graphics: false,
         }
     }
 
@@ -593,11 +597,13 @@ impl BookManager {
         let mut books: Vec<BookInfo>;
         #[cfg(feature = "pdf")]
         {
-            if !is_pdf_enabled() {
+            if !is_pdf_enabled() || !self.supports_graphics {
                 books = self
                     .books
                     .iter()
-                    .filter(|book| book.format != BookFormat::Pdf)
+                    .filter(|book| {
+                        book.format != BookFormat::Pdf && book.format != BookFormat::Djvu
+                    })
                     .cloned()
                     .collect();
             } else {
@@ -693,6 +699,75 @@ mod tests {
         fs::write(path, contents.as_bytes()).unwrap();
     }
 
+    #[cfg(feature = "pdf")]
+    #[test]
+    fn get_books_filters_pdf_and_djvu_when_pdf_disabled() {
+        use crate::settings::{is_pdf_enabled, set_pdf_enabled};
+
+        let temp_dir = TempDir::new().unwrap();
+        // Create dummy files so discover_books_in_dir picks them up
+        fs::write(temp_dir.path().join("novel.epub"), b"fake").unwrap();
+        fs::write(temp_dir.path().join("paper.pdf"), b"fake").unwrap();
+        fs::write(temp_dir.path().join("scan.djvu"), b"fake").unwrap();
+
+        let manager = BookManager::new_with_directory(temp_dir.path().to_str().unwrap());
+        assert_eq!(manager.books.len(), 3, "all 3 files should be discovered");
+
+        let prev = is_pdf_enabled();
+        set_pdf_enabled(false);
+
+        let filtered = manager.get_books();
+        let formats: Vec<_> = filtered.iter().map(|b| b.format).collect();
+
+        set_pdf_enabled(prev);
+
+        assert!(
+            !formats.contains(&BookFormat::Pdf),
+            "PDF books should be filtered out when pdf is disabled"
+        );
+        assert!(
+            !formats.contains(&BookFormat::Djvu),
+            "DJVU books should be filtered out when pdf is disabled"
+        );
+        assert_eq!(filtered.len(), 1, "only the epub should remain");
+    }
+
+    #[cfg(feature = "pdf")]
+    #[test]
+    fn get_books_filters_pdf_and_djvu_when_no_graphics_support() {
+        use crate::settings::{is_pdf_enabled, set_pdf_enabled};
+
+        let temp_dir = TempDir::new().unwrap();
+        fs::write(temp_dir.path().join("novel.epub"), b"fake").unwrap();
+        fs::write(temp_dir.path().join("paper.pdf"), b"fake").unwrap();
+        fs::write(temp_dir.path().join("scan.djvu"), b"fake").unwrap();
+
+        let manager = BookManager::new_with_directory(temp_dir.path().to_str().unwrap());
+        assert_eq!(manager.books.len(), 3, "all 3 files should be discovered");
+
+        // pdf_enabled is true (default) — simulating a user who has never toggled the setting.
+        // But the terminal doesn't support graphics, so PDFs/DJVUs should still be hidden.
+        let prev = is_pdf_enabled();
+        set_pdf_enabled(true);
+
+        let filtered = manager.get_books();
+        let formats: Vec<_> = filtered.iter().map(|b| b.format).collect();
+
+        set_pdf_enabled(prev);
+
+        // This must hold regardless of the pdf_enabled setting:
+        // a terminal without graphics cannot render PDFs/DJVUs.
+        assert!(
+            !formats.contains(&BookFormat::Pdf),
+            "PDF books should be filtered out when terminal has no graphics support"
+        );
+        assert!(
+            !formats.contains(&BookFormat::Djvu),
+            "DJVU books should be filtered out when terminal has no graphics support"
+        );
+        assert_eq!(filtered.len(), 1, "only the epub should remain");
+    }
+
     #[test]
     fn load_exploded_epub_directory() {
         let temp_dir = TempDir::new().unwrap();

src/bookmarks.rs

@@ -330,6 +330,7 @@ impl Bookmarks {
             bookmark.book_title = book_title;
             bookmark.book_author = book_author;
             bookmark.absolute_path = absolute_path;
+            bookmark.last_read = chrono::Utc::now();
             if total_chapters.is_some() {
                 bookmark.total_chapters = total_chapters;
             }
@@ -492,6 +493,49 @@ mod tests {
         assert_eq!(bookmark.absolute_path.as_deref(), Some("/abs/book.epub"));
     }
 
+    #[test]
+    fn save_initial_bookmark_refreshes_last_read_for_existing_entry() {
+        let mut bookmarks = Bookmarks::ephemeral();
+        let path = "./book.epub";
+
+        bookmarks.save_initial_bookmark(
+            path,
+            "ch1".to_string(),
+            Some(0),
+            Some(10),
+            None,
+            Some("Title".to_string()),
+            None,
+            Some("/abs/book.epub".to_string()),
+        );
+
+        let first_last_read = bookmarks.get_bookmark(path).unwrap().last_read;
+        let refreshed_last_read = loop {
+            bookmarks.save_initial_bookmark(
+                path,
+                "ch2".to_string(),
+                Some(1),
+                Some(10),
+                None,
+                Some("Updated Title".to_string()),
+                None,
+                Some("/abs/book.epub".to_string()),
+            );
+
+            let bookmark = bookmarks.get_bookmark(path).unwrap();
+            if bookmark.last_read > first_last_read {
+                break bookmark.last_read;
+            }
+
+            std::thread::sleep(std::time::Duration::from_millis(1));
+        };
+
+        let bookmark = bookmarks.get_bookmark(path).unwrap();
+        assert!(refreshed_last_read > first_last_read);
+        assert_eq!(bookmark.book_title.as_deref(), Some("Updated Title"));
+        assert_eq!(bookmark.chapter_index, Some(0));
+    }
+
     /// Opening a book from "All Libraries" must NOT create a bookmark entry
     /// in the current library. This simulates the exact main_app.rs flow:
     /// open_book_for_reading_by_path calls set_metadata which creates an entry.

src/main.rs

@@ -16,7 +16,7 @@ use bookokrat::event_source::KeyboardEventSource;
 #[cfg(feature = "pdf")]
 use bookokrat::inputs::UnifiedEventSource;
 use bookokrat::library;
-use bookokrat::main_app::{App, run_app_with_event_source};
+use bookokrat::main_app::{App, run_app_with_event_source, should_auto_load_recent};
 #[cfg(feature = "pdf")]
 use bookokrat::main_app::{
     set_kitty_delete_range_support_override, set_kitty_shm_support_override,
@@ -204,7 +204,11 @@ fn main() -> Result<()> {
             }
         });
     // In test mode: no auto-load, ephemeral bookmarks
-    let auto_load_recent = args.file_path.is_none() && !args.test_mode;
+    let auto_load_recent = should_auto_load_recent(
+        args.file_path.as_deref(),
+        args.test_mode,
+        args.continue_reading,
+    );
     let (bookmark_file, comments_dir) = if args.test_mode {
         (None, None)
     } else if let Ok(ref paths) = lib_paths {

src/main_app.rs

@@ -297,6 +297,14 @@ pub enum AppAction {
     Quit,
 }
 
+pub fn should_auto_load_recent(
+    file_path: Option<&str>,
+    test_mode: bool,
+    continue_reading: bool,
+) -> bool {
+    file_path.is_none() && !test_mode && !continue_reading
+}
+
 #[cfg(feature = "pdf")]
 struct PdfEventResult {
     handled: bool,
@@ -595,11 +603,18 @@ impl App {
         comments_dir: Option<&Path>,
         image_cache_dir: Option<PathBuf>,
     ) -> Self {
-        let book_manager = match book_directory {
+        let mut book_manager = match book_directory {
             Some(dir) => BookManager::new_with_directory(dir),
             None => BookManager::new(),
         };
 
+        #[cfg(feature = "pdf")]
+        let startup_caps = crate::terminal::detect_terminal_with_probe();
+        #[cfg(feature = "pdf")]
+        {
+            book_manager.supports_graphics = startup_caps.supports_graphics;
+        }
+
         let navigation_panel = NavigationPanel::new(&book_manager);
         #[cfg(any(test, feature = "test-utils"))]
         let mut text_reader = MarkdownTextReader::new_without_image_support();
@@ -644,9 +659,6 @@ impl App {
             Rect::new(0, 0, 80, 24)
         };
 
-        #[cfg(feature = "pdf")]
-        let startup_caps = crate::terminal::detect_terminal_with_probe();
-
         let mut app = Self {
             book_manager,
             navigation_panel,
@@ -1234,6 +1246,7 @@ impl App {
             None => crate::terminal::detect_terminal_with_probe(),
         };
         self.pdf_supports_graphics = caps.supports_graphics;
+        self.book_manager.supports_graphics = caps.supports_graphics;
         self.pdf_supports_scroll_mode = caps.pdf.supports_scroll_mode;
 
         if let Some(reason) = caps.pdf.blocked_reason.as_ref() {
@@ -7039,22 +7052,32 @@ mod tests {
             app.save_bookmark_with_throttle(true);
         }
 
-        // --- Session 2: `bookokrat -c` ---
+        // --- Session 2: simulate `bookokrat -c` startup from main.rs ---
         {
+            let auto_load_recent = should_auto_load_recent(None, false, true);
+            assert!(
+                !auto_load_recent,
+                "`bookokrat -c` must skip the home-library auto-open path"
+            );
+
             let mut app = App::new_with_config(
                 Some(dir.path().to_str().unwrap()),
                 Some(home_bm_path.to_str().unwrap()),
-                false,
+                auto_load_recent,
                 None,
                 Some(dir.path().join("img_cache2")),
             );
 
             let recent = crate::library::find_most_recent_book_in(&libraries_dir)
                 .expect("should find book_b");
 
-            // The fix: open with source_bookmarks so context_override is set
             app.open_book_for_reading_with_source_bookmarks(&recent.path, &recent.source_bookmarks)
                 .unwrap();
+            assert_eq!(
+                app.navigation_panel.current_book_path.as_deref(),
+                Some(book_b_abs.to_str().unwrap()),
+                "`bookokrat -c` should reopen the cross-library book"
+            );
             app.save_bookmark_with_throttle(true);
         }