Present Servo BGRA hardware surfaces
This commit is contained in:
+760
@@ -0,0 +1,760 @@
|
||||
use crate::SharedString;
|
||||
use anyhow::{Context as _, Result};
|
||||
use std::fmt;
|
||||
|
||||
/// A datastructure for resolving whether an action should be dispatched
|
||||
/// at this point in the element tree. Contains a set of identifiers
|
||||
/// and/or key value pairs representing the current context for the
|
||||
/// keymap.
|
||||
#[derive(Clone, Default, Eq, PartialEq, Hash)]
|
||||
pub struct KeyContext(Vec<ContextEntry>);
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
|
||||
/// An entry in a KeyContext
|
||||
pub struct ContextEntry {
|
||||
/// The key (or name if no value)
|
||||
pub key: SharedString,
|
||||
/// The value
|
||||
pub value: Option<SharedString>,
|
||||
}
|
||||
|
||||
impl<'a> TryFrom<&'a str> for KeyContext {
|
||||
type Error = anyhow::Error;
|
||||
|
||||
fn try_from(value: &'a str) -> Result<Self> {
|
||||
Self::parse(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl KeyContext {
|
||||
/// Initialize a new [`KeyContext`] that contains an `os` key set to either `macos`, `linux`, `windows` or `unknown`.
|
||||
pub fn new_with_defaults() -> Self {
|
||||
let mut context = Self::default();
|
||||
#[cfg(target_os = "macos")]
|
||||
context.set("os", "macos");
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd"))]
|
||||
context.set("os", "linux");
|
||||
#[cfg(target_os = "windows")]
|
||||
context.set("os", "windows");
|
||||
#[cfg(not(any(
|
||||
target_os = "macos",
|
||||
target_os = "linux",
|
||||
target_os = "freebsd",
|
||||
target_os = "windows"
|
||||
)))]
|
||||
context.set("os", "unknown");
|
||||
context
|
||||
}
|
||||
|
||||
/// Returns the primary context entry (usually the name of the component)
|
||||
pub fn primary(&self) -> Option<&ContextEntry> {
|
||||
self.0.iter().find(|p| p.value.is_none())
|
||||
}
|
||||
|
||||
/// Returns everything except the primary context entry.
|
||||
pub fn secondary(&self) -> impl Iterator<Item = &ContextEntry> {
|
||||
let primary = self.primary();
|
||||
self.0.iter().filter(move |&p| Some(p) != primary)
|
||||
}
|
||||
|
||||
/// Parse a key context from a string.
|
||||
/// The key context format is very simple:
|
||||
/// - either a single identifier, such as `StatusBar`
|
||||
/// - or a key value pair, such as `mode = visible`
|
||||
/// - separated by whitespace, such as `StatusBar mode = visible`
|
||||
pub fn parse(source: &str) -> Result<Self> {
|
||||
let mut context = Self::default();
|
||||
let source = skip_whitespace(source);
|
||||
Self::parse_expr(source, &mut context)?;
|
||||
Ok(context)
|
||||
}
|
||||
|
||||
fn parse_expr(mut source: &str, context: &mut Self) -> Result<()> {
|
||||
if source.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let key = source
|
||||
.chars()
|
||||
.take_while(|c| is_identifier_char(*c))
|
||||
.collect::<String>();
|
||||
source = skip_whitespace(&source[key.len()..]);
|
||||
if let Some(suffix) = source.strip_prefix('=') {
|
||||
source = skip_whitespace(suffix);
|
||||
let value = source
|
||||
.chars()
|
||||
.take_while(|c| is_identifier_char(*c))
|
||||
.collect::<String>();
|
||||
source = skip_whitespace(&source[value.len()..]);
|
||||
context.set(key, value);
|
||||
} else {
|
||||
context.add(key);
|
||||
}
|
||||
|
||||
Self::parse_expr(source, context)
|
||||
}
|
||||
|
||||
/// Check if this context is empty.
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.0.is_empty()
|
||||
}
|
||||
|
||||
/// Clear this context.
|
||||
pub fn clear(&mut self) {
|
||||
self.0.clear();
|
||||
}
|
||||
|
||||
/// Extend this context with another context.
|
||||
pub fn extend(&mut self, other: &Self) {
|
||||
for entry in &other.0 {
|
||||
if !self.contains(&entry.key) {
|
||||
self.0.push(entry.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Add an identifier to this context, if it's not already in this context.
|
||||
pub fn add<I: Into<SharedString>>(&mut self, identifier: I) {
|
||||
let key = identifier.into();
|
||||
|
||||
if !self.contains(&key) {
|
||||
self.0.push(ContextEntry { key, value: None })
|
||||
}
|
||||
}
|
||||
|
||||
/// Set a key value pair in this context, if it's not already set.
|
||||
pub fn set<S1: Into<SharedString>, S2: Into<SharedString>>(&mut self, key: S1, value: S2) {
|
||||
let key = key.into();
|
||||
if !self.contains(&key) {
|
||||
self.0.push(ContextEntry {
|
||||
key,
|
||||
value: Some(value.into()),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if this context contains a given identifier or key.
|
||||
pub fn contains(&self, key: &str) -> bool {
|
||||
self.0.iter().any(|entry| entry.key.as_ref() == key)
|
||||
}
|
||||
|
||||
/// Get the associated value for a given identifier or key.
|
||||
pub fn get(&self, key: &str) -> Option<&SharedString> {
|
||||
self.0
|
||||
.iter()
|
||||
.find(|entry| entry.key.as_ref() == key)?
|
||||
.value
|
||||
.as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for KeyContext {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let mut entries = self.0.iter().peekable();
|
||||
while let Some(entry) = entries.next() {
|
||||
if let Some(ref value) = entry.value {
|
||||
write!(f, "{}={}", entry.key, value)?;
|
||||
} else {
|
||||
write!(f, "{}", entry.key)?;
|
||||
}
|
||||
if entries.peek().is_some() {
|
||||
write!(f, " ")?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// A datastructure for resolving whether an action should be dispatched
|
||||
/// Representing a small language for describing which contexts correspond
|
||||
/// to which actions.
|
||||
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum KeyBindingContextPredicate {
|
||||
/// A predicate that will match a given identifier.
|
||||
Identifier(SharedString),
|
||||
/// A predicate that will match a given key-value pair.
|
||||
Equal(SharedString, SharedString),
|
||||
/// A predicate that will match a given key-value pair not being present.
|
||||
NotEqual(SharedString, SharedString),
|
||||
/// A predicate that will match a given predicate appearing below another predicate.
|
||||
/// in the element tree
|
||||
Descendant(
|
||||
Box<KeyBindingContextPredicate>,
|
||||
Box<KeyBindingContextPredicate>,
|
||||
),
|
||||
/// Predicate that will invert another predicate.
|
||||
Not(Box<KeyBindingContextPredicate>),
|
||||
/// A predicate that will match if both of its children match.
|
||||
And(
|
||||
Box<KeyBindingContextPredicate>,
|
||||
Box<KeyBindingContextPredicate>,
|
||||
),
|
||||
/// A predicate that will match if either of its children match.
|
||||
Or(
|
||||
Box<KeyBindingContextPredicate>,
|
||||
Box<KeyBindingContextPredicate>,
|
||||
),
|
||||
}
|
||||
|
||||
impl fmt::Display for KeyBindingContextPredicate {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Identifier(name) => write!(f, "{}", name),
|
||||
Self::Equal(left, right) => write!(f, "{} == {}", left, right),
|
||||
Self::NotEqual(left, right) => write!(f, "{} != {}", left, right),
|
||||
Self::Not(pred) => write!(f, "!{}", pred),
|
||||
Self::Descendant(parent, child) => write!(f, "{} > {}", parent, child),
|
||||
Self::And(left, right) => write!(f, "({} && {})", left, right),
|
||||
Self::Or(left, right) => write!(f, "({} || {})", left, right),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl KeyBindingContextPredicate {
|
||||
/// Parse a string in the same format as the keymap's context field.
|
||||
///
|
||||
/// A basic equivalence check against a set of identifiers can performed by
|
||||
/// simply writing a string:
|
||||
///
|
||||
/// `StatusBar` -> A predicate that will match a context with the identifier `StatusBar`
|
||||
///
|
||||
/// You can also specify a key-value pair:
|
||||
///
|
||||
/// `mode == visible` -> A predicate that will match a context with the key `mode`
|
||||
/// with the value `visible`
|
||||
///
|
||||
/// And a logical operations combining these two checks:
|
||||
///
|
||||
/// `StatusBar && mode == visible` -> A predicate that will match a context with the
|
||||
/// identifier `StatusBar` and the key `mode`
|
||||
/// with the value `visible`
|
||||
///
|
||||
///
|
||||
/// There is also a special child `>` operator that will match a predicate that is
|
||||
/// below another predicate:
|
||||
///
|
||||
/// `StatusBar > mode == visible` -> A predicate that will match a context identifier `StatusBar`
|
||||
/// and a child context that has the key `mode` with the
|
||||
/// value `visible`
|
||||
///
|
||||
/// This syntax supports `!=`, `||` and `&&` as logical operators.
|
||||
/// You can also preface an operation or check with a `!` to negate it.
|
||||
pub fn parse(source: &str) -> Result<Self> {
|
||||
let source = skip_whitespace(source);
|
||||
let (predicate, rest) = Self::parse_expr(source, 0)?;
|
||||
if let Some(next) = rest.chars().next() {
|
||||
anyhow::bail!("unexpected character '{next:?}'");
|
||||
} else {
|
||||
Ok(predicate)
|
||||
}
|
||||
}
|
||||
|
||||
/// Find the deepest depth at which the predicate matches.
|
||||
pub fn depth_of(&self, contexts: &[KeyContext]) -> Option<usize> {
|
||||
for depth in (0..=contexts.len()).rev() {
|
||||
let context_slice = &contexts[0..depth];
|
||||
if self.eval_inner(context_slice, contexts) {
|
||||
return Some(depth);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Eval a predicate against a set of contexts, arranged from lowest to highest.
|
||||
#[allow(unused)]
|
||||
pub(crate) fn eval(&self, contexts: &[KeyContext]) -> bool {
|
||||
self.eval_inner(contexts, contexts)
|
||||
}
|
||||
|
||||
/// Eval a predicate against a set of contexts, arranged from lowest to highest.
|
||||
pub fn eval_inner(&self, contexts: &[KeyContext], all_contexts: &[KeyContext]) -> bool {
|
||||
let Some(context) = contexts.last() else {
|
||||
return false;
|
||||
};
|
||||
match self {
|
||||
Self::Identifier(name) => context.contains(name),
|
||||
Self::Equal(left, right) => context
|
||||
.get(left)
|
||||
.map(|value| value == right)
|
||||
.unwrap_or(false),
|
||||
Self::NotEqual(left, right) => context
|
||||
.get(left)
|
||||
.map(|value| value != right)
|
||||
.unwrap_or(true),
|
||||
Self::Not(pred) => {
|
||||
for i in 0..all_contexts.len() {
|
||||
if pred.eval_inner(&all_contexts[..=i], all_contexts) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
// Workspace > Pane > Editor
|
||||
//
|
||||
// Pane > (Pane > Editor) // should match?
|
||||
// (Pane > Pane) > Editor // should not match?
|
||||
// Pane > !Workspace <-- should match?
|
||||
// !Workspace <-- shouldn't match?
|
||||
Self::Descendant(parent, child) => {
|
||||
for i in 0..contexts.len() - 1 {
|
||||
// [Workspace > Pane], [Editor]
|
||||
if parent.eval_inner(&contexts[..=i], all_contexts) {
|
||||
if !child.eval_inner(&contexts[i + 1..], &contexts[i + 1..]) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
Self::And(left, right) => {
|
||||
left.eval_inner(contexts, all_contexts) && right.eval_inner(contexts, all_contexts)
|
||||
}
|
||||
Self::Or(left, right) => {
|
||||
left.eval_inner(contexts, all_contexts) || right.eval_inner(contexts, all_contexts)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether or not this predicate matches all possible contexts matched by
|
||||
/// the other predicate.
|
||||
pub fn is_superset(&self, other: &Self) -> bool {
|
||||
if self == other {
|
||||
return true;
|
||||
}
|
||||
|
||||
if let KeyBindingContextPredicate::Or(left, right) = self {
|
||||
return left.is_superset(other) || right.is_superset(other);
|
||||
}
|
||||
|
||||
match other {
|
||||
KeyBindingContextPredicate::Descendant(_, child) => self.is_superset(child),
|
||||
KeyBindingContextPredicate::And(left, right) => {
|
||||
self.is_superset(left) || self.is_superset(right)
|
||||
}
|
||||
KeyBindingContextPredicate::Identifier(_) => false,
|
||||
KeyBindingContextPredicate::Equal(_, _) => false,
|
||||
KeyBindingContextPredicate::NotEqual(_, _) => false,
|
||||
KeyBindingContextPredicate::Not(_) => false,
|
||||
KeyBindingContextPredicate::Or(_, _) => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_expr(mut source: &str, min_precedence: u32) -> anyhow::Result<(Self, &str)> {
|
||||
type Op = fn(
|
||||
KeyBindingContextPredicate,
|
||||
KeyBindingContextPredicate,
|
||||
) -> Result<KeyBindingContextPredicate>;
|
||||
|
||||
let (mut predicate, rest) = Self::parse_primary(source)?;
|
||||
source = rest;
|
||||
|
||||
'parse: loop {
|
||||
for (operator, precedence, constructor) in [
|
||||
(">", PRECEDENCE_CHILD, Self::new_child as Op),
|
||||
("&&", PRECEDENCE_AND, Self::new_and as Op),
|
||||
("||", PRECEDENCE_OR, Self::new_or as Op),
|
||||
("==", PRECEDENCE_EQ, Self::new_eq as Op),
|
||||
("!=", PRECEDENCE_EQ, Self::new_neq as Op),
|
||||
] {
|
||||
if source.starts_with(operator) && precedence >= min_precedence {
|
||||
source = skip_whitespace(&source[operator.len()..]);
|
||||
let (right, rest) = Self::parse_expr(source, precedence + 1)?;
|
||||
predicate = constructor(predicate, right)?;
|
||||
source = rest;
|
||||
continue 'parse;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
Ok((predicate, source))
|
||||
}
|
||||
|
||||
fn parse_primary(mut source: &str) -> anyhow::Result<(Self, &str)> {
|
||||
let next = source.chars().next().context("unexpected end")?;
|
||||
match next {
|
||||
'(' => {
|
||||
source = skip_whitespace(&source[1..]);
|
||||
let (predicate, rest) = Self::parse_expr(source, 0)?;
|
||||
let stripped = rest.strip_prefix(')').context("expected a ')'")?;
|
||||
source = skip_whitespace(stripped);
|
||||
Ok((predicate, source))
|
||||
}
|
||||
'!' => {
|
||||
let source = skip_whitespace(&source[1..]);
|
||||
let (predicate, source) = Self::parse_expr(source, PRECEDENCE_NOT)?;
|
||||
Ok((KeyBindingContextPredicate::Not(Box::new(predicate)), source))
|
||||
}
|
||||
_ if is_identifier_char(next) => {
|
||||
let len = source
|
||||
.find(|c: char| !is_identifier_char(c) && !is_vim_operator_char(c))
|
||||
.unwrap_or(source.len());
|
||||
let (identifier, rest) = source.split_at(len);
|
||||
source = skip_whitespace(rest);
|
||||
Ok((
|
||||
KeyBindingContextPredicate::Identifier(identifier.to_string().into()),
|
||||
source,
|
||||
))
|
||||
}
|
||||
_ if is_vim_operator_char(next) => {
|
||||
let (operator, rest) = source.split_at(1);
|
||||
source = skip_whitespace(rest);
|
||||
Ok((
|
||||
KeyBindingContextPredicate::Identifier(operator.to_string().into()),
|
||||
source,
|
||||
))
|
||||
}
|
||||
_ => anyhow::bail!("unexpected character '{next:?}'"),
|
||||
}
|
||||
}
|
||||
|
||||
fn new_or(self, other: Self) -> Result<Self> {
|
||||
Ok(Self::Or(Box::new(self), Box::new(other)))
|
||||
}
|
||||
|
||||
fn new_and(self, other: Self) -> Result<Self> {
|
||||
Ok(Self::And(Box::new(self), Box::new(other)))
|
||||
}
|
||||
|
||||
fn new_child(self, other: Self) -> Result<Self> {
|
||||
Ok(Self::Descendant(Box::new(self), Box::new(other)))
|
||||
}
|
||||
|
||||
fn new_eq(self, other: Self) -> Result<Self> {
|
||||
if let (Self::Identifier(left), Self::Identifier(right)) = (self, other) {
|
||||
Ok(Self::Equal(left, right))
|
||||
} else {
|
||||
anyhow::bail!("operands of == must be identifiers");
|
||||
}
|
||||
}
|
||||
|
||||
fn new_neq(self, other: Self) -> Result<Self> {
|
||||
if let (Self::Identifier(left), Self::Identifier(right)) = (self, other) {
|
||||
Ok(Self::NotEqual(left, right))
|
||||
} else {
|
||||
anyhow::bail!("operands of != must be identifiers");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const PRECEDENCE_CHILD: u32 = 1;
|
||||
const PRECEDENCE_OR: u32 = 2;
|
||||
const PRECEDENCE_AND: u32 = 3;
|
||||
const PRECEDENCE_EQ: u32 = 4;
|
||||
const PRECEDENCE_NOT: u32 = 5;
|
||||
|
||||
fn is_identifier_char(c: char) -> bool {
|
||||
c.is_alphanumeric() || c == '_' || c == '-'
|
||||
}
|
||||
|
||||
fn is_vim_operator_char(c: char) -> bool {
|
||||
c == '>' || c == '<' || c == '~' || c == '"' || c == '?'
|
||||
}
|
||||
|
||||
fn skip_whitespace(source: &str) -> &str {
|
||||
let len = source
|
||||
.find(|c: char| !c.is_whitespace())
|
||||
.unwrap_or(source.len());
|
||||
&source[len..]
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use core::slice;
|
||||
|
||||
use super::*;
|
||||
use crate as gpui;
|
||||
use KeyBindingContextPredicate::*;
|
||||
|
||||
#[test]
|
||||
fn test_actions_definition() {
|
||||
{
|
||||
actions!(test_only, [A, B, C, D, E, F, G]);
|
||||
}
|
||||
|
||||
{
|
||||
actions!(
|
||||
test_only,
|
||||
[
|
||||
H, I, J, K, L, M, N, // Don't wrap, test the trailing comma
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_context() {
|
||||
let mut expected = KeyContext::default();
|
||||
expected.add("baz");
|
||||
expected.set("foo", "bar");
|
||||
assert_eq!(KeyContext::parse("baz foo=bar").unwrap(), expected);
|
||||
assert_eq!(KeyContext::parse("baz foo = bar").unwrap(), expected);
|
||||
assert_eq!(
|
||||
KeyContext::parse(" baz foo = bar baz").unwrap(),
|
||||
expected
|
||||
);
|
||||
assert_eq!(KeyContext::parse(" baz foo = bar").unwrap(), expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_identifiers() {
|
||||
// Identifiers
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("abc12").unwrap(),
|
||||
Identifier("abc12".into())
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("_1a").unwrap(),
|
||||
Identifier("_1a".into())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_negations() {
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("!abc").unwrap(),
|
||||
Not(Box::new(Identifier("abc".into())))
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse(" ! ! abc").unwrap(),
|
||||
Not(Box::new(Not(Box::new(Identifier("abc".into())))))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_equality_operators() {
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("a == b").unwrap(),
|
||||
Equal("a".into(), "b".into())
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("c!=d").unwrap(),
|
||||
NotEqual("c".into(), "d".into())
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("c == !d")
|
||||
.unwrap_err()
|
||||
.to_string(),
|
||||
"operands of == must be identifiers"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_boolean_operators() {
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("a || b").unwrap(),
|
||||
Or(
|
||||
Box::new(Identifier("a".into())),
|
||||
Box::new(Identifier("b".into()))
|
||||
)
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("a || !b && c").unwrap(),
|
||||
Or(
|
||||
Box::new(Identifier("a".into())),
|
||||
Box::new(And(
|
||||
Box::new(Not(Box::new(Identifier("b".into())))),
|
||||
Box::new(Identifier("c".into()))
|
||||
))
|
||||
)
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("a && b || c&&d").unwrap(),
|
||||
Or(
|
||||
Box::new(And(
|
||||
Box::new(Identifier("a".into())),
|
||||
Box::new(Identifier("b".into()))
|
||||
)),
|
||||
Box::new(And(
|
||||
Box::new(Identifier("c".into())),
|
||||
Box::new(Identifier("d".into()))
|
||||
))
|
||||
)
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("a == b && c || d == e && f").unwrap(),
|
||||
Or(
|
||||
Box::new(And(
|
||||
Box::new(Equal("a".into(), "b".into())),
|
||||
Box::new(Identifier("c".into()))
|
||||
)),
|
||||
Box::new(And(
|
||||
Box::new(Equal("d".into(), "e".into())),
|
||||
Box::new(Identifier("f".into()))
|
||||
))
|
||||
)
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("a && b && c && d").unwrap(),
|
||||
And(
|
||||
Box::new(And(
|
||||
Box::new(And(
|
||||
Box::new(Identifier("a".into())),
|
||||
Box::new(Identifier("b".into()))
|
||||
)),
|
||||
Box::new(Identifier("c".into())),
|
||||
)),
|
||||
Box::new(Identifier("d".into()))
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_parenthesized_expressions() {
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse("a && (b == c || d != e)").unwrap(),
|
||||
And(
|
||||
Box::new(Identifier("a".into())),
|
||||
Box::new(Or(
|
||||
Box::new(Equal("b".into(), "c".into())),
|
||||
Box::new(NotEqual("d".into(), "e".into())),
|
||||
)),
|
||||
),
|
||||
);
|
||||
assert_eq!(
|
||||
KeyBindingContextPredicate::parse(" ( a || b ) ").unwrap(),
|
||||
Or(
|
||||
Box::new(Identifier("a".into())),
|
||||
Box::new(Identifier("b".into())),
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_superset() {
|
||||
assert_is_superset("editor", "editor", true);
|
||||
assert_is_superset("editor", "workspace", false);
|
||||
|
||||
assert_is_superset("editor", "editor && vim_mode", true);
|
||||
assert_is_superset("editor", "mode == full && editor", true);
|
||||
assert_is_superset("editor && mode == full", "editor", false);
|
||||
|
||||
assert_is_superset("editor", "something > editor", true);
|
||||
assert_is_superset("editor", "editor > menu", false);
|
||||
|
||||
assert_is_superset("foo || bar || baz", "bar", true);
|
||||
assert_is_superset("foo || bar || baz", "quux", false);
|
||||
|
||||
#[track_caller]
|
||||
fn assert_is_superset(a: &str, b: &str, result: bool) {
|
||||
let a = KeyBindingContextPredicate::parse(a).unwrap();
|
||||
let b = KeyBindingContextPredicate::parse(b).unwrap();
|
||||
assert_eq!(a.is_superset(&b), result, "({a:?}).is_superset({b:?})");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_child_operator() {
|
||||
let predicate = KeyBindingContextPredicate::parse("parent > child").unwrap();
|
||||
|
||||
let parent_context = KeyContext::try_from("parent").unwrap();
|
||||
let child_context = KeyContext::try_from("child").unwrap();
|
||||
|
||||
let contexts = vec![parent_context.clone(), child_context.clone()];
|
||||
assert!(predicate.eval(&contexts));
|
||||
|
||||
let grandparent_context = KeyContext::try_from("grandparent").unwrap();
|
||||
|
||||
let contexts = vec![
|
||||
grandparent_context,
|
||||
parent_context.clone(),
|
||||
child_context.clone(),
|
||||
];
|
||||
assert!(predicate.eval(&contexts));
|
||||
|
||||
let other_context = KeyContext::try_from("other").unwrap();
|
||||
|
||||
let contexts = vec![other_context.clone(), child_context.clone()];
|
||||
assert!(!predicate.eval(&contexts));
|
||||
|
||||
let contexts = vec![parent_context.clone(), other_context, child_context.clone()];
|
||||
assert!(predicate.eval(&contexts));
|
||||
|
||||
assert!(!predicate.eval(&[]));
|
||||
assert!(!predicate.eval(slice::from_ref(&child_context)));
|
||||
assert!(!predicate.eval(&[parent_context]));
|
||||
|
||||
let zany_predicate = KeyBindingContextPredicate::parse("child > child").unwrap();
|
||||
assert!(!zany_predicate.eval(slice::from_ref(&child_context)));
|
||||
assert!(zany_predicate.eval(&[child_context.clone(), child_context]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_not_operator() {
|
||||
let not_predicate = KeyBindingContextPredicate::parse("!editor").unwrap();
|
||||
let editor_context = KeyContext::try_from("editor").unwrap();
|
||||
let workspace_context = KeyContext::try_from("workspace").unwrap();
|
||||
let parent_context = KeyContext::try_from("parent").unwrap();
|
||||
let child_context = KeyContext::try_from("child").unwrap();
|
||||
|
||||
assert!(not_predicate.eval(slice::from_ref(&workspace_context)));
|
||||
assert!(!not_predicate.eval(slice::from_ref(&editor_context)));
|
||||
assert!(!not_predicate.eval(&[editor_context.clone(), workspace_context.clone()]));
|
||||
assert!(!not_predicate.eval(&[workspace_context.clone(), editor_context.clone()]));
|
||||
|
||||
let complex_not = KeyBindingContextPredicate::parse("!editor && workspace").unwrap();
|
||||
assert!(complex_not.eval(slice::from_ref(&workspace_context)));
|
||||
assert!(!complex_not.eval(&[editor_context.clone(), workspace_context.clone()]));
|
||||
|
||||
let not_mode_predicate = KeyBindingContextPredicate::parse("!(mode == full)").unwrap();
|
||||
let mut mode_context = KeyContext::default();
|
||||
mode_context.set("mode", "full");
|
||||
assert!(!not_mode_predicate.eval(&[mode_context.clone()]));
|
||||
|
||||
let mut other_mode_context = KeyContext::default();
|
||||
other_mode_context.set("mode", "partial");
|
||||
assert!(not_mode_predicate.eval(&[other_mode_context]));
|
||||
|
||||
let not_descendant = KeyBindingContextPredicate::parse("!(parent > child)").unwrap();
|
||||
assert!(not_descendant.eval(slice::from_ref(&parent_context)));
|
||||
assert!(not_descendant.eval(slice::from_ref(&child_context)));
|
||||
assert!(!not_descendant.eval(&[parent_context.clone(), child_context.clone()]));
|
||||
|
||||
let not_descendant = KeyBindingContextPredicate::parse("parent > !child").unwrap();
|
||||
assert!(!not_descendant.eval(slice::from_ref(&parent_context)));
|
||||
assert!(!not_descendant.eval(slice::from_ref(&child_context)));
|
||||
assert!(!not_descendant.eval(&[parent_context, child_context]));
|
||||
|
||||
let double_not = KeyBindingContextPredicate::parse("!!editor").unwrap();
|
||||
assert!(double_not.eval(slice::from_ref(&editor_context)));
|
||||
assert!(!double_not.eval(slice::from_ref(&workspace_context)));
|
||||
|
||||
// Test complex descendant cases
|
||||
let workspace_context = KeyContext::try_from("Workspace").unwrap();
|
||||
let pane_context = KeyContext::try_from("Pane").unwrap();
|
||||
let editor_context = KeyContext::try_from("Editor").unwrap();
|
||||
|
||||
// Workspace > Pane > Editor
|
||||
let workspace_pane_editor = vec![
|
||||
workspace_context.clone(),
|
||||
pane_context.clone(),
|
||||
editor_context.clone(),
|
||||
];
|
||||
|
||||
// Pane > (Pane > Editor) - should not match
|
||||
let pane_pane_editor = KeyBindingContextPredicate::parse("Pane > (Pane > Editor)").unwrap();
|
||||
assert!(!pane_pane_editor.eval(&workspace_pane_editor));
|
||||
|
||||
let workspace_pane_editor_predicate =
|
||||
KeyBindingContextPredicate::parse("Workspace > Pane > Editor").unwrap();
|
||||
assert!(workspace_pane_editor_predicate.eval(&workspace_pane_editor));
|
||||
|
||||
// (Pane > Pane) > Editor - should not match
|
||||
let pane_pane_then_editor =
|
||||
KeyBindingContextPredicate::parse("(Pane > Pane) > Editor").unwrap();
|
||||
assert!(!pane_pane_then_editor.eval(&workspace_pane_editor));
|
||||
|
||||
// Pane > !Workspace - should match
|
||||
let pane_not_workspace = KeyBindingContextPredicate::parse("Pane > !Workspace").unwrap();
|
||||
assert!(pane_not_workspace.eval(&[pane_context.clone(), editor_context.clone()]));
|
||||
assert!(!pane_not_workspace.eval(&[pane_context.clone(), workspace_context.clone()]));
|
||||
|
||||
// !Workspace - shouldn't match when Workspace is in the context
|
||||
let not_workspace = KeyBindingContextPredicate::parse("!Workspace").unwrap();
|
||||
assert!(!not_workspace.eval(slice::from_ref(&workspace_context)));
|
||||
assert!(not_workspace.eval(slice::from_ref(&pane_context)));
|
||||
assert!(not_workspace.eval(slice::from_ref(&editor_context)));
|
||||
assert!(!not_workspace.eval(&workspace_pane_editor));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user