Struct Rule 

pub struct Rule(/* private fields */);

An AST node for $ast

Implementations

impl Rule

pub fn parse(text: &str) -> Parse<Rule>

Parse rule text, returning a Parse result

pub fn targets(&self) -> impl Iterator<Item = String> + '_

Targets of this rule

Example

use makefile_lossless::Rule;

let rule: Rule = "rule: dependency\n\tcommand".parse().unwrap();
assert_eq!(rule.targets().collect::<Vec<_>>(), vec!["rule"]);

pub fn prerequisites(&self) -> impl Iterator<Item = String> + '_

Get the prerequisites in the rule

Example

use makefile_lossless::Rule;
let rule: Rule = "rule: dependency\n\tcommand".parse().unwrap();
assert_eq!(rule.prerequisites().collect::<Vec<_>>(), vec!["dependency"]);

pub fn recipes(&self) -> impl Iterator<Item = String>

Get the commands in the rule

Example

use makefile_lossless::Rule;
let rule: Rule = "rule: dependency\n\tcommand".parse().unwrap();
assert_eq!(rule.recipes().collect::<Vec<_>>(), vec!["command"]);

pub fn replace_command(&mut self, i: usize, line: &str) -> bool

Replace the command at index i with a new line

Example

use makefile_lossless::Rule;
let mut rule: Rule = "rule: dependency\n\tcommand".parse().unwrap();
rule.replace_command(0, "new command");
assert_eq!(rule.recipes().collect::<Vec<_>>(), vec!["new command"]);

pub fn push_command(&mut self, line: &str)

Add a new command to the rule

Example

use makefile_lossless::Rule;
let mut rule: Rule = "rule: dependency\n\tcommand".parse().unwrap();
rule.push_command("command2");
assert_eq!(rule.recipes().collect::<Vec<_>>(), vec!["command", "command2"]);

pub fn remove_command(&mut self, index: usize) -> bool

Remove command at given index

Example

use makefile_lossless::Rule;
let mut rule: Rule = "rule:\n\tcommand1\n\tcommand2\n".parse().unwrap();
rule.remove_command(0);
assert_eq!(rule.recipes().collect::<Vec<_>>(), vec!["command2"]);

pub fn insert_command(&mut self, index: usize, line: &str) -> bool

Insert command at given index

Example

use makefile_lossless::Rule;
let mut rule: Rule = "rule:\n\tcommand1\n\tcommand2\n".parse().unwrap();
rule.insert_command(1, "inserted_command");
let recipes: Vec<_> = rule.recipes().collect();
assert_eq!(recipes, vec!["command1", "inserted_command", "command2"]);

pub fn recipe_count(&self) -> usize

Get the number of commands/recipes in this rule

Example

use makefile_lossless::Rule;
let rule: Rule = "rule:\n\tcommand1\n\tcommand2\n".parse().unwrap();
assert_eq!(rule.recipe_count(), 2);

pub fn clear_commands(&mut self)

Clear all commands from this rule

Example

use makefile_lossless::Rule;
let mut rule: Rule = "rule:\n\tcommand1\n\tcommand2\n".parse().unwrap();
rule.clear_commands();
assert_eq!(rule.recipe_count(), 0);

pub fn remove_prerequisite(&mut self, target: &str) -> Result<bool, Error>

Remove a prerequisite from this rule

Returns true if the prerequisite was found and removed, false if it wasn’t found.

Example

use makefile_lossless::Rule;
let mut rule: Rule = "target: dep1 dep2 dep3\n".parse().unwrap();
assert!(rule.remove_prerequisite("dep2").unwrap());
assert_eq!(rule.prerequisites().collect::<Vec<_>>(), vec!["dep1", "dep3"]);
assert!(!rule.remove_prerequisite("nonexistent").unwrap());

pub fn add_prerequisite(&mut self, target: &str) -> Result<(), Error>

Add a prerequisite to this rule

Example

use makefile_lossless::Rule;
let mut rule: Rule = "target: dep1\n".parse().unwrap();
rule.add_prerequisite("dep2").unwrap();
assert_eq!(rule.prerequisites().collect::<Vec<_>>(), vec!["dep1", "dep2"]);

pub fn set_prerequisites(&mut self, prereqs: Vec<&str>) -> Result<(), Error>

Set the prerequisites for this rule, replacing any existing ones

Example

use makefile_lossless::Rule;
let mut rule: Rule = "target: old_dep\n".parse().unwrap();
rule.set_prerequisites(vec!["new_dep1", "new_dep2"]).unwrap();
assert_eq!(rule.prerequisites().collect::<Vec<_>>(), vec!["new_dep1", "new_dep2"]);

pub fn remove(self) -> Result<(), Error>

Remove this rule from its parent Makefile

Example

use makefile_lossless::Makefile;
let mut makefile: Makefile = "rule1:\n\tcommand1\nrule2:\n\tcommand2\n".parse().unwrap();
let rule = makefile.rules().next().unwrap();
rule.remove().unwrap();
assert_eq!(makefile.rules().count(), 1);

This will also remove any preceding comments and up to 1 empty line before the rule.

Trait Implementations

impl AstNode for Rule

type Language = Lang

fn can_cast(kind: SyntaxKind) -> bool

fn cast(syntax: SyntaxNode<Lang>) -> Option<Self>

fn syntax(&self) -> &SyntaxNode<Lang>

fn clone_for_update(&self) -> Self

where Self: Sized,

fn clone_subtree(&self) -> Self

where Self: Sized,

impl Display for Rule

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

Formats the value using the given formatter.

impl FromStr for Rule

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Rule

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Rule

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

impl StructuralPartialEq for Rule