fix: Only show range selection when in range-select mode

docs/index.md

@@ -63,6 +63,9 @@ will clear the numeric prefix if you want to cancel it.
 
 * `Ctrl-r` will enter range selection mode
 * `Ctrl-s` will save the sheet.
+* `Ctrl-c`, `y` Copy the cell or range contents.
+* `Ctrl-v`, `p` Paste into the sheet.
+* `Ctrl-Shift-C` Copy the cell or range formatted content.
 * `q` will exit the application.
 * `:` will enter CommandMode.
 
@@ -129,6 +132,8 @@ select mode from CellEdit mode with `CTRL-r`.
 
 * `h`, `j`, `k`, `l` will navigate around the sheet.
 * `Ctrl-n`, `Ctrl-p` will navigate between sheets.
+* `Ctrl-c`, `y` Copy the cell or range contents.
+* `Ctrl-Shift-C`, 'Y' Copy the cell or range formatted content.
 * `The spacebar will select the start and end of the range respectively.
 * `d` will delete the contents of the range leaving any style untouched
 * `D` will delete the contents of the range including any style

src/book/mod.rs

@@ -158,6 +158,15 @@ impl Book {
             .get_formatted_cell_value(self.current_sheet, *row as i32, *col as i32)
             .map_err(|s| anyhow!("Unable to format cell {}", s))?)
     }
+    
+    /// Get a cells actual content unformatted as a string.
+    pub fn get_cell_addr_contents(&self, Address { row, col }: &Address) -> Result<String> {
+        Ok(self
+            .model
+            .get_cell_content(self.current_sheet, *row as i32, *col as i32)
+            .map_err(|s| anyhow!("Unable to format cell {}", s))?)
+    }
+
 
     /// Get a cells actual content as a string.
     pub fn get_current_cell_contents(&self) -> Result<String> {
@@ -174,13 +183,13 @@ impl Book {
     /// Update the current cell in a book.
     /// This update won't be reflected until you call `Book::evaluate`.
     pub fn edit_current_cell<S: Into<String>>(&mut self, value: S) -> Result<()> {
-        self.update_entry(&self.location.clone(), value)?;
+        self.update_cell(&self.location.clone(), value)?;
         Ok(())
     }
 
     /// Update an entry in the current sheet for a book.
     /// This update won't be reflected until you call `Book::evaluate`.
-    pub fn update_entry<S: Into<String>>(&mut self, location: &Address, value: S) -> Result<()> {
+    pub fn update_cell<S: Into<String>>(&mut self, location: &Address, value: S) -> Result<()> {
         self.model
             .set_user_input(
                 self.current_sheet,
@@ -349,7 +358,7 @@ impl Default for Book {
     fn default() -> Self {
         let mut book =
             Book::new(Model::new_empty("default_name", "en", "America/New_York").unwrap());
-        book.update_entry(&Address { row: 1, col: 1 }, "").unwrap();
+        book.update_cell(&Address { row: 1, col: 1 }, "").unwrap();
         book
     }
 }

src/book/test.rs

@@ -36,7 +36,7 @@ fn test_book_default() {
 #[test]
 fn test_book_insert_cell_new_row() {
     let mut book = Book::default();
-    book.update_entry(&Address { row: 2, col: 1 }, "1")
+    book.update_cell(&Address { row: 2, col: 1 }, "1")
         .expect("failed to edit cell");
     book.evaluate();
     let WorksheetDimension {
@@ -52,7 +52,7 @@ fn test_book_insert_cell_new_row() {
 #[test]
 fn test_book_insert_cell_new_column() {
     let mut book = Book::default();
-    book.update_entry(&Address { row: 1, col: 2 }, "1")
+    book.update_cell(&Address { row: 1, col: 2 }, "1")
         .expect("failed to edit cell");
     let WorksheetDimension {
         min_row,
@@ -67,7 +67,7 @@ fn test_book_insert_cell_new_column() {
 #[test]
 fn test_book_insert_rows() {
     let mut book = Book::default();
-    book.update_entry(&Address { row: 2, col: 2 }, "1")
+    book.update_cell(&Address { row: 2, col: 2 }, "1")
         .expect("failed to edit cell");
     book.move_to(&Address { row: 2, col: 2 })
         .expect("Failed to move to location");
@@ -85,7 +85,7 @@ fn test_book_insert_rows() {
 #[test]
 fn test_book_insert_columns() {
     let mut book = Book::default();
-    book.update_entry(&Address { row: 2, col: 2 }, "1")
+    book.update_cell(&Address { row: 2, col: 2 }, "1")
         .expect("failed to edit cell");
     book.move_to(&Address { row: 2, col: 2 })
         .expect("Failed to move to location");
@@ -103,7 +103,7 @@ fn test_book_insert_columns() {
 #[test]
 fn test_book_col_size() {
     let mut book = Book::default();
-    book.update_entry(&Address { row: 2, col: 2 }, "1")
+    book.update_cell(&Address { row: 2, col: 2 }, "1")
         .expect("failed to edit cell");
     book.set_col_size(1, 20).expect("Failed to set column size");
     assert_eq!(20, book.get_col_size(1).expect("Failed to get column size"));

src/ui/mod.rs

@@ -66,6 +66,12 @@ impl RangeSelection {
     }
 }
 
+#[derive(Debug)]
+pub enum ClipboardContents {
+    Cell(String),
+    Range(Vec<Vec<String>>),
+}
+
 #[derive(Debug)]
 pub struct AppState<'ws> {
     pub modality_stack: Vec<Modality>,
@@ -75,6 +81,7 @@ pub struct AppState<'ws> {
     pub range_select: RangeSelection,
     dirty: bool,
     popup: Vec<String>,
+    clipboard: Option<ClipboardContents>,
 }
 
 impl<'ws> Default for AppState<'ws> {
@@ -87,6 +94,7 @@ impl<'ws> Default for AppState<'ws> {
             range_select: Default::default(),
             dirty: Default::default(),
             popup: Default::default(),
+            clipboard: Default::default(),
         }
     }
 }
@@ -533,12 +541,7 @@ impl<'ws> Workspace<'ws> {
                     self.maybe_update_range_end();
                 }
                 KeyCode::Char(' ') | KeyCode::Enter => {
-                    if self.state.range_select.start.is_none() {
-                        self.state.range_select.start = Some(self.book.location.clone());
-                    } else {
-                        self.state.range_select.end = Some(self.book.location.clone());
-                        self.exit_range_select_mode()?;
-                    }
+                    self.update_range_selection()?;
                 }
                 KeyCode::Char('n') if key.modifiers == KeyModifiers::CONTROL => {
                     self.state.range_select.reset_range_selection();
@@ -556,6 +559,19 @@ impl<'ws> Workspace<'ws> {
                     })?;
                     self.state.range_select.sheet = Some(self.book.current_sheet);
                 }
+                KeyCode::Char('C')
+                    if key
+                        .modifiers
+                        .contains(KeyModifiers::CONTROL | KeyModifiers::SHIFT) =>
+                {
+                    // TODO(zaphar): Share the algorithm below between both copies
+                    self.copy_range(true)?;
+                }
+                KeyCode::Char('Y') => self.copy_range(true)?,
+                KeyCode::Char('c') if key.modifiers == KeyModifiers::CONTROL => {
+                    self.copy_range(false)?;
+                }
+                KeyCode::Char('y') => self.copy_range(false)?,
                 _ => {
                     // moop
                 }
@@ -564,6 +580,59 @@ impl<'ws> Workspace<'ws> {
         Ok(None)
     }
 
+    fn copy_range(&mut self, formatted: bool) -> Result<(), anyhow::Error> {
+        self.update_range_selection()?;
+        match &self.state.range_select.get_range() {
+            Some((
+                Address {
+                    row: row_start,
+                    col: col_start,
+                },
+                Address {
+                    row: row_end,
+                    col: col_end,
+                },
+            )) => {
+                let mut rows = Vec::new();
+                for ri in (*row_start)..=(*row_end) {
+                    let mut cols = Vec::new();
+                    for ci in (*col_start)..=(*col_end) {
+                        cols.push(if formatted {
+                            self.book
+                                .get_cell_addr_rendered(&Address { row: ri, col: ci })?
+                        } else {
+                            self.book
+                                .get_cell_addr_contents(&Address { row: ri, col: ci })?
+                        });
+                    }
+                    rows.push(cols);
+                }
+                self.state.clipboard = Some(ClipboardContents::Range(rows));
+            }
+            None => {
+                self.state.clipboard = Some(ClipboardContents::Cell(if formatted {
+                    self.book
+                        .get_current_cell_rendered()?
+                } else {
+                    self.book
+                        .get_current_cell_contents()?
+                }));
+            }
+        }
+        self.exit_range_select_mode()?;
+        Ok(())
+    }
+
+    fn update_range_selection(&mut self) -> Result<(), anyhow::Error> {
+        Ok(if self.state.range_select.start.is_none() {
+            self.state.range_select.start = Some(self.book.location.clone());
+            self.state.range_select.end = Some(self.book.location.clone());
+        } else {
+            self.state.range_select.end = Some(self.book.location.clone());
+            self.exit_range_select_mode()?;
+        })
+    }
+
     fn maybe_update_range_end(&mut self) {
         if self.state.range_select.start.is_some() {
             self.state.range_select.end = Some(self.book.location.clone());
@@ -591,6 +660,39 @@ impl<'ws> Workspace<'ws> {
                 KeyCode::Char('r') if key.modifiers == KeyModifiers::CONTROL => {
                     self.enter_range_select_mode();
                 }
+                KeyCode::Char('c') if key.modifiers == KeyModifiers::CONTROL => {
+                    self.state.clipboard = Some(ClipboardContents::Cell(
+                        self.book.get_current_cell_contents()?,
+                    ));
+                }
+                KeyCode::Char('y') => {
+                    self.state.clipboard = Some(ClipboardContents::Cell(
+                        self.book.get_current_cell_contents()?,
+                    ));
+                }
+                KeyCode::Char('Y') => {
+                    self.state.clipboard = Some(ClipboardContents::Cell(
+                        self.book.get_current_cell_rendered()?,
+                    ));
+                }
+                KeyCode::Char('C')
+                    if key
+                        .modifiers
+                        .contains(KeyModifiers::CONTROL | KeyModifiers::SHIFT) =>
+                {
+                    self.state.clipboard = Some(ClipboardContents::Cell(
+                        self.book.get_current_cell_rendered()?,
+                    ));
+                }
+                KeyCode::Char('v') if key.modifiers != KeyModifiers::CONTROL => {
+                    self.enter_range_select_mode()
+                }
+                KeyCode::Char('p') if key.modifiers != KeyModifiers::CONTROL => {
+                    self.paste_range()?;
+                }
+                KeyCode::Char('v') if key.modifiers == KeyModifiers::CONTROL => {
+                    self.paste_range()?;
+                }
                 KeyCode::Char('h') if key.modifiers == KeyModifiers::ALT => {
                     self.enter_dialog_mode(self.render_help_text());
                 }
@@ -703,6 +805,36 @@ impl<'ws> Workspace<'ws> {
         return Ok(None);
     }
 
+    fn paste_range(&mut self) -> Result<(), anyhow::Error> {
+        match &self.state.clipboard {
+            Some(ClipboardContents::Cell(contents)) => {
+                self.book.edit_current_cell(contents)?;
+            }
+            Some(ClipboardContents::Range(ref rows)) => {
+                let Address { row, col } = self.book.location.clone();
+                let row_len = rows.len();
+                for ri in 0..row_len {
+                    let columns = &rows[ri];
+                    let col_len = columns.len();
+                    for ci in 0..col_len {
+                        self.book.update_cell(
+                            &Address {
+                                row: ri + row,
+                                col: ci + col,
+                            },
+                            columns[ci].clone(),
+                        )?;
+                    }
+                }
+            }
+            None => {
+                // NOOP
+            }
+        }
+        self.state.clipboard = None;
+        Ok(())
+    }
+
     fn run_with_prefix(
         &mut self,
         action: impl Fn(&mut Workspace<'_>) -> std::result::Result<(), anyhow::Error>,

src/ui/render/mod.rs

@@ -28,25 +28,40 @@ impl<'ws> Workspace<'ws> {
         ];
         let mut rs: Vec<Box<dyn Fn(Rect, &mut Buffer, &mut Self)>> = vec![
             Box::new(|rect: Rect, buf: &mut Buffer, ws: &mut Self| {
-                let tabs = Tabs::new(ws.book.get_sheet_names().iter().enumerate().map(|(idx, name)| format!("{} {}", name, idx)).collect::<Vec<String>>())
-                    .select(Some(ws.book.current_sheet as usize));
+                let tabs = Tabs::new(
+                    ws.book
+                        .get_sheet_names()
+                        .iter()
+                        .enumerate()
+                        .map(|(idx, name)| format!("{} {}", name, idx))
+                        .collect::<Vec<String>>(),
+                )
+                .select(Some(ws.book.current_sheet as usize));
                 tabs.render(rect, buf);
             }),
             Box::new(|rect: Rect, buf: &mut Buffer, ws: &mut Self| {
-                let [text_rect, info_rect] = Layout::horizontal(vec![Constraint::Fill(1),Constraint::Fill(1)]).areas(rect);
+                let [text_rect, info_rect] =
+                    Layout::horizontal(vec![Constraint::Fill(1), Constraint::Fill(1)]).areas(rect);
                 ws.text_area.render(text_rect, buf);
                 let hint = Paragraph::new(vec![
                     Line::from(""),
-                    Line::from("ALT-h to toggle help dialog").centered()
+                    Line::from("ALT-h to toggle help dialog").centered(),
                 ]);
                 hint.render(info_rect, buf);
             }),
             Box::new(move |rect: Rect, buf: &mut Buffer, ws: &mut Self| {
                 let sheet_name = ws.book.get_sheet_name().unwrap_or("Unknown");
                 let table_block = Block::bordered().title_top(sheet_name);
-                let viewport = Viewport::new(&ws.book, &ws.state.range_select)
-                    .with_selected(ws.book.location.clone())
-                    .block(table_block);
+                let viewport = Viewport::new(
+                    &ws.book,
+                    if ws.state.modality() == &Modality::RangeSelect {
+                        Some(&ws.state.range_select)
+                    } else {
+                        None
+                    },
+                )
+                .with_selected(ws.book.location.clone())
+                .block(table_block);
                 StatefulWidget::render(viewport, rect, buf, &mut ws.state.viewport_state);
             }),
         ];

src/ui/render/test.rs

@@ -14,7 +14,7 @@ fn test_viewport_get_visible_columns() {
     let width = dbg!(dbg!(default_size) * 12 / 2);
     let app_state = AppState::default();
     let viewport =
-        Viewport::new(&book, &app_state.range_select).with_selected(Address { row: 1, col: 17 });
+        Viewport::new(&book, Some(&app_state.range_select)).with_selected(Address { row: 1, col: 17 });
     let cols = viewport
         .get_visible_columns((width + 5) as u16, &mut state)
         .expect("Failed to get visible columns");
@@ -31,7 +31,7 @@ fn test_viewport_get_visible_rows() {
     let height = 6;
     let app_state = AppState::default();
     let viewport =
-        Viewport::new(&book, &app_state.range_select).with_selected(Address { row: 17, col: 1 });
+        Viewport::new(&book, Some(&app_state.range_select)).with_selected(Address { row: 17, col: 1 });
     let rows = dbg!(viewport.get_visible_rows(height as u16, &mut state));
     assert_eq!(height - 1, rows.len());
     assert_eq!(
@@ -51,7 +51,7 @@ fn test_viewport_visible_columns_after_length_change() {
     let width = dbg!(dbg!(default_size) * 12 / 2);
     {
         let app_state = AppState::default();
-        let viewport = Viewport::new(&book, &app_state.range_select)
+        let viewport = Viewport::new(&book, Some(&app_state.range_select))
             .with_selected(Address { row: 1, col: 17 });
         let cols = viewport
             .get_visible_columns((width + 5) as u16, &mut state)
@@ -65,7 +65,7 @@ fn test_viewport_visible_columns_after_length_change() {
     {
         let app_state = AppState::default();
         let viewport =
-            Viewport::new(&book, &app_state.range_select).with_selected(Address { row: 1, col: 1 });
+            Viewport::new(&book, Some(&app_state.range_select)).with_selected(Address { row: 1, col: 1 });
         let cols = viewport
             .get_visible_columns((width + 5) as u16, &mut state)
             .expect("Failed to get visible columns");

src/ui/render/viewport.rs

@@ -37,7 +37,7 @@ pub struct ViewportState {
 pub struct Viewport<'ws> {
     pub(crate) selected: Address,
     book: &'ws Book,
-    range_selection: &'ws RangeSelection,
+    range_selection: Option<&'ws RangeSelection>,
     block: Option<Block<'ws>>,
 }
 
@@ -47,7 +47,7 @@ pub(crate) const COLNAMES: [&'static str; 26] = [
 ];
 
 impl<'ws> Viewport<'ws> {
-    pub fn new(book: &'ws Book, app_state: &'ws RangeSelection) -> Self {
+    pub fn new(book: &'ws Book, app_state: Option<&'ws RangeSelection>) -> Self {
         Self {
             book,
             range_selection: app_state,
@@ -161,7 +161,9 @@ impl<'ws> Viewport<'ws> {
                                 .get_cell_addr_rendered(&Address { row: ri, col: *ci })
                                 .unwrap();
                             let mut cell = Cell::new(Text::raw(content));
-                            if let Some((start, end)) = &self.range_selection.get_range() {
+                            if let Some((start, end)) =
+                                &self.range_selection.map_or(None, |r| r.get_range())
+                            {
                                 if ri >= start.row
                                     && ri <= end.row
                                     && *ci >= start.col