Struct Example 

pub struct Example {
    pub info: String,
    pub lines: Vec<String>,
    pub runs: bool,
    pub compiles: bool,
}

One fenced block of a doc comment, classified by what cargo test --doc does with it.

The distinction matters and is the whole reason the block is modelled rather than counted: a ```text block is prose in a box, a ```ignore block is a example that is compiled by nobody, and only a Rust block without ignore is a test.

Fields

info: String

The info string of the fence, as written ("", "no_run", "ignore", "text").

lines: Vec<String>

The lines of the block, hidden #-prefixed lines included, as written.

runs: bool

Compiled and run by cargo test --doc.

compiles: bool

Compiled but not run: no_run, and compile_fail which must fail to compile.

Implementations

impl Example

pub fn executable(&self) -> bool

Is this block executable evidence — compiled by the toolchain, either run or deliberately not run?

use majordomus_cli::quality::source::Example;
let runs = Example::parse("", &["assert_eq!(1 + 1, 2);".into()]);
assert!(runs.executable());
let ignored = Example::parse("ignore", &["nothing();".into()]);
assert!(!ignored.executable(), "an ignored block is compiled by nobody");

pub fn parse(info: &str, lines: &[String]) -> Self

Classify a fenced block from its info string and its lines.

The rules are rustdoc’s: a block whose info string is empty, or names only Rust attributes, is Rust; ignore is neither compiled nor run; no_run and compile_fail are compiled; anything else (text, json, console) is prose.

use majordomus_cli::quality::source::Example;
assert!(Example::parse("", &["let x = 1;".into()]).runs);
assert!(!Example::parse("text", &["a diagram".into()]).executable());
assert!(Example::parse("no_run", &["serve();".into()]).compiles);
assert!(!Example::parse("no_run", &["serve();".into()]).runs);

pub fn visible_lines(&self) -> Vec<String>

The lines a reader sees: rustdoc hides a line whose first non-space character is # followed by a space or nothing.

use majordomus_cli::quality::source::Example;
let e = Example::parse("", &["# use std::fmt;".into(), "let x = 1;".into()]);
assert_eq!(e.visible_lines(), vec!["let x = 1;".to_string()]);

pub fn code(&self) -> String

The block’s code with the hidden marker stripped: what the toolchain compiles.

use majordomus_cli::quality::source::Example;
let e = Example::parse("", &["# let a = 1;".into(), "assert_eq!(a, 1);".into()]);
assert_eq!(e.code(), "let a = 1;\nassert_eq!(a, 1);");

Trait Implementations

impl Clone for Example

fn clone(&self) -> Example

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Example

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Example

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Example

impl JsonSchema for Example

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Example

fn eq(&self, other: &Example) -> 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 Serialize for Example

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Example