Trait ryan::environment::loader::ImportLoader

pub trait ImportLoader: Debug {
    // Required methods
    fn resolve(
        &self,
        current: Option<&str>,
        path: &str
    ) -> Result<String, Box<dyn Error + 'static>>;
    fn load(
        &self,
        path: &str
    ) -> Result<Box<dyn Read>, Box<dyn Error + 'static>>;

    // Provided methods
    fn override(self, path: String, value: String) -> Override<Self>
       where Self: Sized { ... }
    fn block(self, path: String) -> Override<Self>
       where Self: Sized { ... }
    fn override_many(
        self,
        overrides: HashMap<String, Option<String>>
    ) -> Override<Self>
       where Self: Sized { ... }
    fn filter<F>(self, filter: F) -> Filter<Self, F>
       where Self: Sized,
             F: Fn(&str) -> bool { ... }
    fn with_resolver<F, E>(self, resolver: F) -> WithResolver<Self, F>
       where Self: Sized,
             F: Fn(Option<&str>, &str) -> Result<String, E> { ... }
    fn with_loader<F, R, E>(self, loader: F) -> WithLoader<Self, F>
       where Self: Sized,
             F: Fn(&str) -> Result<R, E>,
             R: 'static + Read,
             E: 'static + Error { ... }
}

The loader trait for Ryan.

Required Methods

fn resolve( &self, current: Option<&str>, path: &str ) -> Result<String, Box<dyn Error + 'static>>

Returns the absolute import path for a module, given a base and an optional path. The base might be set to None in some cases (e.g., when loading Ryan from a string, not a file). Each loader implementation can choose how to treat this value however it’s expedient.

fn load(&self, path: &str) -> Result<Box<dyn Read>, Box<dyn Error + 'static>>

Resolves an absolute path into a reader, where a Ryan module can be read from.

Provided Methods

fn override(self, path: String, value: String) -> Override<Self>where Self: Sized,

Overrides a single path to be represented by a different model than would be represented by this loader.

fn block(self, path: String) -> Override<Self>where Self: Sized,

Blocks a path from being resolved as a module.

fn override_many( self, overrides: HashMap<String, Option<String>> ) -> Override<Self>where Self: Sized,

Overrides the value imported by multiple paths. Pass None as the value associated to a key in the hashmap to deny access to a given path.

fn filter<F>(self, filter: F) -> Filter<Self, F>where Self: Sized, F: Fn(&str) -> bool,

Determines whether a path should be blocked or loaded based on a supplied closure.

fn with_resolver<F, E>(self, resolver: F) -> WithResolver<Self, F>where Self: Sized, F: Fn(Option<&str>, &str) -> Result<String, E>,

Change the resolve method of the underlying loader.

fn with_loader<F, R, E>(self, loader: F) -> WithLoader<Self, F>where Self: Sized, F: Fn(&str) -> Result<R, E>, R: 'static + Read, E: 'static + Error,

Change the load method of the underlying loader.

Implementors

impl ImportLoader for DefaultImporter

impl ImportLoader for NoImport

impl<L: ImportLoader> ImportLoader for Override<L>

impl<L: ImportLoader, F> ImportLoader for Filter<L, F>where F: Fn(&str) -> bool,

impl<L: ImportLoader, F, E> ImportLoader for WithResolver<L, F>where F: Fn(Option<&str>, &str) -> Result<String, E>, E: 'static + Error,

impl<L: ImportLoader, F, R, E> ImportLoader for WithLoader<L, F>where F: Fn(&str) -> Result<R, E>, R: 'static + Read, E: 'static + Error,