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 rename_target( &mut self, old_name: &str, new_name: &str, ) -> Result<bool, Error>

Rename a target in this rule

Returns Ok(true) if the target was found and renamed, Ok(false) if the target was not found.

Example

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

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

Add a target to this rule

Example

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

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

Set the targets for this rule, replacing any existing ones

Returns an error if the targets list is empty (rules must have at least one target).

Example

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

pub fn has_target(&self, target: &str) -> bool

Check if this rule has a specific target

Example

use makefile_lossless::Rule;
let rule: Rule = "target1 target2: dependency\n\tcommand".parse().unwrap();
assert!(rule.has_target("target1"));
assert!(rule.has_target("target2"));
assert!(!rule.has_target("target3"));

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

Remove a target from this rule

Returns Ok(true) if the target was found and removed, Ok(false) if the target was not found. Returns an error if attempting to remove the last target (rules must have at least one target).

Example

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

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