Struct reagent::Reagent

pub struct Reagent {
    pub package: Option<String>,
    pub description: Option<String>,
    pub url: Option<String>,
    pub version: Option<String>,
    pub license: Option<String>,
    pub name: Option<String>,
    pub email: Option<String>,
    pub debian: bool,
    pub redox: bool,
}

Configuration for reagent, stored in reagent.toml

Fields

package: Option<String>

The name of the package: "reagent"

description: Option<String>

The description of the package: "Redox OS Standard Tests"

url: Option<String>

The repository or homepage of the package: "https://gitlab.redox-os.org/redox-os/reagent"

version: Option<String>

The current version of the package: "0.1.0"

license: Option<String>

The license used by the package: "MIT"

name: Option<String>

The name of the package maintainer: "Jeremy Soller"

email: Option<String>

The email of the package maintainer: "jackpot51@gmail.com"

debian: bool

Debian packaging

redox: bool

CI for Redox OS

Methods

impl Reagent

pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>

Create a reagent instance from a toml file

pub fn split(string: &str) -> (&str, &str, &str)

Split a string based on reagent tags, returning the following:

• Lines up to the tag
• Lines in between and including the tags
• Lines after the tag If there are no reagent tags, the entire file is assumed to be in between tags

pub fn generate(
    &self,
    input: &str,
    original_opt: Option<&str>
) -> Result<String, Error>

Generate updated file based on input template If the file is empty, use the entire input file to generate it If the file is not empty, only generate the sections inside of reagent tags This starts from the line after a tag, and ends on the line before a tag

Trait Implementations

impl Debug for Reagent

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

Formats the value using the given formatter.

impl Content for Reagent

fn capacity_hint(&self, tpl: &Template) -> usize

How much capacity is likely required for all the data in this Content for a given Template.

fn render_field_escaped<E>(
    &self,
    hash: u64,
    _: &str,
    encoder: &mut E
) -> Result<(), E::Error> where
    E: Encoder, 

Render a field by the hash or string of its name.

fn render_field_unescaped<E>(
    &self,
    hash: u64,
    _: &str,
    encoder: &mut E
) -> Result<(), E::Error> where
    E: Encoder, 

Render a field by the hash or string of its name.

fn render_field_section<'section, E>(
    &self,
    hash: u64,
    _: &str,
    section: Section<'section>,
    encoder: &mut E
) -> Result<(), E::Error> where
    E: Encoder, 

Render a field by the hash or string of its name, as a section.

fn render_field_inverse<'section, E>(
    &self,
    hash: u64,
    _: &str,
    section: Section<'section>,
    encoder: &mut E
) -> Result<(), E::Error> where
    E: Encoder, 

Render a field, by the hash of or string its name, as an inverse section.

fn is_truthy(&self) -> bool

Marks whether this content is truthy. Used when attempting to render a section.

fn render_escaped<E>(
    &self,
    _encoder: &mut E
) -> Result<(), <E as Encoder>::Error> where
    E: Encoder, 

Renders self as a variable to the encoder.

fn render_unescaped<E>(
    &self,
    encoder: &mut E
) -> Result<(), <E as Encoder>::Error> where
    E: Encoder, 

Renders self as a variable to the encoder.

fn render_cmark<E>(&self, encoder: &mut E) -> Result<(), <E as Encoder>::Error> where
    E: Encoder, 

Renders self as a variable to the encoder with CommonMark processing.

fn render_section<E>(
    &self,
    section: Section<'section>,
    encoder: &mut E
) -> Result<(), <E as Encoder>::Error> where
    E: Encoder, 

Render a section with self.

fn render_inverse<E>(
    &self,
    section: Section<'section>,
    encoder: &mut E
) -> Result<(), <E as Encoder>::Error> where
    E: Encoder, 

Render a section with self.

impl Serialize for Reagent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Reagent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.