Struct EpubFileLoader 

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

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_core::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>

Available on crate feature epub only.

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_core::loaders::{EpubFileLoader, RawTextProcessor};

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>

Available on crate feature epub only.

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_core::loaders::{EpubFileLoader, RawTextProcessor};

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?.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>

Available on crate feature epub only.

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>

Available on crate feature epub only.

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>

Available on crate feature epub only.

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()
    .ignore_errors()
    .by_chapter()
    .into_iter();
for result in content {
    match result {
        Ok(chapter) => println!("{}", chapter),
        Err(e) => eprintln!("Error reading chapter: {}", e),
    }
}

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

where P: TextProcessor,

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

Available on crate feature epub only.

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>

Available on crate feature epub only.

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")?
    .load_with_path()
    .ignore_errors()
    .by_chapter()
    .ignore_errors();
for (_path, chapters) in content {
    println!("{}", chapters.len())
}

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

where T: 'a,

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

Available on crate feature epub only.

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

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

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

Available on crate feature epub only.

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

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

Available on crate feature epub only.

Creates a new loader on all entries within a directory. Entries are not filtered: a non-file entry’s path is yielded too and surfaces as an error when loaded.

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) -> <EpubFileLoader<'a, T, P> as IntoIterator>::IntoIter

Creates an iterator from a value.