cargo fmt/clippy fixes

Firstp1ck · Firstp1ck · commit bd1765583f8f · 2025-10-30T23:26:11.000+01:00
diff --git a/src/app.rs b/src/app.rs
@@ -145,10 +145,6 @@ impl App {
         };
     }
 
-
-
-
-
     pub fn handle_db_response(&mut self, resp: DBResponse) {
         match resp {
             DBResponse::Schema { tables } => {
@@ -179,9 +175,7 @@ impl App {
                     .visible_rows_per_page
                     .min(self.buffer_rows.len())
                     .max(1);
-                let mut view_start = self
-                    .global_row_offset
-                    .saturating_sub(self.buffer_offset);
+                let mut view_start = self.global_row_offset.saturating_sub(self.buffer_offset);
                 let max_start = self.buffer_rows.len().saturating_sub(cap);
                 if view_start > max_start {
                     view_start = max_start;
@@ -448,9 +442,11 @@ impl App {
         }
         // At bottom of visible window: try to scroll within current buffer first
         let buffer_end = self.buffer_offset.saturating_add(self.buffer_rows.len());
-        if self.global_row_offset
+        if self
+            .global_row_offset
             .saturating_add(self.sel_row)
-            .saturating_add(1) < buffer_end
+            .saturating_add(1)
+            < buffer_end
         {
             self.global_row_offset = self.global_row_offset.saturating_add(1);
             self.view_start = self.view_start.saturating_add(1);
@@ -494,12 +490,17 @@ impl App {
             self.status = "Editing __rowid__ is not supported".into();
             return;
         }
-        if let AppMode::Editing { row: erow, col: ecol, .. } = self.mode {
-            if erow == row && ecol == col {
-                // Already editing this cell; do not reset buffer or cursor
-                self.status = "Editing: Enter to save, Esc to cancel".into();
-                return;
-            }
+        if let AppMode::Editing {
+            row: erow,
+            col: ecol,
+            ..
+        } = self.mode
+            && erow == row
+            && ecol == col
+        {
+            // Already editing this cell; do not reset buffer or cursor
+            self.status = "Editing: Enter to save, Esc to cancel".into();
+            return;
         }
         // Capture a stable rowid for this edit session
         let rowid = self
@@ -761,8 +762,6 @@ impl App {
 
     // ===== Column width tiers (0 = narrow, 1 = normal, 2 = wide) =====
 
-
-
     /// Make the current column narrower by one tier.
     pub fn resize_current_column_narrower(&mut self) {
         if self.columns.is_empty() {
@@ -827,8 +826,6 @@ impl App {
             .and_then(|row| row.get(c))
             .map(|s| s.as_str())
     }
-
-
 }
 
 // Simplified grapheme stepping without unicode-segmentation:
diff --git a/src/db.rs b/src/db.rs
@@ -1,9 +1,9 @@
 use anyhow::Result;
 use crossbeam_channel::{Receiver, Sender};
 use rusqlite::{Connection, Row, types::ValueRef};
+use std::collections::HashMap;
 use std::fs::File;
 use std::io::{BufWriter, Write};
-use std::collections::HashMap;
 
 #[derive(Debug, Clone, Copy)]
 pub enum SortDir {
@@ -101,7 +101,18 @@ pub fn start_db_worker(path: String, req_rx: Receiver<DBRequest>, resp_tx: Sende
                 filter,
                 sort_by,
                 sort_dir,
-            } => load_table(&conn, &table, page, page_size, offset_override, filter, sort_by, sort_dir),
+            } => {
+                let params = LoadTableParams {
+                    table,
+                    page,
+                    page_size,
+                    offset_override,
+                    filter,
+                    sort_by,
+                    sort_dir,
+                };
+                load_table(&conn, &params)
+            }
             DBRequest::UpdateCell {
                 table,
                 rowid,
@@ -139,16 +150,26 @@ fn load_schema(conn: &Connection) -> Result<Vec<String>> {
     Ok(names)
 }
 
-fn load_table(
-    conn: &Connection,
-    table: &str,
+struct LoadTableParams {
+    table: String,
     page: usize,
     page_size: usize,
     offset_override: Option<usize>,
     filter: Option<String>,
     sort_by: Option<String>,
     sort_dir: Option<SortDir>,
-) -> Result<DBResponse> {
+}
+
+fn load_table(conn: &Connection, p: &LoadTableParams) -> Result<DBResponse> {
+    // unpack params
+    let table = p.table.as_str();
+    let page = p.page;
+    let page_size = p.page_size;
+    let offset_override = p.offset_override;
+    let filter = p.filter.clone();
+    let sort_by = p.sort_by.clone();
+    let sort_dir = p.sort_dir;
+
     // columns
     let mut col_stmt = conn.prepare(&format!("PRAGMA table_info({})", ident(table)))?;
     let mut columns: Vec<String> = vec!["__rowid__".to_string()];
@@ -405,7 +426,11 @@ fn update_cell(
 ) -> Result<DBResponse> {
     // Fetch previous value for history
     let prev_value: Option<String> = {
-        let sql = format!("SELECT {} FROM {} WHERE rowid = ?1", ident(column), ident(table));
+        let sql = format!(
+            "SELECT {} FROM {} WHERE rowid = ?1",
+            ident(column),
+            ident(table)
+        );
         let mut stmt_prev = conn.prepare(&sql)?;
         stmt_prev
             .query_row([rowid], |row| {
@@ -454,31 +479,31 @@ fn undo_last_change(
     history: &mut HashMap<String, Vec<Change>>,
     table: &str,
 ) -> Result<DBResponse> {
-    if let Some(stack) = history.get_mut(table) {
-        if let Some(change) = stack.pop() {
-            // Apply reverse update: set column back to previous value
-            let mut stmt = conn.prepare(&format!(
-                "UPDATE {} SET {} = ?1 WHERE rowid = ?2",
-                ident(&change.table),
-                ident(&change.column),
-            ))?;
-            let value_param = match change.prev_value {
-                None => rusqlite::types::Value::Null,
-                Some(ref s) => parse_value(s),
-            };
-            match stmt.execute((value_param, change.rowid)) {
-                Ok(_) => {
-                    return Ok(DBResponse::CellUpdated {
-                        ok: true,
-                        message: Some("Undo applied".into()),
-                    });
-                }
-                Err(e) => {
-                    return Ok(DBResponse::CellUpdated {
-                        ok: false,
-                        message: Some(format!("Undo failed: {}", e)),
-                    });
-                }
+    if let Some(stack) = history.get_mut(table)
+        && let Some(change) = stack.pop()
+    {
+        // Apply reverse update: set column back to previous value
+        let mut stmt = conn.prepare(&format!(
+            "UPDATE {} SET {} = ?1 WHERE rowid = ?2",
+            ident(&change.table),
+            ident(&change.column),
+        ))?;
+        let value_param = match change.prev_value {
+            None => rusqlite::types::Value::Null,
+            Some(ref s) => parse_value(s),
+        };
+        match stmt.execute((value_param, change.rowid)) {
+            Ok(_) => {
+                return Ok(DBResponse::CellUpdated {
+                    ok: true,
+                    message: Some("Undo applied".into()),
+                });
+            }
+            Err(e) => {
+                return Ok(DBResponse::CellUpdated {
+                    ok: false,
+                    message: Some(format!("Undo failed: {}", e)),
+                });
             }
         }
     }
diff --git a/src/main.rs b/src/main.rs
@@ -284,7 +284,8 @@ fn run_app(
                             use crossterm::event::KeyCode::*;
                             // Mark dirty only for keys that affect the edit buffer/cursor/state
                             match key.code {
-                                Enter | Esc | Backspace | Delete | Left | Right | Home | End | Char(_) => {
+                                Enter | Esc | Backspace | Delete | Left | Right | Home | End
+                                | Char(_) => {
                                     dirty = true;
                                 }
                                 _ => {}
@@ -323,15 +324,17 @@ fn handle_key_normal(app: &mut App, code: KeyCode) -> bool {
             } else {
                 app.move_cell_up()
             }
-        },
+        }
         KeyCode::Down => {
             if app.focus == app::Focus::Tables {
                 app.move_table_selection_down()
             } else {
                 app.move_cell_down()
             }
-        },
-        KeyCode::Tab => { app.toggle_focus(); },
+        }
+        KeyCode::Tab => {
+            app.toggle_focus();
+        }
         KeyCode::Enter => app.load_selected_table_page(0),
         KeyCode::PageDown => app.next_page(),
         KeyCode::PageUp => app.prev_page(),
diff --git a/src/ui.rs b/src/ui.rs
@@ -74,7 +74,9 @@ fn draw_help(f: &mut Frame, area: Rect, _app: &App) {
         Line::from(
             "Editing:       e Edit cell               | Enter Save   | Esc Cancel  | Ctrl-d Set NULL | u Undo last change",
         ),
-        Line::from("Filter:        / Begin filter  | Enter Apply  | Esc Clear (also in normal mode)"),
+        Line::from(
+            "Filter:        / Begin filter  | Enter Apply  | Esc Clear (also in normal mode)",
+        ),
         Line::from("Sorting:       s Cycle sort by column     | S Toggle direction"),
         Line::from("Copy:          c Copy cell | C Copy row | Ctrl+C Copy page (TSV)"),
         Line::from("Autosize:      a Autosize column | A Autosize all"),
@@ -94,25 +96,25 @@ fn draw_tables(f: &mut Frame, area: Rect, app: &App) {
         .collect();
 
     // Visually indicate focus on the Tables pane by changing border color and title
-    let title = if app.focus == Focus::Tables { "Tables ◀" } else { "Tables" };
+    let title = if app.focus == Focus::Tables {
+        "Tables ◀"
+    } else {
+        "Tables"
+    };
     let block = if app.focus == Focus::Tables {
         Block::default()
             .borders(Borders::ALL)
             .border_style(Style::default().fg(Color::Cyan))
             .title(title)
     } else {
-        Block::default()
-            .borders(Borders::ALL)
-            .title(title)
+        Block::default().borders(Borders::ALL).title(title)
     };
 
-    let list = List::new(items)
-        .block(block)
-        .highlight_style(
-            Style::default()
-                .add_modifier(Modifier::BOLD)
-                .fg(Color::Yellow),
-        );
+    let list = List::new(items).block(block).highlight_style(
+        Style::default()
+            .add_modifier(Modifier::BOLD)
+            .fg(Color::Yellow),
+    );
 
     f.render_stateful_widget(list, area, &mut list_state(app));
 }
@@ -169,7 +171,11 @@ fn draw_data(f: &mut Frame, area: Rect, app: &mut App) {
     } else {
         "Data".to_string()
     };
-    let title = if app.focus == Focus::Data { format!("{base_title} ◀") } else { base_title };
+    let title = if app.focus == Focus::Data {
+        format!("{base_title} ◀")
+    } else {
+        base_title
+    };
     let block = if app.focus == Focus::Data {
         Block::default()
             .borders(Borders::ALL)
@@ -222,9 +228,10 @@ fn draw_data(f: &mut Frame, area: Rect, app: &mut App) {
             app.autosize_all_request = false;
             app.autosize_col_request = None;
         } else if let Some(i) = app.autosize_col_request.take()
-            && i < cols {
-                app.col_abs_widths[i] = measure_column_width(app, i);
-            }
+            && i < cols
+        {
+            app.col_abs_widths[i] = measure_column_width(app, i);
+        }
     }
     // Table inside inner area
     let widths = column_widths(
@@ -244,7 +251,12 @@ fn draw_data(f: &mut Frame, area: Rect, app: &mut App) {
         let mut cells = Vec::with_capacity(row.len());
         for (c_idx, val) in row.iter().enumerate() {
             // Live editing view: render edit buffer with a visible cursor for the editing cell.
-            let mut cell = if let AppMode::Editing { row: erow, col: ecol, cursor } = app.mode {
+            let mut cell = if let AppMode::Editing {
+                row: erow,
+                col: ecol,
+                cursor,
+            } = app.mode
+            {
                 if r_idx == erow && c_idx == ecol {
                     let buf = app.edit_buffer.as_str();
                     let cur = cursor.min(buf.len());
@@ -259,7 +271,12 @@ fn draw_data(f: &mut Frame, area: Rect, app: &mut App) {
             };
 
             // Highlight selection, and use a distinct highlight for the editing cell.
-            if let AppMode::Editing { row: erow, col: ecol, .. } = app.mode {
+            if let AppMode::Editing {
+                row: erow,
+                col: ecol,
+                ..
+            } = app.mode
+            {
                 if r_idx == erow && c_idx == ecol {
                     cell = cell.style(Style::default().bg(Color::Yellow).fg(Color::Black));
                 } else if r_idx == app.sel_row && c_idx == app.sel_col {
@@ -329,8 +346,6 @@ fn column_widths(total_width: u16, cols: usize, tiers: &[u8], abs: &[u16]) -> Ve
         .collect()
 }
 
-
-
 // Measure the width (in characters) required to fully display a column,
 // considering both header and current page rows. Adds small padding.
 fn measure_column_width(app: &App, col: usize) -> u16 {
