[textinput] more hotkeys

Author: tstack

NEWS.md

@@ -11,7 +11,7 @@ Features:
 * The DB view now shows a status bar above the bottom
   status bar with the SQL query that populated the view,
   the relative time when it was run, and how long it took.
-  A reload icon at the left side of the bar can be clicked
+  A reload icon on the left side of the bar can be clicked
   to re-run the query.  For queries that read from log-backed
   tables, the status bar also calls out whether the results
   are "on current log data" or "on old log data" relative to
@@ -26,6 +26,18 @@ Features:
   - `⌘-X` to cut the current selection to the
     clipboard.
   - `⌘-Z` to undo the last change.
+* Additional readline-style key bindings in the
+  prompt (issue #1676):
+  - `ALT-f` / `ALT-b` move forward/backward by word.
+  - `ALT-d` cuts to the end of the next word.
+  - `ALT-BACKSPACE` is an alias for `CTRL-W`.
+  - `ALT-l` / `ALT-u` lower- or upper-case the
+    next word.
+  - `ALT-c` capitalizes the next word.
+  - `CTRL-h` and `CTRL-d` are aliases for
+    BACKSPACE and DELETE.
+  - `CTRL-t` transposes the two characters before
+    the cursor.
 * The `measure_with_units` collator now recognizes
   (KiB, MiB, ...).
 
@@ -40,6 +52,8 @@ Bug Fixes:
   read and crash in some situations.
 * Fix a lockup when viewing a file that contained log
   messages and lots of binary data.
+* Update Regex101 import functionality to handle a
+  change in their API response.
 * More hardening for some diabolical inputs:
   - Unsupported escape-sequences were ignored before,
     but they are displayed now.

docs/source/hotkeys.rst

@@ -389,6 +389,12 @@ editing:
     * - :kbd:`Shift` + :kbd:`→`
       -
       - Move right one character and include it in the selection
+    * - :kbd:`Alt` + :kbd:`←`
+      - :kbd:`Alt` + :kbd:`b`
+      - Move to the start of the previous word
+    * - :kbd:`Alt` + :kbd:`→`
+      - :kbd:`Alt` + :kbd:`f`
+      - Move to the start of the next word
     * - :kbd:`↑`
       - :kbd:`Ctrl` + :kbd:`P`
       - In single-line mode, search the history with the current contents.
@@ -404,15 +410,30 @@ editing:
     * - :kbd:`Ctrl` + :kbd:`E`
       -
       - Move to the end of the line
+    * - :kbd:`Ctrl` + :kbd:`T`
+      -
+      - Transpose the two characters before the cursor
+    * - :kbd:`Alt` + :kbd:`l`
+      -
+      - Convert the next word to lower-case and move to the end of it
+    * - :kbd:`Alt` + :kbd:`u`
+      -
+      - Convert the next word to upper-case and move to the end of it
+    * - :kbd:`Alt` + :kbd:`c`
+      -
+      - Capitalize the next word and move to the end of it
     * - :kbd:`Ctrl` + :kbd:`K`
       -
       - Cut to the end of the line into the clipboard
     * - :kbd:`Ctrl` + :kbd:`U`
       -
       - Cut from the beginning of the line to the cursor into the clipboard
     * - :kbd:`Ctrl` + :kbd:`W`
-      -
+      - :kbd:`Alt` + :kbd:`Backspace`
       - Cut from the beginning of the previous word into the clipboard
+    * - :kbd:`Alt` + :kbd:`d`
+      -
+      - Cut to the end of the next word into the clipboard
     * - :kbd:`Ctrl` + :kbd:`Y`
       -
       - Paste the clipboard contents

src/base/intern_string.cc

@@ -577,57 +577,77 @@ string_fragment::byte_to_column_index(const size_t byte_index) const
     return curr_col;
 }
 
-static bool
-iswordbreak(wchar_t wchar)
+enum class word_char_class {
+    space,
+    word,
+    symbol,
+};
+
+static word_char_class
+classify_word_char(wchar_t wchar)
 {
-    static constexpr uint32_t mask
+    if (uc_is_property_white_space(wchar)) {
+        return word_char_class::space;
+    }
+    static constexpr uint32_t word_mask
         = UC_CATEGORY_MASK_L | UC_CATEGORY_MASK_N | UC_CATEGORY_MASK_Pc;
-    return !uc_is_general_category_withtable(wchar, mask);
+    if (uc_is_general_category_withtable(wchar, word_mask)) {
+        return word_char_class::word;
+    }
+    return word_char_class::symbol;
+}
+
+static bool
+is_word_start(word_char_class curr_class, word_char_class prev_class)
+{
+    if (curr_class == word_char_class::word
+        && prev_class != word_char_class::word)
+    {
+        return true;
+    }
+    if (curr_class == word_char_class::symbol
+        && prev_class == word_char_class::space)
+    {
+        return true;
+    }
+    return false;
 }
 
 std::optional<int>
 string_fragment::next_word(const int start_col) const
 {
     auto index = this->sf_begin;
     int curr_col = 0;
-    auto in_word = false;
+    auto prev_class = word_char_class::space;
 
     while (index < this->sf_end) {
         auto read_res = ww898::utf::utf8::read(
             [this, &index]() { return this->sf_string[index++]; });
         if (read_res.isErr()) {
             curr_col += 1;
-        } else {
-            auto ch = read_res.unwrap();
+            continue;
+        }
+        auto ch = read_res.unwrap();
+
+        if (ch == '\t') {
+            prev_class = word_char_class::space;
+            do {
+                curr_col += 1;
+            } while (curr_col % 8);
+            continue;
+        }
 
-            switch (ch) {
-                case '\t':
-                    do {
-                        curr_col += 1;
-                    } while (curr_col % 8);
-                    break;
-                default: {
-                    auto wcw_res = uc_width(read_res.unwrap(), "UTF-8");
-                    if (wcw_res < 0) {
-                        wcw_res = 1;
-                    }
+        auto wcw_res = uc_width(ch, "UTF-8");
+        if (wcw_res < 0) {
+            wcw_res = 1;
+        }
 
-                    if (curr_col == start_col) {
-                        in_word = !iswordbreak(ch);
-                    } else if (curr_col > start_col) {
-                        if (in_word) {
-                            if (iswordbreak(ch)) {
-                                in_word = false;
-                            }
-                        } else if (!iswordbreak(ch)) {
-                            return curr_col;
-                        }
-                    }
-                    curr_col += wcw_res;
-                    break;
-                }
-            }
+        auto curr_class = classify_word_char(ch);
+        if (curr_col > start_col && is_word_start(curr_class, prev_class)) {
+            return curr_col;
         }
+        prev_class = curr_class;
+        curr_col += wcw_res;
     }
 
     return std::nullopt;
@@ -638,50 +658,130 @@ string_fragment::prev_word(const int start_col) const
 {
     auto index = this->sf_begin;
     int curr_col = 0;
-    auto in_word = false;
+    auto prev_class = word_char_class::space;
     std::optional<int> last_word_col;
 
     while (index < this->sf_end) {
         auto read_res = ww898::utf::utf8::read(
             [this, &index]() { return this->sf_string[index++]; });
         if (read_res.isErr()) {
             curr_col += 1;
-        } else {
-            auto ch = read_res.unwrap();
-
-            switch (ch) {
-                case '\t':
-                    do {
-                        curr_col += 1;
-                    } while (curr_col % 8);
-                    break;
-                default: {
-                    auto wcw_res = uc_width(read_res.unwrap(), "UTF-8");
-                    if (wcw_res < 0) {
-                        wcw_res = 1;
-                    }
+            continue;
+        }
+        auto ch = read_res.unwrap();
 
-                    if (curr_col == start_col) {
-                        return last_word_col;
-                    }
-                    if (iswordbreak(ch)) {
-                        in_word = false;
-                    } else {
-                        if (!in_word) {
-                            last_word_col = curr_col;
-                        }
-                        in_word = true;
-                    }
-                    curr_col += wcw_res;
-                    break;
-                }
+        if (ch == '\t') {
+            if (curr_col >= start_col) {
+                return last_word_col;
             }
+            prev_class = word_char_class::space;
+            do {
+                curr_col += 1;
+            } while (curr_col % 8);
+            continue;
+        }
+
+        if (curr_col >= start_col) {
+            return last_word_col;
+        }
+
+        auto wcw_res = uc_width(ch, "UTF-8");
+        if (wcw_res < 0) {
+            wcw_res = 1;
         }
+
+        auto curr_class = classify_word_char(ch);
+        if (is_word_start(curr_class, prev_class)) {
+            last_word_col = curr_col;
+        }
+        prev_class = curr_class;
+        curr_col += wcw_res;
     }
 
     return last_word_col;
 }
 
+std::optional<int>
+string_fragment::curr_word(const int start_col) const
+{
+    auto index = this->sf_begin;
+    int curr_col = 0;
+    auto prev_class = word_char_class::space;
+    std::optional<int> last_word_col;
+
+    while (index < this->sf_end) {
+        auto read_res = ww898::utf::utf8::read(
+            [this, &index]() { return this->sf_string[index++]; });
+        if (read_res.isErr()) {
+            curr_col += 1;
+            continue;
+        }
+        auto ch = read_res.unwrap();
+
+        if (ch == '\t') {
+            if (curr_col >= start_col) {
+                return std::nullopt;
+            }
+            prev_class = word_char_class::space;
+            do {
+                curr_col += 1;
+            } while (curr_col % 8);
+            continue;
+        }
+
+        auto wcw_res = uc_width(ch, "UTF-8");
+        if (wcw_res < 0) {
+            wcw_res = 1;
+        }
+
+        auto curr_class = classify_word_char(ch);
+
+        if (start_col < curr_col + wcw_res) {
+            if (curr_class == word_char_class::space) {
+                return std::nullopt;
+            }
+            if (is_word_start(curr_class, prev_class)) {
+                return curr_col;
+            }
+            return last_word_col;
+        }
+
+        if (is_word_start(curr_class, prev_class)) {
+            last_word_col = curr_col;
+        }
+        prev_class = curr_class;
+        curr_col += wcw_res;
+    }
+
+    return std::nullopt;
+}
+
+std::string
+string_fragment::transform_codepoints(
+    const std::function<uint32_t(uint32_t)>& xform) const
+{
+    std::string out;
+    out.reserve(this->length());
+
+    auto index = this->sf_begin;
+    while (index < this->sf_end) {
+        auto byte_before = index;
+        auto read_res = ww898::utf::utf8::read(
+            [this, &index]() { return this->sf_string[index++]; });
+        if (read_res.isErr()) {
+            for (auto j = byte_before; j < index; ++j) {
+                out.push_back(this->sf_string[j]);
+            }
+            continue;
+        }
+        auto cp = read_res.unwrap();
+        auto new_cp = xform(cp);
+        ww898::utf::utf8::write(
+            new_cp, [&out](const char b) { out.push_back(b); });
+    }
+    return out;
+}
+
 size_t
 string_fragment::column_width() const
 {

src/base/intern_string.hh

@@ -32,6 +32,7 @@
 #ifndef intern_string_hh
 #define intern_string_hh
 
+#include <functional>
 #include <optional>
 #include <ostream>
 #include <string>
@@ -362,6 +363,10 @@ struct string_fragment {
 
     std::optional<int> next_word(int start_col) const;
     std::optional<int> prev_word(int start_col) const;
+    std::optional<int> curr_word(int start_col) const;
+
+    std::string transform_codepoints(
+        const std::function<uint32_t(uint32_t)>& xform) const;
 
     template<typename P>
     string_fragment find_left_boundary(size_t start,