1015 lines
38 KiB
Rust
1015 lines
38 KiB
Rust
use std::{io, process::ExitStatus, str::FromStr, string::FromUtf8Error};
|
|
use strum::IntoEnumIterator;
|
|
|
|
use serde::{de::Expected, Deserialize, Serialize};
|
|
use thiserror::Error;
|
|
|
|
use crate::{gen_parse, hlwm::Client};
|
|
|
|
use super::{
|
|
attribute::{Attribute, AttributeError, AttributeOption},
|
|
hlwmbool::ToggleBool,
|
|
hook::Hook,
|
|
key::{KeyUnbind, Keybind, Mousebind},
|
|
rule::Rule,
|
|
setting::{FrameLayout, Setting, SettingName},
|
|
split,
|
|
window::Window,
|
|
Align, Direction, Index, Monitor, Operator, Separator, StringParseError, Tag, ToCommandString,
|
|
};
|
|
|
|
#[derive(Debug, Clone, strum::Display, strum::EnumIter, PartialEq)]
|
|
#[strum(serialize_all = "snake_case")]
|
|
pub enum HlwmCommand {
|
|
/// Quits herbstluftwm.
|
|
Quit,
|
|
/// Prints the version of the running herbstluftwm instance
|
|
Version,
|
|
/// Ignores all arguments and always returns success, i.e. 0
|
|
True,
|
|
/// Ignores all arguments and always returns failure, i.e. 1.
|
|
False,
|
|
/// Prints all given `args` separated by a single space and a newline afterwards
|
|
Echo(Vec<String>),
|
|
/// Executes the autostart file.
|
|
Reload,
|
|
/// Closes the specified `window` gracefully or the focused window
|
|
/// if none is given explicitly
|
|
Close {
|
|
window: Option<Window>,
|
|
},
|
|
/// Spawns an `executable` with its `args`.
|
|
Spawn {
|
|
executable: String,
|
|
args: Vec<String>,
|
|
},
|
|
/// List currently configured monitors with their index,
|
|
/// area (as rectangle), name (if named) and currently viewed tag.
|
|
ListMonitors,
|
|
/// Lists all bound keys with their associated command
|
|
ListKeybinds,
|
|
/// Lists all active rules.
|
|
ListRules,
|
|
/// Increases the monitors_locked setting.
|
|
/// Use this if you want to do multiple window actions at once
|
|
/// (i.e. without repainting between the single steps).
|
|
///
|
|
/// See also: [Command::Unlock]
|
|
Lock,
|
|
/// Decreases the monitors_locked setting.
|
|
/// If monitors_locked is changed to 0, then all monitors are repainted again.
|
|
/// See also: [Command::Lock]
|
|
Unlock,
|
|
/// Print the value of the specified attribute
|
|
GetAttr(String),
|
|
/// Assign `new_value` to the specified `attribute`
|
|
SetAttr {
|
|
path: String,
|
|
new_value: Attribute,
|
|
},
|
|
/// Prints the children and attributes of the given object addressed by `path`.
|
|
/// If `path` is an attribute, then print the attribute value.
|
|
/// If `new_value` is given, assign `new_value` to the attribute given by `path`.
|
|
Attr {
|
|
path: String,
|
|
new_value: Option<Attribute>,
|
|
},
|
|
/// Creates a new attribute with the name and in the object specified by `path`.
|
|
/// Its type is specified by `attr`.
|
|
/// The attribute name has to begin with my_.
|
|
/// If `value` is supplied, then it is written to the attribute
|
|
/// (if this fails the attribute still remains).
|
|
NewAttr {
|
|
path: String,
|
|
attr: AttributeOption,
|
|
},
|
|
/// Print the type of the specified attribute
|
|
AttrType(String),
|
|
/// Removes the user defined attribute
|
|
RemoveAttr(String),
|
|
/// Sets the specified [Setting].
|
|
/// Allowed values for boolean settings are on or true for on,
|
|
/// off or false for off, toggle to toggle its value
|
|
Set(Setting),
|
|
Get(SettingName),
|
|
/// Emits a custom `hook` to all idling herbstclients
|
|
EmitHook(Hook),
|
|
Substitute,
|
|
Keybind(Keybind),
|
|
Keyunbind(KeyUnbind),
|
|
Mousebind(Mousebind),
|
|
/// Removes all mouse bindings
|
|
Mouseunbind,
|
|
UseIndex {
|
|
index: Index<i32>,
|
|
skip_visible: bool,
|
|
},
|
|
MoveIndex {
|
|
index: Index<i32>,
|
|
skip_visible: bool,
|
|
},
|
|
#[strum(serialize = "jumpto")]
|
|
JumpTo(Window),
|
|
/// Creates a new empty tag with the given name
|
|
#[strum(serialize = "add")]
|
|
AddTag(String),
|
|
/// Switches the focused monitor to specified tag
|
|
#[strum(serialize = "use")]
|
|
UseTag(String),
|
|
/// Moves the focused window to the tag with the given name
|
|
#[strum(serialize = "move")]
|
|
MoveTag(String),
|
|
/// Removes tag named `tag` and moves all its windows to tag `target`.
|
|
/// If `target` is None, the focused tag will be used
|
|
MergeTag {
|
|
tag: String,
|
|
target: Option<Tag>,
|
|
},
|
|
Cycle,
|
|
Focus(Direction),
|
|
Shift(Direction),
|
|
Split(Align),
|
|
Remove,
|
|
Fullscreen(ToggleBool),
|
|
CycleLayout {
|
|
delta: Option<Index<i32>>,
|
|
layouts: Vec<FrameLayout>,
|
|
},
|
|
Resize {
|
|
direction: Direction,
|
|
fraction_delta: Option<Index<f64>>,
|
|
},
|
|
Watch,
|
|
Or {
|
|
separator: Separator,
|
|
commands: Vec<HlwmCommand>,
|
|
},
|
|
And {
|
|
separator: Separator,
|
|
commands: Vec<HlwmCommand>,
|
|
},
|
|
Compare {
|
|
attribute: String,
|
|
operator: Operator,
|
|
value: String,
|
|
},
|
|
/// Print a tab separated list of all tags for the specified `monitor` index.
|
|
/// If no `monitor` index is given, the focused monitor is used.
|
|
TagStatus {
|
|
monitor: Option<Monitor>,
|
|
},
|
|
/// Defines a rule which will be applied to all new clients
|
|
Rule(Rule),
|
|
/// executes the provided command, prints its output, but always returns success, i.e. 0
|
|
Try(Box<HlwmCommand>),
|
|
/// executes the provided command, but discards its output and only returns its exit code.
|
|
Silent(Box<HlwmCommand>),
|
|
}
|
|
|
|
impl FromStr for Box<HlwmCommand> {
|
|
type Err = CommandParseError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
Ok(Box::new(HlwmCommand::from_str(s)?))
|
|
}
|
|
}
|
|
|
|
impl Serialize for HlwmCommand {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
serializer.serialize_str(&self.to_command_string().replace("\t", " "))
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for HlwmCommand {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
pub enum Expect {
|
|
NotEmpty,
|
|
}
|
|
impl Expected for Expect {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
match self {
|
|
Expect::NotEmpty => write!(f, "value not being empty"),
|
|
}
|
|
}
|
|
}
|
|
|
|
let str_val: String = Deserialize::deserialize(deserializer)?;
|
|
|
|
let parts = split::tab_or_space(&str_val);
|
|
if parts.is_empty() {
|
|
return Err(serde::de::Error::invalid_length(0, &Expect::NotEmpty));
|
|
}
|
|
let mut parts = parts.into_iter();
|
|
let command = parts.next().unwrap();
|
|
let args = parts.collect();
|
|
|
|
Ok(Self::from_raw_parts(&command, args).map_err(|err| {
|
|
serde::de::Error::invalid_value(serde::de::Unexpected::Str(&str_val), &err)
|
|
})?)
|
|
}
|
|
}
|
|
|
|
impl FromStr for HlwmCommand {
|
|
type Err = CommandParseError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
let mut parts = s.split("\t");
|
|
let command = parts
|
|
.next()
|
|
.ok_or(CommandParseError::UnknownCommand(s.to_string()))?;
|
|
let args = parts.map(String::from).collect();
|
|
HlwmCommand::from_raw_parts(command, args)
|
|
}
|
|
}
|
|
|
|
impl Default for HlwmCommand {
|
|
fn default() -> Self {
|
|
HlwmCommand::Quit
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum CommandParseError {
|
|
#[error("unknown command [{0}]")]
|
|
UnknownCommand(String),
|
|
#[error("bad argument for command [{command}]")]
|
|
BadArgument { command: String },
|
|
#[error("missing required argument")]
|
|
MissingArgument,
|
|
#[error("invalid argument count [{0}] at [{1}]")]
|
|
InvalidArgumentCount(usize, String),
|
|
#[error("error parsing attribute: [{0}]")]
|
|
AttributeError(#[from] AttributeError),
|
|
#[error("command execution error: [{0}]")]
|
|
CommandError(#[from] CommandError),
|
|
#[error("string utf8 error")]
|
|
StringUtf8Error(#[from] FromUtf8Error),
|
|
#[error("parsing string value error: [{0}]")]
|
|
StringParseError(#[from] StringParseError),
|
|
}
|
|
|
|
impl serde::de::Expected for CommandParseError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
write!(f, "expected valid command string. Got error: {self}")
|
|
}
|
|
}
|
|
|
|
fn trim_quotes(itm: String) -> String {
|
|
if itm.starts_with('"') && itm.ends_with('"') {
|
|
itm.trim_matches('"').to_string()
|
|
} else {
|
|
itm
|
|
}
|
|
}
|
|
|
|
impl HlwmCommand {
|
|
pub fn silent(self) -> HlwmCommand {
|
|
HlwmCommand::Silent(Box::new(self))
|
|
}
|
|
|
|
pub fn to_try(self) -> HlwmCommand {
|
|
HlwmCommand::Try(Box::new(self))
|
|
}
|
|
|
|
pub fn from_raw_parts(command: &str, args: Vec<String>) -> Result<Self, CommandParseError> {
|
|
let command = HlwmCommand::iter()
|
|
.find(|cmd| cmd.to_string() == command)
|
|
.ok_or(CommandParseError::UnknownCommand(command.to_string()))?;
|
|
|
|
gen_parse!(command, args);
|
|
|
|
let parsed_command = match command {
|
|
HlwmCommand::Quit
|
|
| HlwmCommand::Lock
|
|
| HlwmCommand::Cycle
|
|
| HlwmCommand::Watch
|
|
| HlwmCommand::Reload
|
|
| HlwmCommand::Remove
|
|
| HlwmCommand::Unlock
|
|
| HlwmCommand::Version
|
|
| HlwmCommand::ListRules
|
|
| HlwmCommand::False
|
|
| HlwmCommand::True
|
|
| HlwmCommand::Substitute
|
|
| HlwmCommand::Mouseunbind
|
|
| HlwmCommand::ListMonitors
|
|
| HlwmCommand::ListKeybinds => Ok::<_, CommandParseError>(command.clone()),
|
|
HlwmCommand::Echo(_) => Ok(Self::Echo(args)),
|
|
HlwmCommand::Close { window: _ } => parse!(window: [Option<FromStr>] => Close),
|
|
HlwmCommand::Spawn {
|
|
executable: _,
|
|
args: _,
|
|
} => {
|
|
parse!(executable: String, args: [Vec<String>] => Spawn).map(|spawn| match spawn {
|
|
HlwmCommand::Spawn { executable, args } => HlwmCommand::Spawn {
|
|
executable: trim_quotes(executable),
|
|
args: args.into_iter().map(trim_quotes).collect(),
|
|
},
|
|
_ => unreachable!(),
|
|
})
|
|
}
|
|
HlwmCommand::GetAttr(_) => parse!(String => GetAttr),
|
|
HlwmCommand::SetAttr {
|
|
path: _,
|
|
new_value: _,
|
|
} => {
|
|
let mut args = args.into_iter();
|
|
let path = args.next().ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?;
|
|
Ok(HlwmCommand::SetAttr {
|
|
path: path.clone(),
|
|
new_value: {
|
|
Attribute::new(
|
|
&String::from_utf8(
|
|
Client::new()
|
|
.execute(HlwmCommand::AttrType(path.clone()))?
|
|
.stdout,
|
|
)?
|
|
.split('\n')
|
|
.next()
|
|
.ok_or(CommandParseError::CommandError(CommandError::Empty))?,
|
|
&args.collect::<Vec<_>>().join(" "),
|
|
)?
|
|
},
|
|
})
|
|
}
|
|
HlwmCommand::Attr {
|
|
path: _,
|
|
new_value: _,
|
|
} => {
|
|
let mut args = args.into_iter();
|
|
Ok(HlwmCommand::Attr {
|
|
path: args.next().ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?,
|
|
new_value: {
|
|
let args = args.collect::<Vec<_>>();
|
|
if args.is_empty() {
|
|
None
|
|
} else {
|
|
Some(Attribute::guess_type(&args.join("\t")))
|
|
}
|
|
},
|
|
})
|
|
}
|
|
HlwmCommand::NewAttr { path: _, attr: _ } => {
|
|
let mut args = args.into_iter();
|
|
let attr_type = args.next().ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?;
|
|
let path = args.next().ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?;
|
|
Ok(HlwmCommand::NewAttr {
|
|
path,
|
|
attr: {
|
|
let attr = args.collect::<Vec<String>>();
|
|
let attr = if attr.len() == 0 {
|
|
None
|
|
} else {
|
|
Some(attr.join("\t"))
|
|
};
|
|
AttributeOption::new(&attr_type, &attr)?
|
|
},
|
|
})
|
|
}
|
|
HlwmCommand::AttrType(_) => parse!(String => AttrType),
|
|
HlwmCommand::RemoveAttr(_) => parse!(String => RemoveAttr),
|
|
HlwmCommand::Set(_) => parse!(FromStrAll => Set),
|
|
HlwmCommand::EmitHook(_) => parse!(FromStr => EmitHook),
|
|
HlwmCommand::Keybind(_) => parse!(FromStrAll => Keybind),
|
|
HlwmCommand::Keyunbind(_) => parse!(FromStr => Keyunbind),
|
|
HlwmCommand::Mousebind(_) => parse!(FromStrAll => Mousebind),
|
|
HlwmCommand::JumpTo(_) => parse!(FromStr => JumpTo),
|
|
HlwmCommand::AddTag(_) => parse!(String => AddTag),
|
|
HlwmCommand::MergeTag { tag: _, target: _ } => {
|
|
parse!(tag: String, target: [Option<FromStr>] => MergeTag)
|
|
}
|
|
HlwmCommand::Focus(_) => parse!(FromStr => Focus),
|
|
HlwmCommand::Shift(_) => parse!(FromStr => Shift),
|
|
HlwmCommand::Split(_) => parse!(FromStrAll => Split),
|
|
HlwmCommand::Fullscreen(_) => parse!(FromStr => Fullscreen),
|
|
HlwmCommand::CycleLayout {
|
|
delta: _,
|
|
layouts: _,
|
|
} => {
|
|
if args.is_empty() {
|
|
Ok(HlwmCommand::CycleLayout {
|
|
delta: None,
|
|
layouts: vec![],
|
|
})
|
|
} else {
|
|
let first = args.first().ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?;
|
|
match FrameLayout::from_str(first) {
|
|
Ok(_) => {
|
|
// only frame layouts
|
|
Ok(HlwmCommand::CycleLayout {
|
|
delta: None,
|
|
layouts: args
|
|
.into_iter()
|
|
.map(|i| FrameLayout::from_str(&i))
|
|
.collect::<Result<_, _>>()
|
|
.map_err(|_| CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?,
|
|
})
|
|
}
|
|
Err(_) => {
|
|
// Has index
|
|
let mut args = args.into_iter();
|
|
Ok(HlwmCommand::CycleLayout {
|
|
delta: Some(args.next().unwrap().parse().map_err(|_| {
|
|
CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
}
|
|
})?),
|
|
layouts: args
|
|
.map(|i| FrameLayout::from_str(&i))
|
|
.collect::<Result<_, _>>()
|
|
.map_err(|_| CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
HlwmCommand::Resize {
|
|
direction: _,
|
|
fraction_delta: _,
|
|
} => parse!(direction: FromStr, fraction_delta: [Option<FromStr>] => Resize),
|
|
HlwmCommand::Or {
|
|
separator: _,
|
|
commands: _,
|
|
} => parse!(And_Or => Or),
|
|
HlwmCommand::And {
|
|
separator: _,
|
|
commands: _,
|
|
} => parse!(And_Or => And),
|
|
HlwmCommand::Compare {
|
|
attribute: _,
|
|
operator: _,
|
|
value: _,
|
|
} => parse!(attribute: String, operator: FromStr, value: String => Compare),
|
|
HlwmCommand::TagStatus { monitor: _ } => {
|
|
parse!(monitor: [Option<FromStr>] => TagStatus)
|
|
}
|
|
HlwmCommand::Rule(_) => parse!(FromStrAll => Rule),
|
|
HlwmCommand::Get(_) => parse!(FromStr => Get),
|
|
HlwmCommand::MoveIndex {
|
|
index: _,
|
|
skip_visible: _,
|
|
} => {
|
|
if args.contains(&"--skip-visible".to_string()) {
|
|
Ok(HlwmCommand::MoveIndex {
|
|
index: args
|
|
.into_iter()
|
|
.filter(|a| a != "--skip-visible")
|
|
.next()
|
|
.ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?
|
|
.parse()?,
|
|
skip_visible: true,
|
|
})
|
|
} else {
|
|
Ok(HlwmCommand::MoveIndex {
|
|
index: args
|
|
.into_iter()
|
|
.next()
|
|
.ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?
|
|
.parse()?,
|
|
skip_visible: false,
|
|
})
|
|
}
|
|
}
|
|
HlwmCommand::UseIndex {
|
|
index: _,
|
|
skip_visible: _,
|
|
} => {
|
|
if args.contains(&"--skip-visible".to_string()) {
|
|
Ok(HlwmCommand::UseIndex {
|
|
index: args
|
|
.into_iter()
|
|
.filter(|a| a != "--skip-visible")
|
|
.next()
|
|
.ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?
|
|
.parse()?,
|
|
skip_visible: true,
|
|
})
|
|
} else {
|
|
Ok(HlwmCommand::UseIndex {
|
|
index: args
|
|
.into_iter()
|
|
.next()
|
|
.ok_or(CommandParseError::BadArgument {
|
|
command: command.to_string(),
|
|
})?
|
|
.parse()?,
|
|
skip_visible: false,
|
|
})
|
|
}
|
|
}
|
|
HlwmCommand::UseTag(_) => parse!(String => UseTag),
|
|
HlwmCommand::MoveTag(_) => parse!(String => MoveTag),
|
|
HlwmCommand::Try(_) => parse!(FromStrAll => Try),
|
|
HlwmCommand::Silent(_) => parse!(FromStrAll => Silent),
|
|
}?;
|
|
|
|
assert_eq!(command.to_string(), parsed_command.to_string());
|
|
|
|
Ok(parsed_command)
|
|
}
|
|
}
|
|
|
|
impl HlwmCommand {
|
|
#[inline(always)]
|
|
pub(crate) fn args(&self) -> Vec<String> {
|
|
if let Self::Spawn { executable, args } = self {
|
|
return vec!["spawn".to_string(), executable.to_string()]
|
|
.into_iter()
|
|
.chain(args.into_iter().cloned())
|
|
.collect();
|
|
}
|
|
self.to_command_string()
|
|
.split('\t')
|
|
.map(|a| a.to_string())
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum CommandError {
|
|
#[error("IO error")]
|
|
IoError(#[from] io::Error),
|
|
#[error("exited with status code {0}")]
|
|
StatusCode(i32, Option<String>),
|
|
#[error("killed by signal ({signal}); core dumped: {core_dumped}")]
|
|
KilledBySignal { signal: i32, core_dumped: bool },
|
|
#[error("stopped by signal ({0})")]
|
|
StoppedBySignal(i32),
|
|
#[error("exit status not checked: {0:?}")]
|
|
OtherExitStatus(ExitStatus),
|
|
#[error("invalid utf8 string in response: {0:?}")]
|
|
UtfError(#[from] FromUtf8Error),
|
|
#[error("attribute error: {0:?}")]
|
|
AttributeError(#[from] AttributeError),
|
|
#[error("string parse error: {0}")]
|
|
StringParseError(#[from] StringParseError),
|
|
#[error("unexpected empty result")]
|
|
Empty,
|
|
}
|
|
|
|
impl ToCommandString for HlwmCommand {
|
|
fn to_command_string(&self) -> String {
|
|
let cmd_string = match self {
|
|
HlwmCommand::Quit
|
|
| HlwmCommand::Lock
|
|
| HlwmCommand::Cycle
|
|
| HlwmCommand::Unlock
|
|
| HlwmCommand::Remove
|
|
| HlwmCommand::Reload
|
|
| HlwmCommand::Version
|
|
| HlwmCommand::ListRules
|
|
| HlwmCommand::Substitute
|
|
| HlwmCommand::Mouseunbind
|
|
| HlwmCommand::True
|
|
| HlwmCommand::False
|
|
| HlwmCommand::ListMonitors
|
|
| HlwmCommand::ListKeybinds
|
|
| HlwmCommand::Watch => self.to_string(),
|
|
HlwmCommand::Echo(args) => format!("{self}\t{}", args.join("\t")),
|
|
HlwmCommand::Close { window } => format!(
|
|
"{self}\t{}",
|
|
window.as_ref().map(|w| w.to_string()).unwrap_or_default(),
|
|
),
|
|
HlwmCommand::Spawn { executable, args } => {
|
|
format!(
|
|
"{self}\t\"{executable}\"\t{}",
|
|
(&args)
|
|
.into_iter()
|
|
.map(|arg| format!("\"{arg}\""))
|
|
.collect::<Vec<String>>()
|
|
.join("\t")
|
|
)
|
|
}
|
|
HlwmCommand::GetAttr(attr) => format!("{self}\t{attr}"),
|
|
HlwmCommand::SetAttr {
|
|
path: attribute,
|
|
new_value,
|
|
} => format!("{self}\t{attribute}\t{new_value}"),
|
|
HlwmCommand::Attr { path, new_value } => {
|
|
format!(
|
|
"{self}\t{path}\t{}",
|
|
new_value
|
|
.as_ref()
|
|
.map(|val| val.to_string())
|
|
.unwrap_or_default()
|
|
)
|
|
}
|
|
HlwmCommand::NewAttr { path, attr } => {
|
|
format!(
|
|
"{self}\t{ty}\t{path}\t{attr}",
|
|
ty = attr.type_string(),
|
|
attr = attr.value_string().unwrap_or_default()
|
|
)
|
|
}
|
|
HlwmCommand::AttrType(attr) | HlwmCommand::RemoveAttr(attr) => {
|
|
format!("{self}\t{attr}")
|
|
}
|
|
HlwmCommand::Set(setting) => format!("{self}\t{}", setting.to_command_string()),
|
|
HlwmCommand::EmitHook(hook) => format!("{self}\t{}", hook.to_command_string()),
|
|
HlwmCommand::Keybind(keybind) => {
|
|
format!("{self}\t{}", keybind.to_command_string())
|
|
}
|
|
HlwmCommand::Mousebind(mousebind) => format!("{self}\t{}", mousebind.to_string()),
|
|
HlwmCommand::Keyunbind(key_unbind) => format!("{self}\t{key_unbind}"),
|
|
HlwmCommand::MoveIndex {
|
|
index,
|
|
skip_visible,
|
|
} => format!(
|
|
"{self}\t{index}{}",
|
|
if *skip_visible {
|
|
"\t--skip-visible"
|
|
} else {
|
|
""
|
|
}
|
|
),
|
|
HlwmCommand::JumpTo(win) => format!("{self}\t{win}"),
|
|
HlwmCommand::AddTag(tag) => format!("{self}\t{tag}"),
|
|
HlwmCommand::MergeTag { tag, target } => format!(
|
|
"{self}\t{tag}\t{}",
|
|
target.as_ref().map(|t| t.to_string()).unwrap_or_default()
|
|
),
|
|
HlwmCommand::Focus(dir) | HlwmCommand::Shift(dir) => format!("{self}\t{dir}"),
|
|
HlwmCommand::Split(split) => format!("{self}\t{}", split.to_command_string()),
|
|
HlwmCommand::Fullscreen(option) => format!(
|
|
"{self}\t{}",
|
|
match option {
|
|
ToggleBool::Bool(b) => match b {
|
|
true => "on",
|
|
false => "off",
|
|
},
|
|
ToggleBool::Toggle => "toggle",
|
|
}
|
|
),
|
|
HlwmCommand::And {
|
|
separator,
|
|
commands,
|
|
}
|
|
| HlwmCommand::Or {
|
|
separator,
|
|
commands,
|
|
} => format!(
|
|
"{self}\t{separator}\t{}",
|
|
commands
|
|
.into_iter()
|
|
.map(|c| c.to_command_string())
|
|
.collect::<Vec<String>>()
|
|
.join(&format!("\t{separator}\t"))
|
|
),
|
|
HlwmCommand::Compare {
|
|
attribute,
|
|
operator,
|
|
value,
|
|
} => format!("{self}\t{attribute}\t{operator}\t{value}"),
|
|
HlwmCommand::CycleLayout { delta, layouts } => {
|
|
let mut command = self.to_string();
|
|
if let Some(delta) = delta {
|
|
command = format!("{command}\t{delta}");
|
|
}
|
|
if layouts.len() != 0 {
|
|
command = format!(
|
|
"{command}\t{}",
|
|
layouts
|
|
.into_iter()
|
|
.map(|l| l.to_string())
|
|
.collect::<Vec<String>>()
|
|
.join("\t")
|
|
)
|
|
}
|
|
command
|
|
}
|
|
HlwmCommand::Resize {
|
|
direction,
|
|
fraction_delta,
|
|
} => format!(
|
|
"{self}\t{direction}\t{}",
|
|
fraction_delta
|
|
.as_ref()
|
|
.map(|d| d.to_string())
|
|
.unwrap_or_default()
|
|
),
|
|
HlwmCommand::TagStatus { monitor } => {
|
|
format!("{self}\t{}", monitor.unwrap_or_default())
|
|
}
|
|
HlwmCommand::Rule(rule) => format!("{self}\t{}", rule.to_command_string()),
|
|
HlwmCommand::Get(setting) => format!("{self}\t{setting}"),
|
|
HlwmCommand::UseIndex {
|
|
index,
|
|
skip_visible,
|
|
} => {
|
|
if *skip_visible {
|
|
format!("{self}\t{index}\t--skip-visible")
|
|
} else {
|
|
format!("{self}\t{index}")
|
|
}
|
|
}
|
|
HlwmCommand::UseTag(tag) | HlwmCommand::MoveTag(tag) => format!("{self}\t{tag}"),
|
|
HlwmCommand::Try(cmd) | HlwmCommand::Silent(cmd) => {
|
|
format!("{self}\t{}", cmd.to_command_string())
|
|
}
|
|
};
|
|
if let Some(s) = cmd_string.strip_suffix('\t') {
|
|
return s.to_string();
|
|
}
|
|
cmd_string
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
|
|
use strum::IntoEnumIterator;
|
|
|
|
use crate::hlwm::{
|
|
attribute::{Attribute, AttributeOption},
|
|
command::{FrameLayout, HlwmCommand, Index, Operator, Separator},
|
|
hlwmbool::ToggleBool,
|
|
hook::Hook,
|
|
key::{Key, KeyUnbind, MouseButton, Mousebind, MousebindAction},
|
|
rule::{Condition, Consequence, Rule, RuleOperator},
|
|
setting::{Setting, SettingName},
|
|
window::Window,
|
|
Align, Direction, Tag, ToCommandString,
|
|
};
|
|
use pretty_assertions::assert_eq;
|
|
|
|
#[test]
|
|
fn hlwm_command_string_and_back() {
|
|
let commands = HlwmCommand::iter()
|
|
.map(|cmd| match cmd {
|
|
HlwmCommand::Quit
|
|
| HlwmCommand::Version
|
|
| HlwmCommand::Reload
|
|
| HlwmCommand::Lock
|
|
| HlwmCommand::Remove
|
|
| HlwmCommand::Cycle
|
|
| HlwmCommand::ListMonitors
|
|
| HlwmCommand::ListRules
|
|
| HlwmCommand::ListKeybinds
|
|
| HlwmCommand::Unlock
|
|
| HlwmCommand::True
|
|
| HlwmCommand::False
|
|
| HlwmCommand::Substitute
|
|
| HlwmCommand::Mouseunbind => (cmd.clone(), cmd.to_string()),
|
|
HlwmCommand::Echo(_) => (
|
|
HlwmCommand::Echo(vec!["Hello world!".into()]),
|
|
"echo\tHello world!".into(),
|
|
),
|
|
HlwmCommand::Close { window: _ } => (
|
|
HlwmCommand::Close {
|
|
window: Some(Window::LastMinimized),
|
|
},
|
|
"close\tlast-minimized".into(),
|
|
),
|
|
HlwmCommand::Spawn {
|
|
executable: _,
|
|
args: _,
|
|
} => (
|
|
HlwmCommand::Spawn {
|
|
executable: "grep".into(),
|
|
args: vec!["content".into()],
|
|
},
|
|
"spawn\t\"grep\"\t\"content\"".into(),
|
|
),
|
|
HlwmCommand::GetAttr(_) => (
|
|
HlwmCommand::GetAttr("my_attr".into()),
|
|
"get_attr\tmy_attr".into(),
|
|
),
|
|
HlwmCommand::SetAttr {
|
|
path: _,
|
|
new_value: _,
|
|
} => (
|
|
HlwmCommand::SetAttr {
|
|
path: "theme.color".into(),
|
|
new_value: Attribute::Color("#000000".parse().unwrap()),
|
|
},
|
|
"set_attr\ttheme.color\t#000000".into(),
|
|
),
|
|
HlwmCommand::Attr {
|
|
path: _,
|
|
new_value: _,
|
|
} => (
|
|
HlwmCommand::Attr {
|
|
path: "my_attr".into(),
|
|
new_value: Some(Attribute::String("hello".into())),
|
|
},
|
|
"attr\tmy_attr\thello".into(),
|
|
),
|
|
HlwmCommand::NewAttr { path: _, attr: _ } => (
|
|
HlwmCommand::NewAttr {
|
|
path: "my_attr".into(),
|
|
attr: AttributeOption::String(Some("hello".into())),
|
|
},
|
|
"new_attr\tstring\tmy_attr\thello".into(),
|
|
),
|
|
HlwmCommand::AttrType(_) => (
|
|
HlwmCommand::AttrType("my_attr".into()),
|
|
"attr_type\tmy_attr".into(),
|
|
),
|
|
HlwmCommand::RemoveAttr(_) => (
|
|
HlwmCommand::RemoveAttr("my_attr".into()),
|
|
"remove_attr\tmy_attr".into(),
|
|
),
|
|
HlwmCommand::Set(_) => (
|
|
HlwmCommand::Set(Setting::AutoDetectMonitors(ToggleBool::Toggle)),
|
|
"set\tauto_detect_monitors\ttoggle".into(),
|
|
),
|
|
HlwmCommand::EmitHook(_) => (
|
|
HlwmCommand::EmitHook(Hook::Reload),
|
|
"emit_hook\treload".into(),
|
|
),
|
|
HlwmCommand::Keybind(_) => (
|
|
HlwmCommand::Keybind("Mod4+1\treload".parse().unwrap()),
|
|
"keybind\tMod4+1\treload".into(),
|
|
),
|
|
HlwmCommand::Keyunbind(_) => (
|
|
HlwmCommand::Keyunbind(KeyUnbind::All),
|
|
"keyunbind\t--all".into(),
|
|
),
|
|
HlwmCommand::Mousebind(_) => (
|
|
HlwmCommand::Mousebind(Mousebind {
|
|
keys: vec![Key::Mod4Super, Key::Mouse(MouseButton::Button1)],
|
|
action: MousebindAction::Move,
|
|
}),
|
|
"mousebind\tMod4-Button1\tmove".into(),
|
|
),
|
|
HlwmCommand::MoveIndex {
|
|
index: _,
|
|
skip_visible: _,
|
|
} => (
|
|
HlwmCommand::MoveIndex {
|
|
index: Index::Absolute(1),
|
|
skip_visible: true,
|
|
},
|
|
"move_index\t1\t--skip-visible".into(),
|
|
),
|
|
HlwmCommand::JumpTo(_) => (
|
|
HlwmCommand::JumpTo(Window::LastMinimized),
|
|
"jumpto\tlast-minimized".into(),
|
|
),
|
|
HlwmCommand::AddTag(_) => (
|
|
HlwmCommand::AddTag("tag_name".into()),
|
|
"add\ttag_name".into(),
|
|
),
|
|
HlwmCommand::Focus(_) => {
|
|
(HlwmCommand::Focus(Direction::Down), "focus\tdown".into())
|
|
}
|
|
HlwmCommand::Shift(_) => (HlwmCommand::Shift(Direction::Up), "shift\tup".into()),
|
|
HlwmCommand::Split(_) => (
|
|
HlwmCommand::Split(Align::Right(Some(0.5))),
|
|
"split\tright\t0.5".into(),
|
|
),
|
|
HlwmCommand::Fullscreen(_) => (
|
|
HlwmCommand::Fullscreen(ToggleBool::Toggle),
|
|
"fullscreen\ttoggle".into(),
|
|
),
|
|
HlwmCommand::MergeTag { tag: _, target: _ } => (
|
|
HlwmCommand::MergeTag {
|
|
tag: "my_tag".into(),
|
|
target: Some(Tag::Name("other_tag".into())),
|
|
},
|
|
"merge_tag\tmy_tag\tother_tag".into(),
|
|
),
|
|
HlwmCommand::CycleLayout {
|
|
delta: _,
|
|
layouts: _,
|
|
} => (
|
|
HlwmCommand::CycleLayout {
|
|
delta: Some(Index::Absolute(1)),
|
|
layouts: vec![FrameLayout::Vertical, FrameLayout::Max, FrameLayout::Grid],
|
|
},
|
|
"cycle_layout\t1\tvertical\tmax\tgrid".into(),
|
|
),
|
|
HlwmCommand::Resize {
|
|
direction: _,
|
|
fraction_delta: _,
|
|
} => (
|
|
HlwmCommand::Resize {
|
|
direction: Direction::Down,
|
|
fraction_delta: Some(Index::Absolute(0.5)),
|
|
},
|
|
"resize\tdown\t0.5".into(),
|
|
),
|
|
HlwmCommand::Watch => (HlwmCommand::Watch, "watch".into()),
|
|
HlwmCommand::Or {
|
|
separator: _,
|
|
commands: _,
|
|
} => (
|
|
HlwmCommand::Or {
|
|
separator: Separator::Comma,
|
|
commands: vec![HlwmCommand::Reload, HlwmCommand::Quit],
|
|
},
|
|
"or\t,\treload\t,\tquit".into(),
|
|
),
|
|
HlwmCommand::And {
|
|
separator: _,
|
|
commands: _,
|
|
} => (
|
|
HlwmCommand::And {
|
|
separator: Separator::Period,
|
|
commands: vec![HlwmCommand::Reload, HlwmCommand::Quit],
|
|
},
|
|
"and\t.\treload\t.\tquit".into(),
|
|
),
|
|
HlwmCommand::Compare {
|
|
attribute: _,
|
|
operator: _,
|
|
value: _,
|
|
} => (
|
|
HlwmCommand::Compare {
|
|
attribute: "my_attr".to_string(),
|
|
operator: Operator::Equal,
|
|
value: "my_value".to_string(),
|
|
},
|
|
"compare\tmy_attr\t=\tmy_value".into(),
|
|
),
|
|
HlwmCommand::TagStatus { monitor: _ } => (
|
|
HlwmCommand::TagStatus { monitor: Some(1) },
|
|
"tag_status\t1".into(),
|
|
),
|
|
HlwmCommand::Rule(_) => (
|
|
HlwmCommand::Rule(Rule::new(
|
|
Some(Condition::Class {
|
|
operator: RuleOperator::Equal,
|
|
value: "Netscape".to_string(),
|
|
}),
|
|
vec![Consequence::Tag("6".into()), Consequence::Focus(false)],
|
|
None,
|
|
None,
|
|
)),
|
|
"rule\t--class=Netscape\t--tag=6\t--focus=off".into(),
|
|
),
|
|
HlwmCommand::Get(_) => (
|
|
HlwmCommand::Get(SettingName::AutoDetectMonitors),
|
|
"get\tauto_detect_monitors".into(),
|
|
),
|
|
HlwmCommand::UseIndex {
|
|
index: _,
|
|
skip_visible: _,
|
|
} => (
|
|
HlwmCommand::UseIndex {
|
|
index: Index::Absolute(1),
|
|
skip_visible: true,
|
|
},
|
|
"use_index\t1\t--skip-visible".into(),
|
|
),
|
|
HlwmCommand::UseTag(_) => (HlwmCommand::UseTag("tag".into()), "use\ttag".into()),
|
|
HlwmCommand::MoveTag(_) => (HlwmCommand::MoveTag("tag".into()), "move\ttag".into()),
|
|
HlwmCommand::Try(_) => (
|
|
HlwmCommand::Try(Box::new(HlwmCommand::MergeTag {
|
|
tag: "default".into(),
|
|
target: None,
|
|
})),
|
|
"try\tmerge_tag\tdefault".into(),
|
|
),
|
|
HlwmCommand::Silent(_) => (
|
|
HlwmCommand::Silent(Box::new(HlwmCommand::MergeTag {
|
|
tag: "default".into(),
|
|
target: None,
|
|
})),
|
|
"silent\tmerge_tag\tdefault".into(),
|
|
),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
for (command, expected_string) in commands {
|
|
let actual_string = command.to_command_string();
|
|
assert_eq!(
|
|
expected_string, actual_string,
|
|
"\n1.\n\tExpected [{expected_string}]\n\tGot [{actual_string}]"
|
|
);
|
|
let actual: HlwmCommand = actual_string
|
|
.parse()
|
|
.expect(&format!("\n2.\n\tparsing string: [{actual_string}]"));
|
|
assert_eq!(
|
|
command, actual,
|
|
"\n3.\n\tcomparing commands:\n\t\tleft: [{command:?}]\n\t\tright: [{actual:?}]"
|
|
)
|
|
}
|
|
}
|
|
}
|