Invertible attributes

src/attribute.rs

@@ -14,17 +14,17 @@ pub(crate) enum Attribute<'src> {
   ExitMessage,
   Extension(StringLiteral<'src>),
   Group(StringLiteral<'src>),
-  Linux,
-  Macos,
+  Linux { enabled: bool },
+  Macos { enabled: bool },
   NoCd,
   NoExitMessage,
   NoQuiet,
-  Openbsd,
+  Openbsd { enabled: bool },
   PositionalArguments,
   Private,
   Script(Option<Interpreter<'src>>),
-  Unix,
-  Windows,
+  Unix { enabled: bool },
+  Windows { enabled: bool },
   WorkingDirectory(StringLiteral<'src>),
 }
 
@@ -53,6 +53,7 @@ impl<'src> Attribute<'src> {
   pub(crate) fn new(
     name: Name<'src>,
     arguments: Vec<StringLiteral<'src>>,
+    enabled: bool,
   ) -> CompileResult<'src, Self> {
     let discriminant = name
       .lexeme()
@@ -77,30 +78,39 @@ impl<'src> Attribute<'src> {
       );
     }
 
-    Ok(match discriminant {
-      AttributeDiscriminant::Confirm => Self::Confirm(arguments.into_iter().next()),
-      AttributeDiscriminant::Doc => Self::Doc(arguments.into_iter().next()),
-      AttributeDiscriminant::ExitMessage => Self::ExitMessage,
-      AttributeDiscriminant::Extension => Self::Extension(arguments.into_iter().next().unwrap()),
-      AttributeDiscriminant::Group => Self::Group(arguments.into_iter().next().unwrap()),
-      AttributeDiscriminant::Linux => Self::Linux,
-      AttributeDiscriminant::Macos => Self::Macos,
-      AttributeDiscriminant::NoCd => Self::NoCd,
-      AttributeDiscriminant::NoExitMessage => Self::NoExitMessage,
-      AttributeDiscriminant::NoQuiet => Self::NoQuiet,
-      AttributeDiscriminant::Openbsd => Self::Openbsd,
-      AttributeDiscriminant::PositionalArguments => Self::PositionalArguments,
-      AttributeDiscriminant::Private => Self::Private,
-      AttributeDiscriminant::Script => Self::Script({
+    Ok(match (enabled, discriminant) {
+      (enabled, AttributeDiscriminant::Linux) => Self::Linux { enabled },
+      (enabled, AttributeDiscriminant::Macos) => Self::Macos { enabled },
+      (enabled, AttributeDiscriminant::Unix) => Self::Unix { enabled },
+      (enabled, AttributeDiscriminant::Windows) => Self::Windows { enabled },
+      (enabled, AttributeDiscriminant::Openbsd) => Self::Openbsd { enabled },
+
+      (false, _attr) => {
+        return Err(name.error(CompileErrorKind::InvalidInvertedAttribute {
+          attr_name: name.lexeme(),
+        }))
+      }
+
+      (true, AttributeDiscriminant::Confirm) => Self::Confirm(arguments.into_iter().next()),
+      (true, AttributeDiscriminant::Doc) => Self::Doc(arguments.into_iter().next()),
+      (true, AttributeDiscriminant::Extension) => {
+        Self::Extension(arguments.into_iter().next().unwrap())
+      }
+      (true, AttributeDiscriminant::ExitMessage) => Self::ExitMessage,
+      (true, AttributeDiscriminant::Group) => Self::Group(arguments.into_iter().next().unwrap()),
+      (true, AttributeDiscriminant::NoCd) => Self::NoCd,
+      (true, AttributeDiscriminant::NoExitMessage) => Self::NoExitMessage,
+      (true, AttributeDiscriminant::NoQuiet) => Self::NoQuiet,
+      (true, AttributeDiscriminant::PositionalArguments) => Self::PositionalArguments,
+      (true, AttributeDiscriminant::Private) => Self::Private,
+      (true, AttributeDiscriminant::Script) => Self::Script({
         let mut arguments = arguments.into_iter();
         arguments.next().map(|command| Interpreter {
           command,
           arguments: arguments.collect(),
         })
       }),
-      AttributeDiscriminant::Unix => Self::Unix,
-      AttributeDiscriminant::Windows => Self::Windows,
-      AttributeDiscriminant::WorkingDirectory => {
+      (true, AttributeDiscriminant::WorkingDirectory) => {
         Self::WorkingDirectory(arguments.into_iter().next().unwrap())
       }
     })
@@ -121,29 +131,35 @@ impl<'src> Attribute<'src> {
 
 impl Display for Attribute<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-    write!(f, "{}", self.name())?;
+    let name = self.name();
 
     match self {
       Self::Confirm(Some(argument))
       | Self::Doc(Some(argument))
       | Self::Extension(argument)
       | Self::Group(argument)
-      | Self::WorkingDirectory(argument) => write!(f, "({argument})")?,
-      Self::Script(Some(shell)) => write!(f, "({shell})")?,
+      | Self::WorkingDirectory(argument) => write!(f, "{name}({argument})")?,
+      Self::Script(Some(shell)) => write!(f, "{name}({shell})")?,
+      Self::Linux { enabled }
+      | Self::Macos { enabled }
+      | Self::Unix { enabled }
+      | Self::Openbsd { enabled }
+      | Self::Windows { enabled } => {
+        if *enabled {
+          write!(f, "{name}")?;
+        } else {
+          write!(f, "not({name})")?;
+        }
+      }
       Self::Confirm(None)
       | Self::Doc(None)
       | Self::ExitMessage
-      | Self::Linux
-      | Self::Macos
       | Self::NoCd
       | Self::NoExitMessage
       | Self::NoQuiet
-      | Self::Openbsd
       | Self::PositionalArguments
       | Self::Private
-      | Self::Script(None)
-      | Self::Unix
-      | Self::Windows => {}
+      | Self::Script(None) => write!(f, "{name}")?,
     }
 
     Ok(())

src/attribute_set.rs

@@ -12,6 +12,17 @@ impl<'src> AttributeSet<'src> {
     self.0.iter().any(|attr| attr.discriminant() == target)
   }
 
+  pub(crate) fn contains_invertible(&self, target: AttributeDiscriminant) -> Option<bool> {
+    self.get(target).map(|attr| match attr {
+      Attribute::Linux { enabled }
+      | Attribute::Macos { enabled }
+      | Attribute::Openbsd { enabled }
+      | Attribute::Unix { enabled }
+      | Attribute::Windows { enabled } => *enabled,
+      _ => panic!("contains_invertible called with non-invertible attribute"),
+    })
+  }
+
   pub(crate) fn get(&self, discriminant: AttributeDiscriminant) -> Option<&Attribute<'src>> {
     self
       .0

src/compile_error.rs

@@ -187,6 +187,9 @@ impl Display for CompileError<'_> {
           _ => character.escape_default().collect(),
         }
       ),
+      InvalidInvertedAttribute { attr_name } => {
+        write!(f, "{attr_name} cannot be inverted with `not()`")
+      }
       MismatchedClosingDelimiter {
         open,
         open_line,

src/compile_error_kind.rs

@@ -76,6 +76,9 @@ pub(crate) enum CompileErrorKind<'src> {
   InvalidEscapeSequence {
     character: char,
   },
+  InvalidInvertedAttribute {
+    attr_name: &'src str,
+  },
   MismatchedClosingDelimiter {
     close: Delimiter,
     open: Delimiter,

src/parser.rs

@@ -1191,7 +1191,17 @@ impl<'run, 'src> Parser<'run, 'src> {
       token.get_or_insert(bracket);
 
       loop {
-        let name = self.parse_name()?;
+        let (name, inverted) = {
+          let name = self.parse_name()?;
+          if name.lexeme() == "not" {
+            self.expect(ParenL)?;
+            let name = self.parse_name()?;
+            self.expect(ParenR)?;
+            (name, true)
+          } else {
+            (name, false)
+          }
+        };
 
         let mut arguments = Vec::new();
 
@@ -1208,7 +1218,7 @@ impl<'run, 'src> Parser<'run, 'src> {
           self.expect(ParenR)?;
         }
 
-        let attribute = Attribute::new(name, arguments)?;
+        let attribute = Attribute::new(name, arguments, !inverted)?;
 
         let first = attributes.get(&attribute).or_else(|| {
           if attribute.repeatable() {
@@ -2749,6 +2759,17 @@ mod tests {
     kind:   UnknownAttribute { attribute: "unknown" },
   }
 
+  error! {
+    name:   invalid_invertable_attribute,
+    input:  "[not(private)]\nsome_recipe:\n @exit 3",
+    offset: 5,
+    line:   0,
+    column: 5,
+    width:  7,
+    kind:   InvalidInvertedAttribute { attr_name: "private" },
+
+  }
+
   error! {
     name:   set_unknown,
     input:  "set shall := []",

src/recipe.rs

@@ -16,6 +16,72 @@ fn error_from_signal(recipe: &str, line_number: Option<usize>, exit_status: Exit
   }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::EnumIter)]
+enum System {
+  Linux,
+  MacOS,
+  OpenBSD,
+  Unix,
+  Unrecognized,
+  Windows,
+}
+
+impl System {
+  fn current() -> System {
+    use System::*;
+    if cfg!(target_os = "linux") {
+      return Linux;
+    }
+    if cfg!(target_os = "openbsd") {
+      return OpenBSD;
+    }
+    if cfg!(target_os = "macos") {
+      return MacOS;
+    }
+    if cfg!(target_os = "windows") || cfg!(windows) {
+      return Windows;
+    }
+    if cfg!(unix) {
+      return Unix;
+    }
+    Unrecognized
+  }
+
+  fn is_specific_unix(self) -> bool {
+    matches!(self, System::Linux | System::MacOS | System::OpenBSD)
+  }
+
+  fn others(self) -> Vec<System> {
+    use strum::IntoEnumIterator;
+    System::iter()
+      .filter(|system| {
+        *system != self
+          && if system.is_specific_unix() {
+            *system != System::Unix
+          } else {
+            true
+          }
+      })
+      .collect()
+  }
+
+  fn enabled(self, enabled: HashMap<System, bool>, disabled: HashMap<System, bool>) -> bool {
+    let not_disabled = !disabled[&self];
+    let explicitly_enabled = enabled[&self];
+    let no_others_enabled = !self
+      .others()
+      .iter()
+      .any(|system| *enabled.get(system).unwrap_or(&false));
+
+    // Special case for Unix family
+    if self.is_specific_unix() && enabled.get(&System::Unix).copied().unwrap_or(false) {
+      return !disabled.get(&self).copied().unwrap_or(false);
+    }
+
+    not_disabled && (explicitly_enabled || no_others_enabled)
+  }
+}
+
 /// A recipe, e.g. `foo: bar baz`
 #[derive(PartialEq, Debug, Clone, Serialize)]
 pub(crate) struct Recipe<'src, D = Dependency<'src>> {
@@ -114,19 +180,54 @@ impl<'src, D> Recipe<'src, D> {
   }
 
   pub(crate) fn enabled(&self) -> bool {
-    let linux = self.attributes.contains(AttributeDiscriminant::Linux);
-    let macos = self.attributes.contains(AttributeDiscriminant::Macos);
-    let openbsd = self.attributes.contains(AttributeDiscriminant::Openbsd);
-    let unix = self.attributes.contains(AttributeDiscriminant::Unix);
-    let windows = self.attributes.contains(AttributeDiscriminant::Windows);
-
-    (!windows && !linux && !macos && !openbsd && !unix)
-      || (cfg!(target_os = "linux") && (linux || unix))
-      || (cfg!(target_os = "macos") && (macos || unix))
-      || (cfg!(target_os = "openbsd") && (openbsd || unix))
-      || (cfg!(target_os = "windows") && windows)
-      || (cfg!(unix) && unix)
-      || (cfg!(windows) && windows)
+    use std::ops::Not;
+
+    let linux = self
+      .attributes
+      .contains_invertible(AttributeDiscriminant::Linux);
+    let macos = self
+      .attributes
+      .contains_invertible(AttributeDiscriminant::Macos);
+    let openbsd = self
+      .attributes
+      .contains_invertible(AttributeDiscriminant::Openbsd);
+    let unix = self
+      .attributes
+      .contains_invertible(AttributeDiscriminant::Unix);
+    let windows = self
+      .attributes
+      .contains_invertible(AttributeDiscriminant::Windows);
+
+    if [linux, macos, openbsd, unix, windows]
+      .into_iter()
+      .all(|x| x.is_none())
+    {
+      return true;
+    }
+
+    let enabled: HashMap<System, bool> = [
+      (System::Windows, windows.unwrap_or(false)),
+      (System::MacOS, macos.unwrap_or(false)),
+      (System::Linux, linux.unwrap_or(false)),
+      (System::OpenBSD, openbsd.unwrap_or(false)),
+      (System::Unix, unix.unwrap_or(false)),
+      (System::Unrecognized, false),
+    ]
+    .into_iter()
+    .collect();
+
+    let disabled: HashMap<System, bool> = [
+      (System::Windows, windows.is_some_and(bool::not)),
+      (System::MacOS, macos.is_some_and(bool::not)),
+      (System::Linux, linux.is_some_and(bool::not)),
+      (System::OpenBSD, openbsd.is_some_and(bool::not)),
+      (System::Unix, unix.is_some_and(bool::not)),
+      (System::Unrecognized, false),
+    ]
+    .into_iter()
+    .collect();
+
+    System::current().enabled(enabled, disabled)
   }
 
   fn print_exit_message(&self, settings: &Settings) -> bool {