just 1.53.0

🤖 Just a command runner
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use super::*;

#[derive(Clone, PartialEq, Debug)]
pub(crate) struct Dependency<'src> {
  pub(crate) arguments: Vec<Vec<DependencyArgument<'src>>>,
  pub(crate) recipe: Arc<Recipe<'src>>,
}

impl Dependency<'_> {
  pub(crate) fn star(&self) -> Option<usize> {
    self
      .arguments
      .iter()
      .position(|group| group.iter().any(|argument| argument.starred))
  }
}

impl Serialize for Dependency<'_> {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: Serializer,
  {
    let arguments = self
      .arguments
      .iter()
      .flatten()
      .map(|argument| &argument.expression)
      .collect::<Vec<&Expression>>();

    let star = self
      .arguments
      .iter()
      .flatten()
      .position(|argument| argument.starred);

    let mut s = serializer.serialize_struct("Dependency", 3)?;
    s.serialize_field("arguments", &arguments)?;
    s.serialize_field("recipe", self.recipe.key())?;
    s.serialize_field("star", &star)?;
    s.end()
  }
}

impl Display for Dependency<'_> {
  fn fmt(&self, f: &mut Formatter) -> fmt::Result {
    if self.arguments.is_empty() {
      write!(f, "{}", self.recipe.name())
    } else {
      if self.star().is_some() {
        write!(f, "*")?;
      }

      write!(f, "({}", self.recipe.name())?;

      for argument in self.arguments.iter().flatten() {
        write!(f, " {argument}")?;
      }

      write!(f, ")")
    }
  }
}