use ratatui::style::{Color, Modifier, Style};
use ratatui::widgets::{BorderType, Borders};
pub fn shell_split(s: &str) -> Vec<String> {
let mut out = Vec::new();
let mut cur = String::new();
let mut started = false; let mut quote: Option<char> = None;
let mut chars = s.chars();
while let Some(c) = chars.next() {
match quote {
Some('\'') if c == '\'' => quote = None,
Some('\'') => cur.push(c),
Some('"') if c == '"' => quote = None,
Some('"') if c == '\\' => match chars.next() {
Some(n @ ('"' | '\\' | '$' | '`')) => cur.push(n),
Some(n) => {
cur.push('\\');
cur.push(n);
}
None => cur.push('\\'),
},
Some('"') => cur.push(c),
Some(_) => unreachable!("quote is only ever ' or \""),
None => match c {
'\'' | '"' => {
started = true;
quote = Some(c);
}
'\\' => {
started = true;
if let Some(n) = chars.next() {
cur.push(n);
}
}
c if c.is_whitespace() => {
if started {
out.push(std::mem::take(&mut cur));
started = false;
}
}
_ => {
started = true;
cur.push(c);
}
},
}
}
if started {
out.push(cur);
}
out
}
pub fn env_args() -> Vec<String> {
let mut out = Vec::new();
if let Ok(path) = std::env::var("FZF_DEFAULT_OPTS_FILE") {
let path = match (path.strip_prefix("~/"), std::env::var("HOME")) {
(Some(rest), Ok(home)) => format!("{home}/{rest}"),
_ => path,
};
if let Ok(body) = std::fs::read_to_string(path) {
out.extend(shell_split(&body));
}
}
if let Ok(opts) = std::env::var("FZF_DEFAULT_OPTS") {
out.extend(shell_split(&opts));
}
out
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Ent {
pub color: Option<Color>,
pub attrs: Modifier,
}
impl Ent {
fn c(idx: u8) -> Self {
Ent {
color: Some(Color::Indexed(idx)),
attrs: Modifier::empty(),
}
}
fn b(idx: u8) -> Self {
Ent {
color: Some(Color::Indexed(idx)),
attrs: Modifier::BOLD,
}
}
fn attr(attrs: Modifier) -> Self {
Ent { color: None, attrs }
}
pub fn fg(self) -> Style {
let s = Style::default().add_modifier(self.attrs);
match self.color {
Some(c) => s.fg(c),
None => s,
}
}
pub fn bg(self) -> Style {
match self.color {
Some(c) => Style::default().bg(c),
None => Style::default(),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Colors {
pub fg: Ent,
pub bg: Ent,
pub hl: Ent,
pub fg_plus: Ent,
pub bg_plus: Ent,
pub hl_plus: Ent,
pub gutter: Ent,
pub pointer: Ent,
pub marker: Ent,
pub prompt: Ent,
pub query: Ent,
pub info: Ent,
pub spinner: Ent,
pub header: Ent,
pub border: Ent,
pub separator: Ent,
pub scrollbar: Ent,
}
impl Default for Colors {
fn default() -> Self {
Colors::dark()
}
}
impl Colors {
pub fn dark() -> Self {
Colors {
fg: Ent::default(),
bg: Ent::default(),
hl: Ent::c(108),
fg_plus: Ent::b(254),
bg_plus: Ent::c(236),
hl_plus: Ent::b(151),
gutter: Ent::c(236),
pointer: Ent::b(161),
marker: Ent::c(168),
prompt: Ent::b(110),
query: Ent::attr(Modifier::BOLD),
info: Ent::c(144),
spinner: Ent::b(148),
header: Ent::c(109),
border: Ent::c(59),
separator: Ent::c(59),
scrollbar: Ent::c(59),
}
}
pub fn light() -> Self {
Colors {
hl: Ent::c(66),
fg_plus: Ent::b(237),
bg_plus: Ent::c(251),
hl_plus: Ent::b(23),
gutter: Ent::c(251),
pointer: Ent::b(161),
marker: Ent::c(168),
prompt: Ent::b(25),
info: Ent::c(101),
border: Ent::c(145),
separator: Ent::c(145),
scrollbar: Ent::c(145),
..Colors::dark()
}
}
pub fn base16() -> Self {
Colors {
hl: Ent {
color: Some(Color::Green),
attrs: Modifier::empty(),
},
fg_plus: Ent {
color: Some(Color::White),
attrs: Modifier::BOLD,
},
bg_plus: Ent {
color: Some(Color::DarkGray),
attrs: Modifier::empty(),
},
hl_plus: Ent {
color: Some(Color::LightGreen),
attrs: Modifier::BOLD,
},
gutter: Ent {
color: Some(Color::DarkGray),
attrs: Modifier::empty(),
},
pointer: Ent {
color: Some(Color::Red),
attrs: Modifier::BOLD,
},
marker: Ent {
color: Some(Color::Magenta),
attrs: Modifier::empty(),
},
prompt: Ent {
color: Some(Color::Blue),
attrs: Modifier::BOLD,
},
info: Ent {
color: Some(Color::Yellow),
attrs: Modifier::empty(),
},
border: Ent::attr(Modifier::DIM),
separator: Ent::attr(Modifier::DIM),
scrollbar: Ent::attr(Modifier::DIM),
..Colors::dark()
}
}
pub fn bw() -> Self {
Colors {
fg: Ent::default(),
bg: Ent::default(),
hl: Ent::attr(Modifier::UNDERLINED),
fg_plus: Ent::attr(Modifier::BOLD),
bg_plus: Ent::default(),
hl_plus: Ent::attr(Modifier::BOLD | Modifier::UNDERLINED),
gutter: Ent::default(),
pointer: Ent::attr(Modifier::BOLD),
marker: Ent::attr(Modifier::BOLD),
prompt: Ent::default(),
query: Ent::attr(Modifier::BOLD),
info: Ent::default(),
spinner: Ent::default(),
header: Ent::default(),
border: Ent::default(),
separator: Ent::default(),
scrollbar: Ent::default(),
}
}
fn scheme(name: &str) -> Option<Self> {
match name {
"dark" => Some(Colors::dark()),
"light" => Some(Colors::light()),
"16" | "base16" => Some(Colors::base16()),
"bw" | "no" => Some(Colors::bw()),
_ => None,
}
}
fn set(&mut self, name: &str, ent: Ent) {
match name {
"fg" | "list-fg" => self.fg = ent,
"bg" | "list-bg" => self.bg = ent,
"hl" => self.hl = ent,
"fg+" | "current-fg" | "selected-fg" => self.fg_plus = ent,
"bg+" | "current-bg" | "selected-bg" => self.bg_plus = ent,
"hl+" | "current-hl" | "selected-hl" => self.hl_plus = ent,
"gutter" => self.gutter = ent,
"pointer" => self.pointer = ent,
"marker" => self.marker = ent,
"prompt" => self.prompt = ent,
"query" | "input-fg" => self.query = ent,
"info" => self.info = ent,
"spinner" => self.spinner = ent,
"header" => self.header = ent,
"border" => {
self.border = ent;
self.separator = ent;
}
"separator" => self.separator = ent,
_ => {}
}
}
}
fn parse_color(tok: &str) -> Option<Option<Color>> {
if tok == "-1" || tok == "default" {
return Some(None);
}
if let Some(hex) = tok.strip_prefix('#') {
if hex.len() == 6 {
let n = u32::from_str_radix(hex, 16).ok()?;
return Some(Some(Color::Rgb((n >> 16) as u8, (n >> 8) as u8, n as u8)));
}
return None;
}
if let Ok(idx) = tok.parse::<u8>() {
return Some(Some(Color::Indexed(idx)));
}
let named = match tok {
"black" => Color::Black,
"red" => Color::Red,
"green" => Color::Green,
"yellow" => Color::Yellow,
"blue" => Color::Blue,
"magenta" => Color::Magenta,
"cyan" => Color::Cyan,
"white" => Color::Gray,
"bright-black" | "gray" | "grey" => Color::DarkGray,
"bright-red" => Color::LightRed,
"bright-green" => Color::LightGreen,
"bright-yellow" => Color::LightYellow,
"bright-blue" => Color::LightBlue,
"bright-magenta" => Color::LightMagenta,
"bright-cyan" => Color::LightCyan,
"bright-white" => Color::White,
_ => return None,
};
Some(Some(named))
}
fn parse_attr(tok: &str) -> Option<Modifier> {
match tok {
"bold" => Some(Modifier::BOLD),
"dim" => Some(Modifier::DIM),
"italic" => Some(Modifier::ITALIC),
"underline" => Some(Modifier::UNDERLINED),
"blink" => Some(Modifier::SLOW_BLINK),
"reverse" => Some(Modifier::REVERSED),
"strikethrough" => Some(Modifier::CROSSED_OUT),
"regular" => Some(Modifier::empty()),
_ => None,
}
}
fn apply_color_spec(colors: &mut Colors, spec: &str) {
for entry in spec.split([',', ' ', '\t']).filter(|e| !e.is_empty()) {
let mut parts = entry.split(':');
let Some(name) = parts.next() else { continue };
if let Some(scheme) = Colors::scheme(name) {
*colors = scheme;
continue;
}
let mut ent = Ent::default();
let mut saw = false;
for tok in parts {
if let Some(c) = parse_color(tok) {
ent.color = c;
saw = true;
} else if let Some(a) = parse_attr(tok) {
ent.attrs |= a;
saw = true;
}
}
if saw {
colors.set(name, ent);
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Nth {
pub begin: i32,
pub end: i32,
}
impl Nth {
pub const ELLIPSIS: i32 = i32::MIN;
pub fn parse(s: &str) -> Option<Nth> {
let n = |v: &str| v.parse::<i32>().ok().filter(|n| *n != 0);
if s == ".." {
return Some(Nth {
begin: Nth::ELLIPSIS,
end: Nth::ELLIPSIS,
});
}
if let Some(rest) = s.strip_prefix("..") {
return n(rest).map(|end| Nth {
begin: Nth::ELLIPSIS,
end,
});
}
if let Some(rest) = s.strip_suffix("..") {
return n(rest).map(|begin| Nth {
begin,
end: Nth::ELLIPSIS,
});
}
if let Some((a, b)) = s.split_once("..") {
let (begin, end) = (n(a)?, n(b)?);
return (!(begin < 0 && end > 0)).then_some(Nth { begin, end });
}
n(s).map(|v| Nth { begin: v, end: v })
}
pub fn parse_list(s: &str) -> Vec<Nth> {
let mut out = Vec::new();
for part in s.split(',').filter(|p| !p.is_empty()) {
match Nth::parse(part) {
Some(r) => out.push(r),
None => return Vec::new(),
}
}
out
}
}
pub fn tokenize<'a>(text: &'a str, delimiter: Option<&str>) -> Vec<&'a str> {
let Some(d) = delimiter else {
let mut out = Vec::new();
let bytes = text.as_bytes();
let (mut start, mut i) = (0usize, 0usize);
while i < bytes.len() && (bytes[i] == b' ' || bytes[i] == b'\t') {
i += 1;
}
start = start.max(i);
while i < bytes.len() {
while i < bytes.len() && bytes[i] != b' ' && bytes[i] != b'\t' {
i += 1;
}
while i < bytes.len() && (bytes[i] == b' ' || bytes[i] == b'\t') {
i += 1;
}
out.push(&text[start..i]);
start = i;
}
return out;
};
if d.is_empty() {
return vec![text];
}
let mut out = Vec::new();
let mut rest = text;
while let Some(pos) = rest.find(d) {
let (head, tail) = rest.split_at(pos + d.len());
out.push(head);
rest = tail;
}
if !rest.is_empty() {
out.push(rest);
}
out
}
pub fn transform(tokens: &[&str], ranges: &[Nth], delimiter: Option<&str>) -> String {
if ranges.is_empty() {
return tokens.concat();
}
let mut out = String::new();
for r in ranges {
let part = transform_join(tokens, std::slice::from_ref(r));
match delimiter {
Some(d) => out.push_str(part.strip_suffix(d).unwrap_or(&part)),
None => out.push_str(&part),
}
}
out
}
pub fn transform_join(tokens: &[&str], ranges: &[Nth]) -> String {
if ranges.is_empty() {
return tokens.concat();
}
let n = tokens.len() as i32;
let resolve = |v: i32| if v < 0 { v + n + 1 } else { v };
let mut out = String::new();
for r in ranges {
let (begin, end) = match (r.begin, r.end) {
(Nth::ELLIPSIS, Nth::ELLIPSIS) => (1, n),
(Nth::ELLIPSIS, e) => (1, resolve(e)),
(b, Nth::ELLIPSIS) => (resolve(b), n),
(b, e) => (resolve(b), resolve(e)),
};
for idx in begin.max(1)..=end.min(n) {
out.push_str(tokens[(idx - 1) as usize]);
}
}
out
}
pub fn strip_ansi(s: &str) -> String {
if !s.contains('\u{1b}') {
return s.to_string();
}
let mut out = String::with_capacity(s.len());
let mut chars = s.chars();
while let Some(c) = chars.next() {
if c != '\u{1b}' {
out.push(c);
continue;
}
if chars.next() != Some('[') {
continue;
}
for t in chars.by_ref() {
if t.is_ascii_alphabetic() {
break;
}
}
}
out
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Layout {
Default,
Reverse,
ReverseList,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Info {
Default,
Right,
Hidden,
Inline(String),
InlineRight(String),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PreviewPos {
Up,
Down,
Left,
Right,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PreviewSize {
Percent(u16),
Cells(u16),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ScrollBase {
Line(i64),
Field(Vec<Nth>),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PreviewScroll {
pub base: ScrollBase,
pub offset: i64,
pub denom: usize,
}
impl PreviewScroll {
fn parse(spec: &str) -> Option<PreviewScroll> {
let (spec, denom) = match spec.split_once('/') {
Some((s, d)) => (s, d.parse::<usize>().ok()?),
None => (spec, 0),
};
let (base, mut rest) = match spec.strip_prefix('{') {
Some(r) => {
let (inner, tail) = r.split_once('}')?;
(ScrollBase::Field(Nth::parse_list(inner)), tail)
}
None => {
let end = spec
.find(|c: char| !c.is_ascii_digit())
.unwrap_or(spec.len());
(ScrollBase::Line(spec[..end].parse().ok()?), &spec[end..])
}
};
if matches!(&base, ScrollBase::Field(n) if n.is_empty()) {
return None;
}
let mut offset = 0i64;
while !rest.is_empty() {
let sign = match rest.as_bytes()[0] {
b'+' => 1,
b'-' => -1,
_ => return None,
};
let end = rest[1..]
.find(|c: char| !c.is_ascii_digit())
.map_or(rest.len(), |i| i + 1);
offset += sign * rest[1..end].parse::<i64>().ok()?;
rest = &rest[end..];
}
Some(PreviewScroll {
base,
offset,
denom,
})
}
pub fn target(&self, line: &str, delimiter: Option<&str>) -> Option<i64> {
let base = match &self.base {
ScrollBase::Line(n) => *n,
ScrollBase::Field(nth) => {
let tokens = tokenize(line, delimiter);
let field = strip_last_delimiter(&transform_join(&tokens, nth), delimiter);
field.trim().parse::<i64>().ok()?
}
};
Some(base + self.offset)
}
pub fn top(&self, target: i64, rows: usize) -> usize {
let above = rows.checked_div(self.denom).unwrap_or(0) as i64;
(target - 1 - above).max(0) as usize
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PreviewWindow {
pub pos: PreviewPos,
pub size: PreviewSize,
pub hidden: bool,
pub wrap: bool,
pub scroll: Option<PreviewScroll>,
}
impl Default for PreviewWindow {
fn default() -> Self {
Self {
pos: PreviewPos::Right,
size: PreviewSize::Percent(50),
hidden: false,
wrap: false,
scroll: None,
}
}
}
impl PreviewWindow {
pub fn parse(spec: &str) -> PreviewWindow {
let mut w = PreviewWindow::default();
w.apply(spec);
w
}
pub fn apply(&mut self, spec: &str) {
let w = self;
for part in spec.split([',', ':']).map(str::trim) {
match part {
"" => {}
"up" | "top" => w.pos = PreviewPos::Up,
"down" | "bottom" => w.pos = PreviewPos::Down,
"left" => w.pos = PreviewPos::Left,
"right" | "next" => w.pos = PreviewPos::Right,
"hidden" => w.hidden = true,
"nohidden" => w.hidden = false,
"wrap" | "wrap-word" => w.wrap = true,
"nowrap" => w.wrap = false,
_ if part.starts_with('+') => w.scroll = PreviewScroll::parse(&part[1..]),
_ => {
if let Some(n) = part.strip_suffix('%') {
if let Ok(pct) = n.parse::<u16>() {
w.size = PreviewSize::Percent(pct.min(100));
}
} else if let Ok(cells) = part.parse::<u16>() {
w.size = PreviewSize::Cells(cells);
}
}
}
}
}
pub fn split(
&self,
body: ratatui::layout::Rect,
) -> (ratatui::layout::Rect, Option<ratatui::layout::Rect>) {
use ratatui::layout::{Constraint, Layout};
if self.hidden {
return (body, None);
}
let vertical = matches!(self.pos, PreviewPos::Up | PreviewPos::Down);
let total = match vertical {
true => body.height,
false => body.width,
};
let want = match self.size {
PreviewSize::Percent(p) => (u32::from(total) * u32::from(p) / 100) as u16,
PreviewSize::Cells(c) => c,
};
let want = want.min(total.saturating_sub(1));
if want == 0 {
return (body, None);
}
let rest = total - want;
let constraints = match self.pos {
PreviewPos::Up | PreviewPos::Left => {
[Constraint::Length(want), Constraint::Length(rest)]
}
PreviewPos::Down | PreviewPos::Right => {
[Constraint::Length(rest), Constraint::Length(want)]
}
};
let chunks = match vertical {
true => Layout::vertical(constraints).split(body),
false => Layout::horizontal(constraints).split(body),
};
match self.pos {
PreviewPos::Up | PreviewPos::Left => (chunks[1], Some(chunks[0])),
PreviewPos::Down | PreviewPos::Right => (chunks[0], Some(chunks[1])),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Case {
#[default]
Smart,
Ignore,
Respect,
}
#[derive(Clone, Debug)]
pub struct Look {
pub layout: Layout,
pub info: Info,
pub border: Option<(BorderType, Borders)>,
pub pointer: String,
pub marker: String,
pub ellipsis: String,
pub colors: Colors,
pub cycle: bool,
pub tac: bool,
pub ansi: bool,
pub delimiter: Option<String>,
pub nth: Vec<Nth>,
pub with_nth: Vec<Nth>,
pub header_lines: usize,
pub with_shell: Option<String>,
pub print_query: bool,
pub expect: Vec<(Key, String)>,
pub min_height: u16,
pub min_height_plus: bool,
pub scrollbar: bool,
pub scroll_off: usize,
pub tiebreak: Vec<crate::pattern::Criterion>,
pub preview_window: PreviewWindow,
pub binds: Vec<(Key, Vec<Action>)>,
pub case: Case,
pub algo_v1: bool,
pub scheme: crate::algo::Scheme,
pub tail: Option<usize>,
pub read0: bool,
pub print0: bool,
pub accept_nth: Option<AcceptNth>,
pub extended: bool,
}
impl Default for Look {
fn default() -> Self {
Look {
layout: Layout::Default,
info: Info::Default,
border: None,
pointer: "\u{258c}".to_string(),
marker: "\u{2503}".to_string(),
ellipsis: "\u{b7}\u{b7}".to_string(),
colors: Colors::dark(),
cycle: false,
tac: false,
ansi: false,
delimiter: None,
nth: Vec::new(),
with_nth: Vec::new(),
header_lines: 0,
with_shell: None,
print_query: false,
expect: Vec::new(),
min_height: 10,
min_height_plus: true,
scrollbar: true,
scroll_off: 3,
tiebreak: vec![
crate::pattern::Criterion::Score,
crate::pattern::Criterion::Length,
],
preview_window: PreviewWindow::default(),
binds: Vec::new(),
case: Case::Smart,
algo_v1: false,
scheme: crate::algo::Scheme::DEFAULT,
tail: None,
read0: false,
print0: false,
accept_nth: None,
extended: true,
}
}
}
pub fn expand_preview(
template: &str,
line: &str,
delimiter: Option<&str>,
quote: impl Fn(&str) -> String,
) -> String {
let tokens = tokenize(line, delimiter);
let mut out = String::new();
let mut rest = template;
while let Some(open) = rest.find('{') {
out.push_str(&rest[..open]);
let tail = &rest[open..];
let Some(close) = tail.find('}') else { break };
let inner = &tail[1..close];
let is_fields = !inner.is_empty()
&& inner
.chars()
.all(|c| c.is_ascii_digit() || matches!(c, ',' | '-' | '.'));
if inner.is_empty() {
out.push_str("e(line));
} else if is_fields {
let nth = Nth::parse_list(inner);
out.push_str("e(&strip_last_delimiter(
&transform_join(&tokens, &nth),
delimiter,
)));
} else {
out.push_str(&tail[..=close]);
}
rest = &tail[close + 1..];
}
out.push_str(rest);
out
}
#[derive(Clone, Debug, PartialEq)]
pub enum AcceptNth {
Fields(Vec<Nth>),
Template(Vec<AcceptPart>),
}
#[derive(Clone, Debug, PartialEq)]
pub enum AcceptPart {
Literal(String),
Fields(Vec<Nth>),
Index,
}
impl AcceptNth {
pub fn parse(spec: &str) -> Option<AcceptNth> {
if !spec.is_empty()
&& spec
.chars()
.all(|c| c.is_ascii_digit() || matches!(c, ',' | '-' | '.'))
{
let nth = Nth::parse_list(spec);
if !nth.is_empty() {
return Some(AcceptNth::Fields(nth));
}
}
let mut parts = Vec::new();
let mut rest = spec;
let mut saw_placeholder = false;
while let Some(open) = rest.find('{') {
let Some(close) = rest[open..].find('}').map(|i| open + i) else {
break;
};
let inner = &rest[open + 1..close];
let ok = inner == "n"
|| (!inner.is_empty()
&& inner
.chars()
.all(|c| c.is_ascii_digit() || matches!(c, ',' | '-' | '.')));
if !ok {
let (lit, tail) = rest.split_at(close + 1);
parts.push(AcceptPart::Literal(lit.to_string()));
rest = tail;
continue;
}
if open > 0 {
parts.push(AcceptPart::Literal(rest[..open].to_string()));
}
parts.push(match inner {
"n" => AcceptPart::Index,
f => AcceptPart::Fields(Nth::parse_list(f)),
});
saw_placeholder = true;
rest = &rest[close + 1..];
}
if !saw_placeholder {
return None;
}
if !rest.is_empty() {
parts.push(AcceptPart::Literal(rest.to_string()));
}
Some(AcceptNth::Template(parts))
}
pub fn render(&self, line: &str, delimiter: Option<&str>, index: usize) -> String {
let tokens = tokenize(line, delimiter);
match self {
AcceptNth::Fields(nth) => {
strip_last_delimiter(&transform_join(&tokens, nth), delimiter)
}
AcceptNth::Template(parts) => parts
.iter()
.map(|p| match p {
AcceptPart::Literal(s) => s.clone(),
AcceptPart::Index => index.to_string(),
AcceptPart::Fields(nth) => {
strip_last_delimiter(&transform_join(&tokens, nth), delimiter)
}
})
.collect(),
}
}
}
pub fn strip_last_delimiter(s: &str, delimiter: Option<&str>) -> String {
match delimiter {
Some(d) => s.strip_suffix(d).unwrap_or(s).to_string(),
None => s.trim_end().to_string(),
}
}
fn parse_border(style: &str) -> Option<(BorderType, Borders)> {
let all = Borders::ALL;
match style {
"rounded" | "" => Some((BorderType::Rounded, all)),
"sharp" | "block" | "thinblock" => Some((BorderType::Plain, all)),
"bold" | "double" => Some((BorderType::Double, all)),
"horizontal" => Some((BorderType::Plain, Borders::TOP | Borders::BOTTOM)),
"vertical" => Some((BorderType::Plain, Borders::LEFT | Borders::RIGHT)),
"top" | "up" => Some((BorderType::Plain, Borders::TOP)),
"bottom" | "down" => Some((BorderType::Plain, Borders::BOTTOM)),
"left" => Some((BorderType::Plain, Borders::LEFT)),
"right" => Some((BorderType::Plain, Borders::RIGHT)),
"none" => None,
_ => Some((BorderType::Rounded, all)),
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Key {
Ctrl(char),
Alt(char),
Tab,
BTab,
Enter,
Esc,
Up,
Down,
Left,
Right,
PageUp,
PageDown,
Home,
End,
Backspace,
Delete,
Space,
ShiftUp,
ShiftDown,
Char(char),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Action {
Up,
Down,
PageUp,
PageDown,
HalfPageUp,
HalfPageDown,
First,
Last,
Toggle,
ToggleAll,
Accept,
Abort,
ClearQuery,
BackwardDeleteChar,
PreviewUp,
PreviewDown,
PreviewPageUp,
PreviewPageDown,
PreviewHalfPageUp,
PreviewHalfPageDown,
PreviewTop,
PreviewBottom,
Ignore,
}
fn parse_key(name: &str) -> Option<Key> {
let n = name.trim().to_ascii_lowercase();
if let Some(rest) = n.strip_prefix("ctrl-") {
let mut ch = rest.chars();
let c = ch.next()?;
return ch.next().is_none().then_some(Key::Ctrl(c));
}
if let Some(rest) = n.strip_prefix("alt-") {
let mut ch = rest.chars();
let c = ch.next()?;
return ch.next().is_none().then_some(Key::Alt(c));
}
Some(match n.as_str() {
"tab" => Key::Tab,
"btab" | "shift-tab" => Key::BTab,
"enter" | "return" => Key::Enter,
"esc" => Key::Esc,
"up" => Key::Up,
"down" => Key::Down,
"left" => Key::Left,
"right" => Key::Right,
"pgup" | "page-up" => Key::PageUp,
"pgdn" | "page-down" => Key::PageDown,
"home" => Key::Home,
"end" => Key::End,
"bspace" | "bs" | "backspace" => Key::Backspace,
"del" | "delete" => Key::Delete,
"shift-up" => Key::ShiftUp,
"shift-down" => Key::ShiftDown,
"space" => Key::Space,
s if s.chars().count() == 1 => Key::Char(s.chars().next()?),
_ => return None,
})
}
fn parse_action(name: &str) -> Option<Action> {
Some(match name.trim() {
"up" | "prev-history" => Action::Up,
"down" | "next-history" => Action::Down,
"page-up" => Action::PageUp,
"page-down" => Action::PageDown,
"half-page-up" => Action::HalfPageUp,
"half-page-down" => Action::HalfPageDown,
"first" | "top" | "beginning-of-line" => Action::First,
"last" => Action::Last,
"toggle" | "toggle+up" => Action::Toggle,
"toggle-all" | "select-all" | "deselect-all" => Action::ToggleAll,
"accept" | "accept-non-empty" => Action::Accept,
"abort" | "cancel" => Action::Abort,
"clear-query" | "unix-line-discard" | "kill-line" => Action::ClearQuery,
"backward-delete-char" => Action::BackwardDeleteChar,
"preview-up" => Action::PreviewUp,
"preview-down" => Action::PreviewDown,
"preview-page-up" => Action::PreviewPageUp,
"preview-page-down" => Action::PreviewPageDown,
"preview-half-page-up" => Action::PreviewHalfPageUp,
"preview-half-page-down" => Action::PreviewHalfPageDown,
"preview-top" => Action::PreviewTop,
"preview-bottom" => Action::PreviewBottom,
"ignore" => Action::Ignore,
_ => return None,
})
}
fn split_top(s: &str, sep: char) -> Vec<String> {
let mut out = Vec::new();
let mut cur = String::new();
let mut depth = 0i32;
for c in s.chars() {
match c {
'(' => {
depth += 1;
cur.push(c);
}
')' => {
depth -= 1;
cur.push(c);
}
c if c == sep && depth <= 0 => out.push(std::mem::take(&mut cur)),
_ => cur.push(c),
}
}
out.push(cur);
out
}
fn parse_bind_spec(spec: &str) -> Vec<(Key, Vec<Action>)> {
let mut out = Vec::new();
for one in split_top(spec, ',') {
let one = one.trim();
if one.is_empty() {
continue;
}
let Some((keyname, actions)) = one.split_once(':') else {
continue;
};
let Some(key) = parse_key(keyname) else {
continue;
};
let acts: Option<Vec<Action>> = split_top(actions, '+')
.iter()
.map(|a| parse_action(a))
.collect();
if let Some(acts) = acts {
out.push((key, acts));
}
}
out
}
fn flag_value(arg: &str, next: Option<&String>) -> (Option<String>, bool) {
match arg.split_once('=') {
Some((_, v)) => (Some(v.to_string()), false),
None => (next.cloned(), true),
}
}
impl Look {
pub fn parse(args: &[String]) -> Look {
let mut look = Look::default();
if std::env::var_os("NO_COLOR").is_some() {
look.colors = Colors::bw();
}
let mut i = 0;
while i < args.len() {
let a = args[i].as_str();
let key = match a.as_bytes() {
[b'-', b'd', rest @ ..] if !rest.is_empty() => "-d",
[b'-', b'n', rest @ ..] if !rest.is_empty() && rest[0] != b'o' => "-n",
_ => a.split('=').next().unwrap_or(a),
};
let attached = match key {
"-d" | "-n" if a.len() > 2 => Some(a[2..].to_string()),
_ => None,
};
let next = args.get(i + 1);
match key {
"--reverse" => look.layout = Layout::Reverse,
"--no-reverse" => look.layout = Layout::Default,
"--layout" => {
let (v, sep) = flag_value(a, next);
look.layout = match v.as_deref() {
Some("reverse") => Layout::Reverse,
Some("reverse-list") => Layout::ReverseList,
_ => Layout::Default,
};
i += usize::from(sep);
}
"--preview-window" => {
let (v, sep) = flag_value(a, next);
if let Some(spec) = v {
look.preview_window.apply(&spec);
}
i += usize::from(sep);
}
"--border" => {
let style = a.split_once('=').map(|(_, v)| v.to_string());
look.border = parse_border(style.as_deref().unwrap_or("rounded"));
}
"--no-border" => look.border = None,
"--info" => {
let (v, sep) = flag_value(a, next);
look.info = match v.as_deref() {
Some("hidden") => Info::Hidden,
Some("right") => Info::Right,
Some("inline") => Info::Inline(" < ".to_string()),
Some("inline-right") => Info::InlineRight(String::new()),
Some(s) if s.starts_with("inline-right:") => {
Info::InlineRight(s["inline-right:".len()..].to_string())
}
Some(s) if s.starts_with("inline:") => {
Info::Inline(s["inline:".len()..].to_string())
}
_ => Info::Default,
};
i += usize::from(sep);
}
"--no-info" => look.info = Info::Hidden,
"--inline-info" => look.info = Info::Inline(" < ".to_string()),
"--no-inline-info" => look.info = Info::Default,
"--pointer" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
look.pointer = v;
}
i += usize::from(sep);
}
"--marker" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
look.marker = v;
}
i += usize::from(sep);
}
"--ellipsis" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
look.ellipsis = v;
}
i += usize::from(sep);
}
"--color" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
apply_color_spec(&mut look.colors, &v);
}
i += usize::from(sep);
}
"--no-color" => look.colors = Colors::bw(),
"--tiebreak" => {
let (v, sep) = flag_value(a, next);
if let Some(c) = v.as_deref().and_then(crate::pattern::parse_tiebreak) {
look.tiebreak = c;
}
i += usize::from(sep);
}
"--scroll-off" => {
let (v, sep) = flag_value(a, next);
if let Some(n) = v.and_then(|v| v.parse::<usize>().ok()) {
look.scroll_off = n;
}
i += usize::from(sep);
}
"--cycle" => look.cycle = true,
"--no-cycle" => look.cycle = false,
"--tac" => look.tac = true,
"--no-tac" => look.tac = false,
"--ansi" => look.ansi = true,
"--print-query" => look.print_query = true,
"--no-print-query" => look.print_query = false,
"-i" | "--ignore-case" => look.case = Case::Ignore,
"+i" | "--no-ignore-case" => look.case = Case::Respect,
"--smart-case" => look.case = Case::Smart,
"-x" | "--extended" => look.extended = true,
"+x" | "--no-extended" => look.extended = false,
"--extended-exact" => look.extended = true,
"--algo" => {
let (v, sep) = flag_value(a, next);
match v.as_deref() {
Some("v1") => look.algo_v1 = true,
Some("v2") => look.algo_v1 = false,
_ => {}
}
i += usize::from(sep);
}
"--scheme" => {
let (v, sep) = flag_value(a, next);
if let Some(s) = v.as_deref().and_then(crate::algo::Scheme::by_name) {
look.scheme = s;
look.tiebreak = crate::pattern::scheme_criteria(&s);
}
i += usize::from(sep);
}
"--read0" => look.read0 = true,
"--no-read0" => look.read0 = false,
"--print0" => look.print0 = true,
"--no-print0" => look.print0 = false,
"--tail" => {
let (v, sep) = flag_value(a, next);
look.tail = v.and_then(|v| v.parse::<usize>().ok()).filter(|n| *n > 0);
i += usize::from(sep);
}
"--no-tail" => look.tail = None,
"--accept-nth" => {
let (v, sep) = flag_value(a, next);
look.accept_nth = v.as_deref().and_then(AcceptNth::parse);
i += usize::from(sep);
}
"--with-shell" => {
let (v, sep) = flag_value(a, next);
look.with_shell = v.filter(|v| !v.is_empty());
i += usize::from(sep);
}
"--expect" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
look.expect = v
.split(',')
.filter(|k| !k.is_empty())
.filter_map(|k| parse_key(k).map(|p| (p, k.to_string())))
.collect();
}
i += usize::from(sep);
}
"--no-ansi" => look.ansi = false,
"--no-expect" => look.expect.clear(),
"--no-header-lines" => look.header_lines = 0,
"--scrollbar" => look.scrollbar = true,
"--delimiter" | "-d" => {
let (v, sep) = match attached {
Some(v) => (Some(v), false),
None => flag_value(a, next),
};
look.delimiter = v.filter(|v| !v.is_empty());
i += usize::from(sep);
}
"--nth" | "-n" => {
let (v, sep) = match attached {
Some(v) => (Some(v), false),
None => flag_value(a, next),
};
if let Some(v) = v {
look.nth = Nth::parse_list(&v);
}
i += usize::from(sep);
}
"--with-nth" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
look.with_nth = Nth::parse_list(&v);
}
i += usize::from(sep);
}
"--header-lines" => {
let (v, sep) = flag_value(a, next);
if let Some(n) = v.and_then(|v| v.parse::<usize>().ok()) {
look.header_lines = n;
}
i += usize::from(sep);
}
"--min-height" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
let plus = v.ends_with('+');
if let Ok(n) = v.trim_end_matches('+').parse::<u16>() {
look.min_height = n;
look.min_height_plus = plus;
}
}
i += usize::from(sep);
}
"--no-scrollbar" => look.scrollbar = false,
"--bind" => {
let (v, sep) = flag_value(a, next);
if let Some(v) = v {
look.binds.extend(parse_bind_spec(&v));
}
i += usize::from(sep);
}
_ => {}
}
i += 1;
}
look
}
pub fn shell(&self) -> Vec<String> {
if let Some(w) = &self.with_shell {
let words = shell_split(w);
if !words.is_empty() {
return words;
}
}
match std::env::var("SHELL") {
Ok(sh) if !sh.is_empty() => vec![sh, "-c".to_string()],
_ => vec!["sh".to_string(), "-c".to_string()],
}
}
pub fn bound(&self, key: Key) -> Option<&[Action]> {
self.binds
.iter()
.rev()
.find(|(k, _)| *k == key)
.map(|(_, a)| a.as_slice())
}
pub fn bound_or_default(&self, key: Key) -> Option<Vec<Action>> {
self.bound(key).map(<[_]>::to_vec).or(match key {
Key::ShiftUp => Some(vec![Action::PreviewUp]),
Key::ShiftDown => Some(vec![Action::PreviewDown]),
_ => None,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn shell_split_keeps_quoted_prompt_intact() {
let v = shell_split("--prompt='<<)ZPWR(>> ' --reverse --height 100%");
assert_eq!(
v,
vec!["--prompt=<<)ZPWR(>> ", "--reverse", "--height", "100%"]
);
}
#[test]
fn shell_split_handles_double_quotes_and_escapes() {
let v = shell_split(r#"--prompt="a b" --header=c\ d"#);
assert_eq!(v, vec!["--prompt=a b", "--header=c d"]);
assert_eq!(shell_split("--prompt=''"), vec!["--prompt="]);
}
#[test]
fn later_options_win() {
let args: Vec<String> = ["--layout=reverse", "--layout=default"]
.iter()
.map(|s| s.to_string())
.collect();
assert_eq!(Look::parse(&args).layout, Layout::Default);
}
#[test]
fn parses_layout_border_info_pointer() {
let args: Vec<String> = [
"--reverse",
"--border",
"--info=inline",
"--pointer",
">",
"--marker",
"*",
]
.iter()
.map(|s| s.to_string())
.collect();
let look = Look::parse(&args);
assert_eq!(look.layout, Layout::Reverse);
assert_eq!(look.border, Some((BorderType::Rounded, Borders::ALL)));
assert_eq!(look.info, Info::Inline(" < ".to_string()));
assert_eq!(look.pointer, ">");
assert_eq!(look.marker, "*");
}
#[test]
fn color_spec_overrides_scheme_slots() {
let args: Vec<String> = ["--color=light,hl:#ff0000,fg+:2:bold:underline"]
.iter()
.map(|s| s.to_string())
.collect();
let c = Look::parse(&args).colors;
assert_eq!(c.prompt, Ent::b(25));
assert_eq!(c.hl.color, Some(Color::Rgb(0xff, 0, 0)));
assert_eq!(c.fg_plus.color, Some(Color::Indexed(2)));
assert!(c.fg_plus.attrs.contains(Modifier::BOLD));
assert!(c.fg_plus.attrs.contains(Modifier::UNDERLINED));
}
#[test]
fn binds_map_fzf_actions() {
let args: Vec<String> =
["--bind=ctrl-n:page-down,ctrl-p:page-up,tab:toggle+down,ctrl-j:down,ctrl-k:up"]
.iter()
.map(|s| s.to_string())
.collect();
let look = Look::parse(&args);
assert_eq!(look.bound(Key::Ctrl('n')), Some(&[Action::PageDown][..]));
assert_eq!(look.bound(Key::Ctrl('p')), Some(&[Action::PageUp][..]));
assert_eq!(
look.bound(Key::Tab),
Some(&[Action::Toggle, Action::Down][..])
);
assert_eq!(look.bound(Key::Ctrl('j')), Some(&[Action::Down][..]));
assert_eq!(look.bound(Key::Ctrl('k')), Some(&[Action::Up][..]));
}
#[test]
fn unsupported_action_drops_only_that_binding() {
let args: Vec<String> = ["--bind=ctrl-o:execute(vim {}),ctrl-k:up"]
.iter()
.map(|s| s.to_string())
.collect();
let look = Look::parse(&args);
assert_eq!(look.bound(Key::Ctrl('o')), None);
assert_eq!(look.bound(Key::Ctrl('k')), Some(&[Action::Up][..]));
}
#[test]
fn preview_scroll_actions_parse_and_shift_arrows_default_to_them() {
let args: Vec<String> = ["--bind=ctrl-d:preview-half-page-down,ctrl-b:preview-page-up,alt-t:preview-top+preview-down"]
.iter()
.map(|s| s.to_string())
.collect();
let look = Look::parse(&args);
assert_eq!(
look.bound(Key::Ctrl('d')),
Some(&[Action::PreviewHalfPageDown][..])
);
assert_eq!(
look.bound(Key::Ctrl('b')),
Some(&[Action::PreviewPageUp][..])
);
assert_eq!(
look.bound(Key::Alt('t')),
Some(&[Action::PreviewTop, Action::PreviewDown][..])
);
let plain = Look::default();
assert_eq!(
plain.bound_or_default(Key::ShiftUp),
Some(vec![Action::PreviewUp])
);
assert_eq!(
plain.bound_or_default(Key::ShiftDown),
Some(vec![Action::PreviewDown])
);
assert_eq!(plain.bound_or_default(Key::Char('x')), None);
let own = Look::parse(&["--bind=shift-up:up".to_string()]);
assert_eq!(own.bound_or_default(Key::ShiftUp), Some(vec![Action::Up]));
}
#[test]
fn preview_scroll_spec_parses_base_offsets_and_denominator() {
let w = PreviewWindow::parse("right,60%,+{2}+3/2");
assert_eq!(w.size, PreviewSize::Percent(60));
let sc = w.scroll.expect("scroll");
assert_eq!(sc.base, ScrollBase::Field(Nth::parse_list("2")));
assert_eq!((sc.offset, sc.denom), (3, 2));
let n = PreviewWindow::parse("+10-4").scroll.expect("scroll");
assert_eq!((n.base, n.offset, n.denom), (ScrollBase::Line(10), -4, 0));
assert_eq!(PreviewWindow::parse("+{x}").scroll, None);
assert_eq!(PreviewWindow::parse("+{2}*").scroll, None);
}
#[test]
fn preview_scroll_targets_the_field_line_and_centres_it() {
let sc = PreviewWindow::parse("+{2}-5").scroll.unwrap();
assert_eq!(sc.target("main.rs:120:fn x", Some(":")), Some(115));
assert_eq!(sc.target("main.rs:abc:fn x", Some(":")), None);
assert_eq!(sc.top(115, 20), 114);
let mid = PreviewWindow::parse("+{2}/2").scroll.unwrap();
assert_eq!(mid.top(120, 20), 109);
assert_eq!(mid.top(3, 20), 0);
}
#[test]
fn preview_template_expands_whole_line_and_fields() {
let q = |s: &str| format!("<{s}>");
assert_eq!(
expand_preview("bat {1} --highlight-line {2}", "a.rs:7:x", Some(":"), q),
"bat <a.rs> --highlight-line <7>"
);
assert_eq!(expand_preview("echo {}", "a b", None, q), "echo <a b>");
assert_eq!(
expand_preview("awk '{print $1}' {}", "z", None, q),
"awk '{print $1}' <z>"
);
}
#[test]
fn repeated_preview_window_options_fold_together() {
let look = Look::parse(
&[
"--preview-window=down:40%:wrap",
"--preview-window",
"+{2}+3/3",
]
.map(String::from),
);
let w = look.preview_window;
assert_eq!(
(w.pos, w.size, w.wrap),
(PreviewPos::Down, PreviewSize::Percent(40), true)
);
assert!(w.scroll.is_some());
}
#[test]
fn preview_window_defaults_are_fzfs() {
let w = PreviewWindow::default();
assert_eq!(w.pos, PreviewPos::Right);
assert_eq!(w.size, PreviewSize::Percent(50));
assert!(!w.hidden && !w.wrap);
}
#[test]
fn preview_window_takes_both_separators_in_any_order() {
let a = PreviewWindow::parse("down,30%,wrap");
assert_eq!(a.pos, PreviewPos::Down);
assert_eq!(a.size, PreviewSize::Percent(30));
assert!(a.wrap);
let b = PreviewWindow::parse("right:55%");
assert_eq!(b.pos, PreviewPos::Right);
assert_eq!(b.size, PreviewSize::Percent(55));
assert_eq!(PreviewWindow::parse("20,up"), PreviewWindow::parse("up,20"));
assert_eq!(PreviewWindow::parse("up,20").size, PreviewSize::Cells(20));
}
#[test]
fn unmodeled_parts_of_the_spec_are_ignored_not_rejected() {
let w = PreviewWindow::parse("left,40%,border-sharp,follow,cycle,+3/2,~2,noinfo");
assert_eq!(w.pos, PreviewPos::Left);
assert_eq!(w.size, PreviewSize::Percent(40));
}
#[test]
fn hidden_and_zero_size_draw_no_pane() {
use ratatui::layout::Rect;
let body = Rect {
x: 0,
y: 0,
width: 100,
height: 30,
};
let (list, pane) = PreviewWindow::parse("hidden").split(body);
assert!(pane.is_none(), "hidden draws nothing");
assert_eq!(list, body, "and the list takes the whole body");
assert!(PreviewWindow::parse("right,0").split(body).1.is_none());
assert!(PreviewWindow::parse("right,0%").split(body).1.is_none());
}
#[test]
fn the_split_places_and_sizes_the_pane() {
use ratatui::layout::Rect;
let body = Rect {
x: 0,
y: 0,
width: 100,
height: 30,
};
let (list, pane) = PreviewWindow::parse("right,60%").split(body);
let pane = pane.expect("drawn");
assert_eq!((list.width, pane.width), (40, 60));
assert_eq!(pane.x, 40, "right means after the list");
let (list, pane) = PreviewWindow::parse("left,25").split(body);
let pane = pane.expect("drawn");
assert_eq!((pane.width, list.width), (25, 75));
assert_eq!(pane.x, 0, "left means before the list");
let (list, pane) = PreviewWindow::parse("up,10").split(body);
let pane = pane.expect("drawn");
assert_eq!((pane.height, list.height), (10, 20));
assert_eq!(pane.y, 0);
let (list, pane) = PreviewWindow::parse("down,3").split(body);
let pane = pane.expect("drawn");
assert_eq!((list.height, pane.height), (27, 3));
assert_eq!(pane.y, 27);
}
#[test]
fn the_list_always_keeps_a_cell() {
use ratatui::layout::Rect;
let body = Rect {
x: 0,
y: 0,
width: 10,
height: 4,
};
let (list, pane) = PreviewWindow::parse("right,100%").split(body);
assert_eq!(list.width, 1);
assert_eq!(pane.expect("drawn").width, 9);
}
#[test]
fn look_parses_the_flag_in_both_spellings() {
let attached = Look::parse(&["arb".into(), "--fzf".into(), "--preview-window=up,7".into()]);
assert_eq!(attached.preview_window.pos, PreviewPos::Up);
assert_eq!(attached.preview_window.size, PreviewSize::Cells(7));
let separate = Look::parse(&[
"arb".into(),
"--fzf".into(),
"--preview-window".into(),
"down,20%".into(),
]);
assert_eq!(separate.preview_window.pos, PreviewPos::Down);
assert_eq!(separate.preview_window.size, PreviewSize::Percent(20));
}
}