Enum Locate 

pub enum Locate {
    File(PathBuf),
    StdInOut,
}

An wrapper for representing file or stdin / stdout

Variants

File(PathBuf)

StdInOut

Implementations

impl Locate

pub fn new(locate: Option<PathBuf>) -> Self

Creates a new Locate.

• Some(x) -> Locate::File
• None -> Locate::StdInOut (stdin / stdout)

pub fn to_path_buf(&self) -> PathBuf

Converts a Locate to an owned PathBuf.

pub fn output_path(&self, input: &Locate, id: &str, format: &Format) -> Self

Creates image’s output path.

• input - An input Locate.
• id - Identifiers in the PlantUML diagram.
• format - A format of output.

Examples

let locate = Locate::from("./output/dir");
let output_path = locate.output_path(&"./foo.puml".into(), "id_a", &Format::Svg);

let expected = Locate::from(PathBuf::from("./output/dir/foo/id_a.svg"));
assert_eq!(output_path, expected);

let locate = Locate::from(None); // `--output` is not specified
let output_path = locate.output_path(&"./foo.puml".into(), "id_a", &Format::Svg);

let expected = Locate::from(PathBuf::from("foo/id_a.svg"));
assert_eq!(output_path, expected);

let locate = Locate::from("./output/dir");
let input = Locate::from(None); // `--input` is not specified (read from stdin)
let output_path = locate.output_path(&input, "id_a", &Format::Svg);

let expected = Locate::from(PathBuf::from("./output/dir/id_a.svg"));
assert_eq!(output_path, expected);

let locate = Locate::from(None);
let input = Locate::from(None);
let output_path = locate.output_path(&input, "N/A", &Format::Svg);

let expected = Locate::from(None);
assert_eq!(output_path, expected);

pub fn combined_output_path(&self, input: &Locate, id: &str) -> Option<Self>

Creates “combined” PlantUML content’s path. The “combined PlantUML content” is output when the --combined option is specified.

Examples

let locate = Locate::from("./output/dir");
let output_path = locate.combined_output_path(&"./foo.puml".into(), "id_a");

let expected_path = "./output/dir/foo/id_a.puml"; // different extension from `output_path()`.
let expected = Some(Locate::from(PathBuf::from(expected_path)));
assert_eq!(output_path, expected);

pub fn read(&self) -> Result<String>

Read from the Locate.

Examples

let locate = Locate::from("./target/tests_docs/locate_read");
let data = "foo";

std::fs::write(locate.to_path_buf(), data)?;
let read_data = locate.read()?;
assert_eq!(read_data, data);

pub async fn write( &self, stream: impl Stream<Item = Result<Bytes, Error>> + Unpin, ) -> Result<()>

Write a stream to Locate.

• stream - Data to write

Examples

let locate = Locate::from("./target/tests_docs/locate_write");
let data = "foo2";
let stream = futures::stream::iter(vec![Ok(data.into())]);

locate.write(stream).await?;
let read_data = std::fs::read_to_string(locate.to_path_buf())?;
assert_eq!(read_data, data);

Trait Implementations

impl Debug for Locate

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

Formats the value using the given formatter.

impl From<&str> for Locate

fn from(inner: &str) -> Self

Converts to this type from the input type.

impl From<Option<PathBuf>> for Locate

fn from(inner: Option<PathBuf>) -> Self

Converts to this type from the input type.

impl From<PathBuf> for Locate

fn from(inner: PathBuf) -> Self

Converts to this type from the input type.

impl PartialEq for Locate

fn eq(&self, rhs: &Locate) -> 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.