Valdemar Lorenzen
747 lines
29 KiB
Rust
747 lines
29 KiB
Rust
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||
use ratatui::{
|
||
Frame,
|
||
layout::{Constraint, Layout, Rect},
|
||
style::{Color, Modifier, Style},
|
||
text::Line,
|
||
widgets::{Block, Cell, Paragraph, Row, Table, TableState},
|
||
};
|
||
|
||
use crate::{
|
||
Result,
|
||
connection::Input,
|
||
db::{Column, Database, PAGE_SIZE, Page, QueryResult, Relation},
|
||
error_text, sql,
|
||
};
|
||
|
||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||
pub(crate) enum Focus {
|
||
Explorer,
|
||
Query,
|
||
Rows,
|
||
}
|
||
|
||
pub struct App {
|
||
db: Database,
|
||
pub(crate) relations: Vec<Relation>,
|
||
active: Option<usize>,
|
||
columns: Vec<Column>,
|
||
page: Page,
|
||
page_index: usize,
|
||
rows_state: TableState,
|
||
schema_state: TableState,
|
||
column_offset: usize,
|
||
show_schema: bool,
|
||
query: Input,
|
||
query_insert: bool,
|
||
query_highlights: sql::Highlights,
|
||
query_result: Option<QueryResult>,
|
||
error: Option<String>,
|
||
}
|
||
|
||
impl App {
|
||
pub fn new(mut db: Database) -> Result<Self> {
|
||
let relations = db.relations()?;
|
||
let selected = (!relations.is_empty()).then_some(0);
|
||
let mut app = Self {
|
||
db,
|
||
relations,
|
||
active: None,
|
||
columns: Vec::new(),
|
||
page: Page {
|
||
rows: Vec::new(),
|
||
has_next: false,
|
||
},
|
||
page_index: 0,
|
||
rows_state: TableState::default(),
|
||
schema_state: TableState::default(),
|
||
column_offset: 0,
|
||
show_schema: false,
|
||
query: Input::default(),
|
||
query_insert: false,
|
||
query_highlights: Vec::new(),
|
||
query_result: None,
|
||
error: None,
|
||
};
|
||
app.open_relation(selected);
|
||
Ok(app)
|
||
}
|
||
|
||
pub(crate) fn provider(&self) -> &'static str {
|
||
self.db.name()
|
||
}
|
||
|
||
pub(crate) fn database_name(&self) -> &str {
|
||
self.db.display_name()
|
||
}
|
||
|
||
pub(crate) fn query_insert_mode(&self) -> bool {
|
||
self.query_insert
|
||
}
|
||
|
||
pub(crate) fn leave_query_insert(&mut self) -> bool {
|
||
std::mem::replace(&mut self.query_insert, false)
|
||
}
|
||
|
||
pub(crate) fn query_position(&self) -> (usize, usize) {
|
||
self.query.position()
|
||
}
|
||
|
||
pub(crate) fn handle_key(&mut self, key: KeyEvent) {
|
||
match key.code {
|
||
KeyCode::Down | KeyCode::Char('j') => self.move_selection(1),
|
||
KeyCode::Up | KeyCode::Char('k') => self.move_selection(-1),
|
||
KeyCode::Home | KeyCode::Char('g') => self.move_selection(isize::MIN),
|
||
KeyCode::End | KeyCode::Char('G') => self.move_selection(isize::MAX),
|
||
KeyCode::Char('s') if self.query_result.is_none() => {
|
||
self.show_schema = !self.show_schema;
|
||
self.column_offset = 0;
|
||
}
|
||
KeyCode::Left | KeyCode::Char('h') => self.move_column(-1),
|
||
KeyCode::Right | KeyCode::Char('l') => self.move_column(1),
|
||
KeyCode::Char('n') | KeyCode::PageDown
|
||
if self.query_result.is_none() && !self.show_schema && self.page.has_next =>
|
||
{
|
||
self.load_page(self.page_index + 1);
|
||
}
|
||
KeyCode::Char('p') | KeyCode::PageUp
|
||
if self.query_result.is_none() && !self.show_schema && self.page_index > 0 =>
|
||
{
|
||
self.load_page(self.page_index - 1);
|
||
}
|
||
KeyCode::Char('r') => self.refresh(),
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
pub(crate) fn handle_query_key(&mut self, key: KeyEvent) {
|
||
let previous_len = self.query.value.len();
|
||
match key.code {
|
||
KeyCode::F(5) => self.execute_query(),
|
||
KeyCode::Enter if key.modifiers.contains(KeyModifiers::CONTROL) => self.execute_query(),
|
||
KeyCode::Esc => {
|
||
self.leave_query_insert();
|
||
}
|
||
KeyCode::Enter if self.query_insert => self.query.paste_multiline("\n"),
|
||
_ if self.query_insert => self.query.edit(key),
|
||
KeyCode::Left
|
||
| KeyCode::Right
|
||
| KeyCode::Up
|
||
| KeyCode::Down
|
||
| KeyCode::Home
|
||
| KeyCode::End => self.query.edit(key),
|
||
KeyCode::Char(character)
|
||
if !key
|
||
.modifiers
|
||
.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT) =>
|
||
{
|
||
let movement = match character {
|
||
'h' => Some(KeyCode::Left),
|
||
'j' => Some(KeyCode::Down),
|
||
'k' => Some(KeyCode::Up),
|
||
'l' => Some(KeyCode::Right),
|
||
'a' => {
|
||
let (line, column) = self.query_position();
|
||
self.query
|
||
.value
|
||
.split('\n')
|
||
.nth(line - 1)
|
||
.filter(|text| column <= text.chars().count())
|
||
.map(|_| KeyCode::Right)
|
||
}
|
||
'I' => Some(KeyCode::Home),
|
||
'A' => Some(KeyCode::End),
|
||
_ => None,
|
||
};
|
||
if let Some(code) = movement {
|
||
self.query.edit(KeyEvent::new(code, KeyModifiers::NONE));
|
||
}
|
||
self.query_insert = matches!(character, 'i' | 'a' | 'I' | 'A');
|
||
}
|
||
_ => {}
|
||
}
|
||
self.highlight_query(previous_len);
|
||
}
|
||
|
||
pub(crate) fn paste_query(&mut self, text: &str) {
|
||
if !self.query_insert {
|
||
return;
|
||
}
|
||
let previous_len = self.query.value.len();
|
||
self.query.paste_multiline(text);
|
||
self.highlight_query(previous_len);
|
||
}
|
||
|
||
fn highlight_query(&mut self, previous_len: usize) {
|
||
// Editing inserts or removes bytes; cursor movement does not invalidate syntax.
|
||
if self.query.value.len() != previous_len {
|
||
self.query_highlights = sql::highlight(&self.query.value, self.db.name() == "SQLite");
|
||
}
|
||
}
|
||
|
||
fn execute_query(&mut self) {
|
||
match self.db.query(&self.query.value) {
|
||
Ok(result) => {
|
||
self.rows_state = TableState::default()
|
||
.with_selected((!result.page.rows.is_empty()).then_some(0))
|
||
.with_selected_column((!result.headers.is_empty()).then_some(0));
|
||
self.column_offset = 0;
|
||
self.show_schema = false;
|
||
self.query_result = Some(result);
|
||
self.error = None;
|
||
}
|
||
Err(error) => self.error = Some(error_text(error.as_ref())),
|
||
}
|
||
}
|
||
|
||
fn move_selection(&mut self, delta: isize) {
|
||
if self.show_schema {
|
||
let next = moved_index(self.schema_state.selected(), self.columns.len(), delta);
|
||
self.schema_state.select(next);
|
||
} else {
|
||
let count = self
|
||
.query_result
|
||
.as_ref()
|
||
.map_or(self.page.rows.len(), |result| result.page.rows.len());
|
||
let next = moved_index(self.rows_state.selected(), count, delta);
|
||
self.rows_state.select(next);
|
||
}
|
||
}
|
||
|
||
fn column_count(&self) -> usize {
|
||
if self.show_schema {
|
||
5
|
||
} else {
|
||
self.query_result
|
||
.as_ref()
|
||
.map_or(self.columns.len(), |result| result.headers.len())
|
||
}
|
||
}
|
||
|
||
fn move_column(&mut self, delta: isize) {
|
||
let count = self.column_count();
|
||
let state = if self.show_schema {
|
||
&mut self.schema_state
|
||
} else {
|
||
&mut self.rows_state
|
||
};
|
||
state.select_column(moved_index(state.selected_column(), count, delta));
|
||
}
|
||
|
||
pub(crate) fn open_relation(&mut self, index: Option<usize>) {
|
||
self.active = index;
|
||
self.query_result = None;
|
||
self.columns.clear();
|
||
self.page = Page {
|
||
rows: Vec::new(),
|
||
has_next: false,
|
||
};
|
||
self.page_index = 0;
|
||
self.column_offset = 0;
|
||
self.rows_state = TableState::default();
|
||
self.schema_state = TableState::default();
|
||
self.error = None;
|
||
if let Some(index) = self.active {
|
||
match self.db.columns(&self.relations[index]) {
|
||
Ok(columns) => {
|
||
self.columns = columns;
|
||
self.schema_state
|
||
.select((!self.columns.is_empty()).then_some(0));
|
||
self.schema_state
|
||
.select_column((!self.columns.is_empty()).then_some(0));
|
||
self.load_page(0);
|
||
}
|
||
Err(error) => self.error = Some(error_text(error.as_ref())),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn load_page(&mut self, index: usize) {
|
||
if let Some(active) = self.active {
|
||
// ponytail: synchronous reads block input; use a worker if responsiveness matters.
|
||
match self.db.page(&self.relations[active], &self.columns, index) {
|
||
Ok(page) => {
|
||
self.rows_state = TableState::default()
|
||
.with_selected((!page.rows.is_empty()).then_some(0))
|
||
.with_selected_column(
|
||
self.rows_state
|
||
.selected_column()
|
||
.or_else(|| (!self.columns.is_empty()).then_some(0)),
|
||
);
|
||
self.page = page;
|
||
self.page_index = index;
|
||
self.error = None;
|
||
}
|
||
Err(error) => self.error = Some(error_text(error.as_ref())),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn refresh(&mut self) {
|
||
match self.db.relations() {
|
||
Ok(relations) => {
|
||
let id = self.active.map(|index| self.relations[index].id);
|
||
let selected = relations
|
||
.iter()
|
||
.position(|relation| Some(relation.id) == id)
|
||
.or_else(|| (!relations.is_empty()).then_some(0));
|
||
self.relations = relations;
|
||
self.open_relation(selected);
|
||
}
|
||
Err(error) => self.error = Some(error_text(error.as_ref())),
|
||
}
|
||
}
|
||
|
||
pub(crate) fn draw(&mut self, frame: &mut Frame, area: Rect, focus: Focus) {
|
||
if area.width < 38 || area.height < 10 {
|
||
frame.render_widget(
|
||
Paragraph::new("Enlarge terminal to at least 70×17. Ctrl-C to quit."),
|
||
area,
|
||
);
|
||
return;
|
||
}
|
||
let [error_area, body] = Layout::vertical([
|
||
Constraint::Length(u16::from(self.error.is_some())),
|
||
Constraint::Min(4),
|
||
])
|
||
.areas(area);
|
||
let [query, content] =
|
||
Layout::vertical([Constraint::Ratio(1, 2), Constraint::Min(4)]).areas(body);
|
||
self.query.draw(
|
||
frame,
|
||
query,
|
||
" Query · F5 execute ",
|
||
false,
|
||
focus == Focus::Query,
|
||
Some(sql::text(&self.query.value, &self.query_highlights)),
|
||
);
|
||
let title = if self.query_result.is_some() {
|
||
" Results "
|
||
} else if self.show_schema {
|
||
" Schema · s for rows "
|
||
} else {
|
||
" Rows · s for schema "
|
||
};
|
||
let count = self.column_count();
|
||
let capacity = usize::from(content.width.saturating_sub(2) / 21).max(1);
|
||
let selected = if self.show_schema {
|
||
self.schema_state.selected_column()
|
||
} else {
|
||
self.rows_state.selected_column()
|
||
};
|
||
if let Some(selected) = selected {
|
||
self.column_offset = self.column_offset.min(selected);
|
||
if selected >= self.column_offset + capacity {
|
||
self.column_offset = selected + 1 - capacity;
|
||
}
|
||
}
|
||
let visible = capacity.min(count.saturating_sub(self.column_offset));
|
||
let widths = (0..visible).map(|index| {
|
||
if index + 1 == visible {
|
||
Constraint::Min(1)
|
||
} else {
|
||
Constraint::Length(20)
|
||
}
|
||
});
|
||
let description = if let Some(result) = &self.query_result {
|
||
format!(
|
||
" Query · {} rows{} · columns {}–{}/{}",
|
||
result.page.rows.len(),
|
||
if result.page.has_next {
|
||
" (first 100)"
|
||
} else {
|
||
""
|
||
},
|
||
if count > 0 { self.column_offset + 1 } else { 0 },
|
||
self.column_offset + visible,
|
||
count,
|
||
)
|
||
} else if let Some(index) = self.active {
|
||
let relation = &self.relations[index];
|
||
if self.show_schema {
|
||
format!(
|
||
" [{}] · {} columns · fields {}–{}/5",
|
||
relation.kind,
|
||
self.columns.len(),
|
||
self.column_offset + 1,
|
||
self.column_offset + visible
|
||
)
|
||
} else {
|
||
let start = if self.page.rows.is_empty() {
|
||
0
|
||
} else {
|
||
self.page_index * PAGE_SIZE + 1
|
||
};
|
||
let end = self.page_index * PAGE_SIZE + self.page.rows.len();
|
||
format!(
|
||
" [{}] · rows {start}–{end} · page {}{} · columns {}–{}/{}",
|
||
relation.kind,
|
||
self.page_index + 1,
|
||
if self.page.has_next { " (more)" } else { "" },
|
||
if count > 0 { self.column_offset + 1 } else { 0 },
|
||
self.column_offset + visible,
|
||
count
|
||
)
|
||
}
|
||
} else {
|
||
" No readable relations. r to refresh.".into()
|
||
};
|
||
let mut content_block =
|
||
panel(title, focus == Focus::Rows).title_bottom(Line::from(description).left_aligned());
|
||
if self.query_result.is_none()
|
||
&& let Some(index) = self.active
|
||
{
|
||
content_block = content_block.title_top(
|
||
Line::from(format!(" {} ", self.relations[index].label)).right_aligned(),
|
||
);
|
||
}
|
||
let page = self
|
||
.query_result
|
||
.as_ref()
|
||
.map_or(&self.page, |result| &result.page);
|
||
if self.active.is_none() && self.query_result.is_none() {
|
||
frame.render_widget(
|
||
Paragraph::new("Choose a relation and press Enter.").block(content_block),
|
||
content,
|
||
);
|
||
} else if self.show_schema {
|
||
let headers = ["Column", "Type", "Nullable", "Key", "Default"];
|
||
let rows = self.columns.iter().map(|column| {
|
||
Row::new(
|
||
[
|
||
column.label.as_str(),
|
||
column.data_type.as_str(),
|
||
if column.nullable { "yes" } else { "no" },
|
||
if column.primary_key { "PK" } else { "" },
|
||
column.default.as_str(),
|
||
]
|
||
.into_iter()
|
||
.skip(self.column_offset)
|
||
.take(visible),
|
||
)
|
||
});
|
||
let table = Table::new(rows, widths)
|
||
.header(
|
||
Row::new(headers.into_iter().skip(self.column_offset).take(visible))
|
||
.style(header_style()),
|
||
)
|
||
.block(content_block)
|
||
.cell_highlight_style(selected_style());
|
||
self.schema_state
|
||
.select_column(selected.map(|column| column - self.column_offset));
|
||
frame.render_stateful_widget(table, content, &mut self.schema_state);
|
||
self.schema_state.select_column(selected);
|
||
} else if page.rows.is_empty() {
|
||
frame.render_widget(
|
||
Paragraph::new(if self.error.is_some() {
|
||
"Could not load rows. See error above."
|
||
} else {
|
||
"No rows."
|
||
})
|
||
.block(content_block),
|
||
content,
|
||
);
|
||
} else {
|
||
let headers = (self.column_offset..self.column_offset + visible).map(|index| {
|
||
self.query_result.as_ref().map_or_else(
|
||
|| self.columns[index].label.as_str(),
|
||
|result| result.headers[index].as_str(),
|
||
)
|
||
});
|
||
let rows = page.rows.iter().map(|row| {
|
||
Row::new(
|
||
row.iter()
|
||
.skip(self.column_offset)
|
||
.take(visible)
|
||
.map(|value| match value {
|
||
Some(value) => Cell::from(value.as_str()),
|
||
None => Cell::from("NULL").style(
|
||
Style::default()
|
||
.fg(Color::DarkGray)
|
||
.add_modifier(Modifier::ITALIC),
|
||
),
|
||
}),
|
||
)
|
||
});
|
||
let table = Table::new(rows, widths)
|
||
.header(Row::new(headers).style(header_style()))
|
||
.block(content_block)
|
||
.cell_highlight_style(selected_style());
|
||
self.rows_state
|
||
.select_column(selected.map(|column| column - self.column_offset));
|
||
frame.render_stateful_widget(table, content, &mut self.rows_state);
|
||
self.rows_state.select_column(selected);
|
||
}
|
||
if let Some(error) = &self.error {
|
||
frame.render_widget(
|
||
Paragraph::new(error.as_str()).style(Style::default().fg(Color::Red)),
|
||
error_area,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
fn panel(title: &str, focused: bool) -> Block<'_> {
|
||
Block::bordered()
|
||
.title(title)
|
||
.border_style(Style::default().fg(if focused {
|
||
Color::Cyan
|
||
} else {
|
||
Color::DarkGray
|
||
}))
|
||
}
|
||
|
||
fn selected_style() -> Style {
|
||
Style::default().bg(Color::Blue).fg(Color::White)
|
||
}
|
||
|
||
fn header_style() -> Style {
|
||
Style::default()
|
||
.fg(Color::Cyan)
|
||
.add_modifier(Modifier::BOLD)
|
||
}
|
||
|
||
fn moved_index(selected: Option<usize>, count: usize, delta: isize) -> Option<usize> {
|
||
if count == 0 {
|
||
return None;
|
||
}
|
||
Some(
|
||
selected
|
||
.unwrap_or(0)
|
||
.saturating_add_signed(delta)
|
||
.min(count - 1),
|
||
)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::moved_index;
|
||
|
||
#[test]
|
||
fn navigation_clamps_to_available_items() {
|
||
assert_eq!(moved_index(None, 0, 1), None);
|
||
assert_eq!(moved_index(None, 3, 1), Some(1));
|
||
assert_eq!(moved_index(Some(0), 3, -1), Some(0));
|
||
assert_eq!(moved_index(Some(2), 3, 1), Some(2));
|
||
assert_eq!(moved_index(Some(1), 3, isize::MIN), Some(0));
|
||
assert_eq!(moved_index(Some(1), 3, isize::MAX), Some(2));
|
||
}
|
||
|
||
#[test]
|
||
fn query_modes_preserve_literal_text_and_navigation() -> crate::Result<()> {
|
||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||
let file = tempfile::NamedTempFile::new()?;
|
||
let mut app = super::App::new(crate::db::Database::open_sqlite(file.path())?)?;
|
||
let key = |character| KeyEvent::new(KeyCode::Char(character), KeyModifiers::NONE);
|
||
assert!(!app.query_insert_mode());
|
||
app.paste_query("ignored");
|
||
app.handle_query_key(key('q'));
|
||
assert!(app.query.value.is_empty());
|
||
assert!(!app.leave_query_insert());
|
||
app.handle_query_key(key('i'));
|
||
for character in ['q', 'i', 'h'] {
|
||
app.handle_query_key(key(character));
|
||
}
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
||
app.paste_query("界é");
|
||
assert_eq!(app.query.value, "qih\n界é");
|
||
assert_eq!(app.query_position(), (2, 3));
|
||
assert!(app.leave_query_insert());
|
||
app.paste_query("ignored");
|
||
app.handle_query_key(key('h'));
|
||
assert_eq!(app.query_position(), (2, 2));
|
||
app.handle_query_key(key('k'));
|
||
assert_eq!(app.query_position(), (1, 2));
|
||
app.handle_query_key(key('a'));
|
||
assert!(app.query_insert_mode());
|
||
assert_eq!(app.query_position(), (1, 3));
|
||
app.leave_query_insert();
|
||
app.handle_query_key(key('I'));
|
||
assert_eq!(app.query_position(), (1, 1));
|
||
assert!(app.query_insert_mode());
|
||
app.leave_query_insert();
|
||
app.handle_query_key(key('A'));
|
||
assert_eq!(app.query_position(), (1, 4));
|
||
assert!(app.query_insert_mode());
|
||
app.leave_query_insert();
|
||
app.handle_query_key(key('a'));
|
||
assert_eq!(app.query_position(), (1, 4));
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
||
assert!(!app.query_insert_mode());
|
||
assert_eq!(app.query.value, "qih\n界é");
|
||
Ok(())
|
||
}
|
||
|
||
#[test]
|
||
fn execution_shortcuts_work_in_both_query_modes() -> crate::Result<()> {
|
||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||
let file = tempfile::NamedTempFile::new()?;
|
||
let mut app = super::App::new(crate::db::Database::open_sqlite(file.path())?)?;
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
|
||
app.paste_query("SELECT\n42");
|
||
for insert in [true, false] {
|
||
if !insert {
|
||
app.leave_query_insert();
|
||
}
|
||
for key in [
|
||
KeyEvent::new(KeyCode::F(5), KeyModifiers::NONE),
|
||
KeyEvent::new(KeyCode::Enter, KeyModifiers::CONTROL),
|
||
] {
|
||
app.query_result = None;
|
||
app.handle_query_key(key);
|
||
assert_eq!(app.query_insert_mode(), insert);
|
||
assert_eq!(
|
||
app.query_result.as_ref().unwrap().page.rows[0][0].as_deref(),
|
||
Some("42")
|
||
);
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
#[test]
|
||
fn cell_selection_scrolls_and_survives_paging_and_schema_switches() -> crate::Result<()> {
|
||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||
use ratatui::{Terminal, backend::TestBackend, style::Color};
|
||
let file = tempfile::NamedTempFile::new()?;
|
||
rusqlite::Connection::open(file.path())?.execute_batch(
|
||
"CREATE TABLE cells (a, b, c, d, e, f);
|
||
WITH RECURSIVE n(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<101)
|
||
INSERT INTO cells SELECT x, x, x, x, x, x FROM n;",
|
||
)?;
|
||
let mut app = super::App::new(crate::db::Database::open_sqlite(file.path())?)?;
|
||
let mut terminal = Terminal::new(TestBackend::new(60, 20))?;
|
||
let key = |character| KeyEvent::new(KeyCode::Char(character), KeyModifiers::NONE);
|
||
assert_eq!(app.rows_state.selected_cell(), Some((0, 0)));
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), super::Focus::Rows))?;
|
||
assert_eq!(terminal.backend().buffer()[(1, 12)].bg, Color::Blue);
|
||
assert_ne!(terminal.backend().buffer()[(22, 12)].bg, Color::Blue);
|
||
app.handle_key(key('l'));
|
||
app.handle_key(key('l'));
|
||
app.handle_key(key('j'));
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), super::Focus::Rows))?;
|
||
assert_eq!(app.rows_state.selected_cell(), Some((1, 2)));
|
||
assert_eq!(app.column_offset, 1);
|
||
assert_eq!(terminal.backend().buffer()[(22, 13)].bg, Color::Blue);
|
||
assert_ne!(terminal.backend().buffer()[(1, 13)].bg, Color::Blue);
|
||
assert_ne!(terminal.backend().buffer()[(22, 12)].bg, Color::Blue);
|
||
app.handle_key(key('n'));
|
||
assert_eq!(app.page_index, 1);
|
||
assert_eq!(app.rows_state.selected_cell(), Some((0, 2)));
|
||
app.handle_key(key('s'));
|
||
app.handle_key(key('l'));
|
||
app.handle_key(key('j'));
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), super::Focus::Rows))?;
|
||
assert_eq!(app.schema_state.selected_cell(), Some((1, 1)));
|
||
assert_eq!(app.column_offset, 0);
|
||
assert_eq!(terminal.backend().buffer()[(22, 13)].bg, Color::Blue);
|
||
assert_ne!(terminal.backend().buffer()[(1, 13)].bg, Color::Blue);
|
||
app.handle_key(key('s'));
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), super::Focus::Rows))?;
|
||
assert_eq!(app.rows_state.selected_cell(), Some((0, 2)));
|
||
assert_eq!(app.column_offset, 1);
|
||
app.handle_key(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE));
|
||
assert_eq!(app.rows_state.selected_column(), Some(1));
|
||
Ok(())
|
||
}
|
||
|
||
#[test]
|
||
fn query_colors_survive_editing_and_scrolling() -> crate::Result<()> {
|
||
use super::{App, Focus};
|
||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||
use ratatui::{Terminal, backend::TestBackend, style::Color};
|
||
let file = tempfile::NamedTempFile::new()?;
|
||
let mut app = App::new(crate::db::Database::open_sqlite(file.path())?)?;
|
||
let mut terminal = Terminal::new(TestBackend::new(60, 14))?;
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
|
||
app.paste_query("SELECT '界', 42;\n-- comment");
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), Focus::Query))?;
|
||
let buffer = terminal.backend().buffer();
|
||
assert_eq!(buffer[(1, 1)].fg, Color::Cyan);
|
||
assert_eq!(buffer[(8, 1)].fg, Color::Green);
|
||
assert_eq!(buffer[(1, 2)].fg, Color::DarkGray);
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Char('\''), KeyModifiers::NONE));
|
||
app.paste_query("unfinished\nstring");
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), Focus::Query))?;
|
||
assert_eq!(terminal.backend().buffer()[(1, 2)].fg, Color::Green);
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
|
||
app.paste_query(&format!("{}--{}", "-- line\n".repeat(12), "x".repeat(90)));
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), Focus::Query))?;
|
||
let cursor = terminal.get_cursor_position()?;
|
||
let buffer = terminal.backend().buffer();
|
||
assert_eq!(cursor.x, 58);
|
||
assert_eq!(buffer[(cursor.x - 1, cursor.y)].symbol(), "x");
|
||
assert_eq!(buffer[(1, cursor.y)].fg, Color::DarkGray);
|
||
Ok(())
|
||
}
|
||
|
||
#[test]
|
||
fn queries_replace_rows_and_preserve_results_on_error() -> crate::Result<()> {
|
||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||
let file = tempfile::NamedTempFile::new()?;
|
||
rusqlite::Connection::open(file.path())?.execute_batch(
|
||
"CREATE TABLE comments (id INTEGER); INSERT INTO comments VALUES (9);",
|
||
)?;
|
||
let mut app = super::App::new(crate::db::Database::open_sqlite(file.path())?)?;
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
|
||
app.paste_query("SELECT '界é' AS note,\nNULL AS missing UNION ALL SELECT 'next', 2;");
|
||
app.handle_query_key(KeyEvent::new(KeyCode::F(5), KeyModifiers::NONE));
|
||
let result = app.query_result.as_ref().unwrap();
|
||
assert_eq!(result.headers, ["note", "missing"]);
|
||
assert_eq!(result.page.rows[0], [Some("界é".into()), None]);
|
||
assert_eq!(app.rows_state.selected_cell(), Some((0, 0)));
|
||
app.handle_key(KeyEvent::new(KeyCode::Right, KeyModifiers::NONE));
|
||
assert_eq!(app.rows_state.selected_cell(), Some((0, 1)));
|
||
app.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
|
||
assert_eq!(app.rows_state.selected(), Some(1));
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
|
||
app.paste_query("SELECT missing FROM nowhere");
|
||
app.handle_query_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::CONTROL));
|
||
assert!(app.error.is_some());
|
||
assert_eq!(
|
||
app.query_result.as_ref().unwrap().page.rows[0][0].as_deref(),
|
||
Some("界é")
|
||
);
|
||
app.open_relation(Some(0));
|
||
assert!(app.query_result.is_none());
|
||
assert!(app.error.is_none());
|
||
assert_eq!(app.page.rows, [vec![Some("9".into())]]);
|
||
assert_eq!(app.query.value, "SELECT missing FROM nowhere");
|
||
Ok(())
|
||
}
|
||
|
||
#[test]
|
||
fn relation_status_is_in_the_bottom_border() -> crate::Result<()> {
|
||
let file = tempfile::NamedTempFile::new()?;
|
||
rusqlite::Connection::open(file.path())?.execute_batch(
|
||
"CREATE TABLE comments (id INTEGER); INSERT INTO comments VALUES (1);",
|
||
)?;
|
||
let mut app = super::App::new(crate::db::Database::open_sqlite(file.path())?)?;
|
||
let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 20))?;
|
||
for (schema, error) in [(false, None), (true, None), (false, Some("Read failed"))] {
|
||
app.show_schema = schema;
|
||
app.error = error.map(str::to_owned);
|
||
terminal.draw(|frame| app.draw(frame, frame.area(), super::Focus::Rows))?;
|
||
let buffer = terminal.backend().buffer();
|
||
let border: String = (0..100).map(|x| buffer[(x, 19)].symbol()).collect();
|
||
assert!(border.ends_with('┘'), "{border}");
|
||
assert!(!border.contains("main.comments"));
|
||
assert!((0..19).any(|y| {
|
||
let line: String = (0..100).map(|x| buffer[(x, y)].symbol()).collect();
|
||
line.ends_with(" main.comments ┐")
|
||
}));
|
||
assert!(border.contains(if schema {
|
||
"fields 1–4/5"
|
||
} else {
|
||
"rows 1–1"
|
||
}));
|
||
if let Some(error) = error {
|
||
let message: String = (0..100).map(|x| buffer[(x, 0)].symbol()).collect();
|
||
assert!(message.starts_with(error), "{message}");
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|