Struct EpubFileLoader 

pub struct EpubFileLoader<'a, T, P = RawTextProcessor> { /* private fields */ }

Available on crate feature epub only.

EpubFileLoader is a utility for loading epub files from the filesystem using glob patterns or directory paths. It provides methods to read file contents and handle errors gracefully.

Errors

This module defines a custom error type EpubLoaderError which can represent various errors that might occur during file loading operations, such as any FileLoaderError alongside specific EPUB-related errors.

Example Usage

use rig::loaders::{EpubFileLoader, RawTextProcessor, StripXmlProcessor};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a FileLoader using a glob pattern
    let loader = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?;

    // Load epub file contents by chapter, ignoring any errors
    let contents = loader
        .load_with_path()
        .ignore_errors()
        .by_chapter()
        .ignore_errors();

    for (path, chapters) in contents {
        println!("{}", path.display());
        for (idx, chapter) in chapters {
            println!("Chapter {} begins", idx);
            println!("{}", chapter);
            println!("Chapter {} ends", idx);
        }
    }

    // Create a FileLoader using a glob pattern with stripping xml
    let loader = EpubFileLoader::<_, StripXmlProcessor>::with_glob("tests/data/*.epub")?;

    // Load epub file contents by chapter, ignoring any errors
    let contents = loader
        .load_with_path()
        .ignore_errors()
        .by_chapter()
        .ignore_errors();

    for (path, chapters) in contents {
        println!("{}", path.display());
        for (idx, chapter) in chapters {
            println!("Chapter {} begins", idx);
            println!("{}", chapter);
            println!("Chapter {} ends", idx);
        }
    }

    Ok(())
}

EpubFileLoader uses strict typing between the iterator methods to ensure that transitions between different implementations of the loaders and it’s methods are handled properly by the compiler.

Implementations

impl<'a, P> EpubFileLoader<'a, Result<PathBuf, EpubLoaderError>, P>

pub fn load( self, ) -> EpubFileLoader<'a, Result<EpubDoc<BufReader<File>>, EpubLoaderError>, P>

Loads the contents of the epub files within the iterator returned by EpubFileLoader::with_glob or EpubFileLoader::with_dir. Loaded EPUB documents are raw EPUB instances that can be further processed (by chapter, etc).

Example

Load epub files in directory “tests/data/*.epub” and return the loaded documents

use rig::loaders::EpubFileLoader;

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?.load().into_iter();
for result in content {
    match result {
        Ok(doc) => println!("{:?}", doc),
        Err(e) => eprintln!("Error reading epub: {}", e),
    }
}

pub fn load_with_path( self, ) -> EpubFileLoader<'a, Result<(PathBuf, EpubDoc<BufReader<File>>), EpubLoaderError>, P>

Loads the contents of the epub files within the iterator returned by EpubFileLoader::with_glob or EpubFileLoader::with_dir. Loaded EPUB documents are raw EPUB instances with their path that can be further processed.

Example

Load epub files in directory “tests/data/*.epub” and return the loaded documents

use rig::loaders::EpubFileLoader;

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub").unwrap().load_with_path().into_iter();
for result in content {
    match result {
        Ok((path, doc)) => println!("{:?} {:?}", path, doc),
        Err(e) => eprintln!("Error reading epub: {}", e),
    }
}

impl<'a, P> EpubFileLoader<'a, Result<PathBuf, EpubLoaderError>, P>

where P: TextProcessor,

pub fn read(self) -> EpubFileLoader<'a, Result<String, EpubLoaderError>, P>

Directly reads the contents of the epub files within the iterator returned by EpubFileLoader::with_glob or EpubFileLoader::with_dir.

Example

Read epub files in directory “tests/data/*.epub” and return the contents of the documents.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?.read().into_iter();
for result in content {
    match result {
        Ok(content) => println!("{}", content),
        Err(e) => eprintln!("Error reading epub: {}", e),
    }
}

pub fn read_with_path( self, ) -> EpubFileLoader<'a, Result<(PathBuf, String), EpubLoaderError>, P>

Directly reads the contents of the epub files within the iterator returned by EpubFileLoader::with_glob or EpubFileLoader::with_dir and returns the path along with the content.

Example

Read epub files in directory “tests/data/*.epub” and return the content and paths of the documents.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?.read_with_path().into_iter();
for result in content {
    match result {
        Ok((path, content)) => println!("{:?} {}", path, content),
        Err(e) => eprintln!("Error reading epub: {}", e),
    }
}

impl<'a, P> EpubFileLoader<'a, EpubDoc<BufReader<File>>, P>

where P: TextProcessor + 'a,

pub fn by_chapter( self, ) -> EpubFileLoader<'a, Result<String, EpubLoaderError>, P>

Chunks the chapters of a loaded document by chapter, flattened as a single vector.

Example

Load epub files in directory “tests/data/*.epub” and chunk all document into it’s chapters.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?.load().by_chapter().into_iter();
for result in content {
    println!("{}", result);
}

impl<'a, P: TextProcessor> EpubFileLoader<'a, (PathBuf, EpubDoc<BufReader<File>>), P>

pub fn by_chapter( self, ) -> EpubFileLoader<'a, (PathBuf, Vec<(usize, Result<String, EpubLoaderError>)>), P>

Chunks the chapters of a loaded document by chapter, processed as a vector of documents by path which each document container an inner vector of chapters by chapter number.

Example

Read epub files in directory “tests/data/*.epub” and chunk all documents by path by it’s chapters.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?
    .load_with_path()
    .ignore_errors()
    .by_chapter()
    .ignore_errors()
    .into_iter();

for result in content {
    println!("{:?}", result);
}

impl<'a, P> EpubFileLoader<'a, (PathBuf, Vec<(usize, Result<String, EpubLoaderError>)>), P>

where P: TextProcessor,

pub fn ignore_errors( self, ) -> EpubFileLoader<'a, (PathBuf, Vec<(usize, String)>), P>

Ignores errors in the iterator, returning only successful results. This can be used on any EpubFileLoader state of iterator whose items are results.

Example

Read files in directory “tests/data/*.epub” and ignore errors from unreadable files.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?.read().ignore_errors().into_iter();
for result in content {
    println!("{}", content)
}

impl<'a, P, T: 'a> EpubFileLoader<'a, Result<T, EpubLoaderError>, P>

pub fn ignore_errors(self) -> EpubFileLoader<'a, T, P>

Ignores errors in the iterator, returning only successful results. This can be used on any EpubFileLoader state of iterator whose items are results.

Example

Read files in directory “tests/data/*.epub” and ignore errors from unreadable files.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?.read().ignore_errors().into_iter();
for result in content {
    println!("{}", content)
}

impl<P> EpubFileLoader<'_, Result<PathBuf, FileLoaderError>, P>

pub fn with_glob( pattern: &str, ) -> Result<EpubFileLoader<'_, Result<PathBuf, EpubLoaderError>, P>, EpubLoaderError>

Creates a new EpubFileLoader using a glob pattern to match files.

Example

Create a EpubFileLoader for all .epub files that match the glob “tests/data/*.epub”.

let loader = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?;

pub fn with_dir( directory: &str, ) -> Result<EpubFileLoader<'_, Result<PathBuf, EpubLoaderError>, P>, EpubLoaderError>

Creates a new EpubFileLoader on all files within a directory.

Example

Create a EpubFileLoader for all files that are in the directory “files”.

let loader = EpubFileLoader::<_, RawTextProcessor>::with_dir("files")?;

Trait Implementations

impl<'a, T, P> IntoIterator for EpubFileLoader<'a, T, P>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.