ebook 0.1.2

A CLI tool for reading, writing, and operating on various ebook formats
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299

use crate::{EbookError, Result, Progress};
use crate::traits::{EbookReader, EbookWriter};
use crate::formats::{EpubHandler, TxtHandler, MobiHandler, Fb2Handler, PdfHandler};
use std::path::Path;

/// Conversion utility for converting between ebook formats
pub struct Converter {
    // Placeholder for future conversion options
}

impl Converter {
    pub fn new() -> Self {
        Self {}
    }

    /// Convert an ebook from one format to another
    pub fn convert(
        input_path: &Path,
        output_path: &Path,
        target_format: &str,
    ) -> Result<()> {
        Self::convert_with_progress(input_path, output_path, target_format, None)
    }

    /// Convert an ebook with optional progress reporting
    pub fn convert_with_progress(
        input_path: &Path,
        output_path: &Path,
        target_format: &str,
        progress_name: Option<String>,
    ) -> Result<()> {
        let input_format = crate::utils::detect_format(input_path)?;
        let progress = progress_name.map(|name| Progress::new(name, 3));

        if let Some(ref p) = progress {
            p.increment(0);
            p.print_with_message("Reading input file");
        }

        let result = match (input_format.as_str(), target_format) {
            ("txt", "epub") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting to EPUB"); }
                let r = Self::txt_to_epub(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing EPUB"); }
                r
            }
            ("txt", "pdf") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting to PDF"); }
                let r = Self::txt_to_pdf(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing PDF"); }
                r
            }
            ("txt", "mobi") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting to MOBI"); }
                let r = Self::txt_to_mobi(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing MOBI"); }
                r
            }
            ("epub", "txt") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting to TXT"); }
                let r = Self::epub_to_txt(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing TXT"); }
                r
            }
            ("epub", "pdf") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting EPUB to PDF"); }
                let r = Self::epub_to_pdf(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing PDF"); }
                r
            }
            ("mobi", "txt") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting MOBI to TXT"); }
                let r = Self::mobi_to_txt(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing TXT"); }
                r
            }
            ("fb2", "txt") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting FB2 to TXT"); }
                let r = Self::fb2_to_txt(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing TXT"); }
                r
            }
            ("pdf", "txt") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting PDF to TXT"); }
                let r = Self::pdf_to_txt(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing TXT"); }
                r
            }
            ("txt", "fb2") => {
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Converting to FB2"); }
                let r = Self::txt_to_fb2(input_path, output_path);
                if let Some(ref p) = progress { p.increment(1); p.print_with_message("Writing FB2"); }
                r
            }
            _ => Err(EbookError::NotSupported(format!(
                "Conversion from {input_format} to {target_format} is not supported"
            ))),
        };

        if let Some(ref p) = progress {
            p.finish();
        }

        result
    }

    fn txt_to_epub(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut txt_handler = TxtHandler::new();
        txt_handler.read_from_file(input_path)?;

        let content = txt_handler.get_content()?;
        let metadata = txt_handler.get_metadata()?;

        let mut epub_handler = EpubHandler::new();
        epub_handler.set_metadata(metadata)?;
        epub_handler.set_content(&content)?;

        // Split content into chapters
        let chapters: Vec<&str> = content.split("\n\n---\n\n")
            .map(|s| s.trim())
            .filter(|s| !s.is_empty())
            .collect();

        if chapters.is_empty() {
            // If no chapter markers, treat entire content as one chapter
            epub_handler.add_chapter("Chapter 1", &content)?;
        } else {
            for (idx, chapter) in chapters.iter().enumerate() {
                epub_handler.add_chapter(&format!("Chapter {}", idx + 1), chapter)?;
            }
        }

        epub_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn txt_to_pdf(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut txt_handler = TxtHandler::new();
        txt_handler.read_from_file(input_path)?;

        let content = txt_handler.get_content()?;
        let metadata = txt_handler.get_metadata()?;

        let mut pdf_handler = PdfHandler::new();
        pdf_handler.set_metadata(metadata)?;
        pdf_handler.set_content(&content)?;
        pdf_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn txt_to_mobi(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut txt_handler = TxtHandler::new();
        txt_handler.read_from_file(input_path)?;

        let content = txt_handler.get_content()?;
        let metadata = txt_handler.get_metadata()?;

        let mut mobi_handler = MobiHandler::new();
        mobi_handler.set_metadata(metadata)?;
        mobi_handler.set_content(&content)?;
        mobi_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn epub_to_txt(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut epub_handler = EpubHandler::new();
        epub_handler.read_from_file(input_path)?;

        let content = epub_handler.get_content()?;
        let metadata = epub_handler.get_metadata()?;

        let mut txt_handler = TxtHandler::new();
        txt_handler.set_metadata(metadata)?;
        txt_handler.set_content(&content)?;
        txt_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn epub_to_pdf(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut epub_handler = EpubHandler::new();
        epub_handler.read_from_file(input_path)?;

        let content = epub_handler.get_content()?;
        let metadata = epub_handler.get_metadata()?;

        let mut pdf_handler = PdfHandler::new();
        pdf_handler.set_metadata(metadata)?;
        pdf_handler.set_content(&content)?;
        pdf_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn mobi_to_txt(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut mobi_handler = MobiHandler::new();
        mobi_handler.read_from_file(input_path)?;

        let content = mobi_handler.get_content()?;
        let metadata = mobi_handler.get_metadata()?;

        let mut txt_handler = TxtHandler::new();
        txt_handler.set_metadata(metadata)?;
        txt_handler.set_content(&content)?;
        txt_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn fb2_to_txt(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut fb2_handler = Fb2Handler::new();
        fb2_handler.read_from_file(input_path)?;

        let content = fb2_handler.get_content()?;
        let metadata = fb2_handler.get_metadata()?;

        let mut txt_handler = TxtHandler::new();
        txt_handler.set_metadata(metadata)?;
        txt_handler.set_content(&content)?;
        txt_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn pdf_to_txt(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut pdf_handler = PdfHandler::new();
        pdf_handler.read_from_file(input_path)?;

        let content = pdf_handler.get_content()?;
        let metadata = pdf_handler.get_metadata()?;

        let mut txt_handler = TxtHandler::new();
        txt_handler.set_metadata(metadata)?;
        txt_handler.set_content(&content)?;
        txt_handler.write_to_file(output_path)?;
        Ok(())
    }

    fn txt_to_fb2(input_path: &Path, output_path: &Path) -> Result<()> {
        // Ensure parent directory exists
        if let Some(parent) = output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let mut txt_handler = TxtHandler::new();
        txt_handler.read_from_file(input_path)?;

        let content = txt_handler.get_content()?;
        let metadata = txt_handler.get_metadata()?;

        let mut fb2_handler = Fb2Handler::new();
        fb2_handler.set_metadata(metadata)?;
        fb2_handler.set_content(&content)?;
        fb2_handler.write_to_file(output_path)?;
        Ok(())
    }
}

impl Default for Converter {
    fn default() -> Self {
        Self::new()
    }
}