Struct Context

pub struct Context<S: ContextState + ?Sized> { /* private fields */ }

Tiny wrapper around “Tera context” with some additional information.

Implementations

impl<S: ContextState> Context<S>

The methods below are available in all ContentState states.

pub fn get_path(&self) -> &Path

Getter for self.path.

pub fn get_dir_path(&self) -> &Path

Getter for self.dir_path.

pub fn get_root_path(&self) -> &Path

Getter for self.root_path.

pub fn get_doc_file_date(&self) -> Option<SystemTime>

Getter for self.doc_file_date.

pub fn mark_as_invalid(self) -> Context<Invalid>

Transition to the fault state.

pub fn from_context_path(context: &Context<S>) -> Context<HasSettings>

Constructor. Unlike from() this constructor does not access the file system in order to detect dir_path, root_path and doc_file_date. It copies these values from the passed context. Use this constructor when you are sure that the above date has not changed since you instantiated context. In this case you can avoid repeated file access.

pub fn insert_raw_text_from_existing_content(&mut self, content: &impl Content)

Inserts a Content in Context. The content appears as key in context.ct with its name taken from content.name(). Its value is a tera::Map with two keys TMPL_VAR_HEADER and TMPL_VAR_BODY. The corresponding values are copied from conten.header() and content.body().

pub fn insert_front_matter_and_raw_text_from_existing_content2( &mut self, clipboards: &Vec<&impl Content>, ) -> Result<(), NoteError>

See function of the same name in impl Context<HasSettings>.

impl Context<Invalid>

The start state of all Context objects.

pub fn from(path: &Path) -> Result<Context<HasSettings>, FileError>

Constructor: path is the first positional command line parameter <path> (see man page). path must point to a directory or a file.

A copy of path is stored in self.ct as key TMPL_VAR_PATH. It directory path as key TMPL_VAR_DIR_PATH. The root directory, where the marker file tpnote.toml was found, is stored with the key TMPL_VAR_ROOT_PATH. If path points to a file, its file creation date is stored with the key TMPL_VAR_DOC_FILE_DATE.

use std::path::Path;
use tpnote_lib::settings::set_test_default_settings;
use tpnote_lib::config::TMPL_VAR_DIR_PATH;
use tpnote_lib::config::TMPL_VAR_PATH;
use tpnote_lib::context::Context;
set_test_default_settings().unwrap();

let mut context = Context::from(&Path::new("/path/to/mynote.md")).unwrap();

assert_eq!(context.get_path(), Path::new("/path/to/mynote.md"));
assert_eq!(context.get_dir_path(), Path::new("/path/to/"));
assert_eq!(&context.get(TMPL_VAR_PATH).unwrap().to_string(),
            r#""/path/to/mynote.md""#);
assert_eq!(&context.get(TMPL_VAR_DIR_PATH).unwrap().to_string(),
            r#""/path/to""#);

impl Context<HasSettings>

pub fn insert_front_matter( self, fm: &FrontMatter, ) -> Context<ReadyForFilenameTemplate>

Merges fm into self.ct.

pub fn insert_front_matter_and_raw_text_from_existing_content( self, clipboards: &Vec<&impl Content>, ) -> Result<Context<HasExistingContent>, NoteError>

Inserts clipboard data, stdin data and/or existing note file content into the context. The data may contain some copied text with or without a YAML header. The latter usually carries front matter variables. The input data below is registered with the key name given by tmpl_var_body_name. Typical names are "clipboard" or "stdin". If the below input contains a valid YAML header, it will be registered in the context with the key name given by tmpl_var_header_name. The templates expect the key names clipboard_header or std_header. The raw header text will be inserted with this key name.

use std::path::Path;
use tpnote_lib::settings::set_test_default_settings;
use tpnote_lib::context::Context;
use tpnote_lib::content::Content;
use tpnote_lib::content::ContentString;
set_test_default_settings().unwrap();

let mut context = Context::from(&Path::new("/path/to/mynote.md")).unwrap();
let c1 =  ContentString::from_string(String::from("Data from clipboard."),
         "txt_clipboard".to_string(),
);
let c2 = ContentString::from_string(
         "---\ntitle: My Stdin.\n---\nbody".to_string(),
         "stdin".to_string(),
);
let c = vec![&c1, &c2];

let context = context
    .insert_front_matter_and_raw_text_from_existing_content(&c).unwrap();

assert_eq!(
    &context.get("txt_clipboard").unwrap().get("body").unwrap().to_string(),
    "\"Data from clipboard.\"");
assert_eq!(
    &context.get("stdin").unwrap().get("body").unwrap().to_string(),
    "\"body\"");
assert_eq!(
    &context.get("stdin").unwrap().get("header").unwrap().to_string(),
    "\"title: My Stdin.\"");
// "fm_title" is dynamically generated from the header variable "title".
assert_eq!(&context
           .get("fm").unwrap()
           .get("fm_title").unwrap().to_string(),
     "\"My Stdin.\"");

pub fn insert_error_content( self, note_erroneous_content: &impl Content, error_message: &str, viewer_doc_js: &str, ) -> Context<ReadyForHtmlErrorTemplate>

This adds the following variables to self:

• TMPL_HTML_VAR_VIEWER_DOC_JS from viewer_doc_js
• TMPL_HTML_VAR_DOC_ERROR from error_message
• TMPL_HTML_VAR_DOC_TEXT from note_erroneous_content

impl Context<HasExistingContent>

pub fn insert_front_matter_and_raw_text_from_existing_content( self, clipboards: &Vec<&impl Content>, ) -> Result<Context<HasExistingContent>, NoteError>

See same method in Context<HasSettings>.

pub fn set_state_ready_for_content_template( self, ) -> Context<ReadyForContentTemplate>

Mark this as ready for a content template.

impl Context<ReadyForFilenameTemplate>

pub fn assert_precoditions(&self) -> Result<(), NoteError>

Checks if the front matter variables satisfy preconditions. self.path is the path to the current document.

pub fn insert_raw_content_and_css( self, content: &impl Content, viewer_doc_js: &str, ) -> Context<ReadyForHtmlTemplate>

Inserts the following variables into self:

• TMPL_HTML_VAR_VIEWER_DOC_JS from viewer_doc_js
• TMPL_VAR_DOC from content.header() and content.body()
• TMPL_HTML_VAR_EXPORTER_DOC_CSS
• TMPL_HTML_VAR_EXPORTER_HIGHLIGHTING_CSS
• TMPL_HTML_VAR_EXPORTER_HIGHLIGHTING_CSS
• TMPL_HTML_VAR_VIEWER_DOC_CSS_PATH
• TMPL_HTML_VAR_VIEWER_DOC_CSS_PATH_VALUE
• TMPL_HTML_VAR_VIEWER_HIGHLIGHTING_CSS_PATH
• TMPL_HTML_VAR_VIEWER_HIGHLIGHTING_CSS_PATH_VALUE

Methods from Deref<Target = Context>

pub fn get(&self, index: &str) -> Option<&Value>

Returns the value at a given key index.

pub fn contains_key(&self, index: &str) -> bool

Checks if a value exists at a specific index.

Trait Implementations

impl<S: Clone + ContextState + ?Sized> Clone for Context<S>

fn clone(&self) -> Context<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug + ContextState + ?Sized> Debug for Context<S>

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

Formats the value using the given formatter.

impl<S: ContextState> Deref for Context<S>

Auto dereferences for convenient access to tera::Context.

type Target = Context

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: PartialEq + ContextState + ?Sized> PartialEq for Context<S>

fn eq(&self, other: &Context<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: ContextState + ?Sized> StructuralPartialEq for Context<S>