Struct Step

pub struct Step {
    pub name: Option<String>,
    pub uses: Option<String>,
    pub exec: Option<String>,
    pub with: Option<HashMap<String, String>>,
}

Step represent a single, instruction in the Workflow

Like a workflow, a step is mainly defined in two parts:

• The metadata: step name
• The instructions: the command to run, the parameters, etc…

There’s two kind of steps currently existing:

The executable step

A step is executable if it can be executed directly (i.e if a command is defined on the step)

use workflow::Step;
use std::collections::HashMap;
let step = Step {
    name: Some("Test step".to_string()),
    uses: None,
    exec: Some("echo {name}".to_string()),
    with: Some(HashMap::default()),
};

assert!(step.executable());

The referral step

A step is referral if it cannot be executed directly, but rather call another workflow to perform the job.

use workflow::Step;
use std::collections::HashMap;
let step = Step {
    name: Some("Test step".to_string()),
    uses: Some("std-download".to_string()), // The workflow to run
    exec: None,
    with: Some(HashMap::default()),
};

assert!(!step.executable());

The referral system allows to build complex workflow while not re-inventing existing but rathers use already defined workflow.

Fields

name: Option<String>

The optional step name.

uses: Option<String>

The id of the workflow to be executed.

exec: Option<String>

The command to execute. This will step as executable.

with: Option<HashMap<String, String>>

The optional step args.

Implementations

impl Step

pub fn executable(&self) -> bool

executable determines if the step is an executable one

Trait Implementations

impl Debug for Step

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

Formats the value using the given formatter.

impl Default for Step

fn default() -> Step

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Step

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Step

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

where __S: Serializer,

Serialize this value into the given Serde serializer.