Struct TemplateContext 

pub struct TemplateContext {
    pub collection: Arc<Collection>,
    pub selected_profile: Option<ProfileId>,
    pub http_provider: Box<dyn HttpProvider>,
    pub overrides: IndexMap<String, ValueTemplate>,
    pub prompter: Box<dyn Prompter>,
    pub show_sensitive: bool,
    pub root_dir: PathBuf,
    pub state: RenderGroupState,
}

A little container struct for all the data that the user can access via templating. Unfortunately this has to own all data so templating can be deferred into a task (tokio requires 'static for spawned tasks). If this becomes a bottleneck, we can Arc some stuff.

One instance of this context applies to all renders in a group (a render group is all the renders for a single request). It’s important to use the same context for an entire request so common profile fields can be cached between components of the request.

This has two different implementations of Context: one for Value and one for ValueStream. The former is used in most cases, where values are eagerly evaluated. The latter is used when streams are supported.

Fields

collection: Arc<Collection>

Entire request collection

selected_profile: Option<ProfileId>

ID of the profile whose data should be used for rendering. Generally the caller should check the ID is valid before passing it, to provide a better error to the user if not.

http_provider: Box<dyn HttpProvider>

An interface to allow accessing and sending HTTP chained requests

overrides: IndexMap<String, ValueTemplate>

Additional profile key=value overrides passed directly from the user. These will be applied to both the root and triggered requests, which is why they are part of the context instead of BuildOptions.

prompter: Box<dyn Prompter>

A conduit to ask the user questions

show_sensitive: bool

Should sensitive values be shown normally or masked? Enabled for request renders, disabled for previews

root_dir: PathBuf

Directory in which to run file system operations. Should be the directory containing the collection file.

state: RenderGroupState

State that should be shared across all renders that use this context. This is meant to be opaque; just use Default::default to initialize.

Trait Implementations

impl Context<Value> for TemplateContext

async fn get_field(&self, field: &Identifier) -> Result<Value, RenderError>

Get the value of a field from the context. The implementor can decide where fields are derived from. Fields can also be computed dynamically and be async. For example, fields can be loaded from a map of nested templates, in which case the nested template would need to be rendered before this can be returned.

async fn call( &self, function_name: &Identifier, arguments: Arguments<'_, Self>, ) -> Result<Value, RenderError>

Call a function by name

impl Context<ValueStream> for TemplateContext

async fn get_field( &self, field: &Identifier, ) -> Result<ValueStream, RenderError>

Get the value of a field from the context. The implementor can decide where fields are derived from. Fields can also be computed dynamically and be async. For example, fields can be loaded from a map of nested templates, in which case the nested template would need to be rendered before this can be returned.

async fn call( &self, function_name: &Identifier, arguments: Arguments<'_, Self>, ) -> Result<ValueStream, RenderError>

Call a function by name

impl Debug for TemplateContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.