[filter-ui] fix history

Author: tstack

src/command_executor.cc

@@ -1274,7 +1274,7 @@ exec_context::execute(source_location loc, const std::string& cmdline)
 
     auto before_dls_gen = dls.dls_generation;
     if (this->get_provenance<mouse_input>() && !prompt.p_editor.is_enabled()) {
-        auto& hist = prompt.get_history_for(cmdline[0]);
+        auto& hist = prompt.get_history_for();
         hist_guard = hist.start_operation(cmdline.substr(1));
     }
 

src/filter_sub_source.cc

@@ -54,25 +54,24 @@
 using namespace lnav::roles::literals;
 
 filter_sub_source::filter_sub_source(std::shared_ptr<textinput_curses> editor)
-    : fss_editor(std::move(editor)),
-      fss_regexp_history(
-          lnav::textinput::history::for_context("regexp-filter"_frag)),
-      fss_sql_history(lnav::textinput::history::for_context("sql-filter"_frag))
+    : fss_editor(std::move(editor))
 {
+    static auto& prompt = lnav::prompt::get();
+
     this->fss_editor->set_visible(false);
     this->fss_editor->set_x(28);
     this->fss_editor->tc_popup.set_title("Pattern");
     this->fss_editor->tc_height = 1;
     this->fss_editor->tc_on_change
         = bind_mem(&filter_sub_source::rl_change, this);
     this->fss_editor->tc_on_history_search
-        = bind_mem(&filter_sub_source::rl_history, this);
+        = bind_mem(&lnav::prompt::rl_history_search, &prompt);
     this->fss_editor->tc_on_history_list
-        = bind_mem(&filter_sub_source::rl_history, this);
+        = bind_mem(&lnav::prompt::rl_history_list, &prompt);
     this->fss_editor->tc_on_completion_request
         = bind_mem(&filter_sub_source::rl_completion_request, this);
     this->fss_editor->tc_on_completion
-        = bind_mem(&filter_sub_source::rl_completion, this);
+        = bind_mem(&lnav::prompt::rl_completion, &prompt);
     this->fss_editor->tc_on_perform
         = bind_mem(&filter_sub_source::rl_perform, this);
     this->fss_editor->tc_on_blur = bind_mem(&filter_sub_source::rl_blur, this);
@@ -433,42 +432,22 @@ filter_sub_source::text_size_for_line(textview_curses& tc,
 void
 filter_sub_source::rl_change(textinput_curses& rc)
 {
+    static auto& prompt = lnav::prompt::get();
+
+    if (rc.tc_popup_type == textinput_curses::popup_type_t::history
+        && !prompt.p_replace_from_history)
+    {
+        rc.tc_on_history_search(rc);
+        return;
+    }
+
     auto* top_view = *lnav_data.ld_view_stack.top();
     auto rows = this->rows_for(top_view);
     auto& row = rows[this->tss_view->get_selection().value()];
 
     row->ti_change(top_view, rc);
 }
 
-void
-filter_sub_source::rl_history(textinput_curses& tc)
-{
-    switch (tc.tc_text_format) {
-        case text_format_t::TF_PCRE: {
-            std::vector<attr_line_t> poss;
-            this->fss_regexp_history.query_entries(
-                tc.get_content(), [&poss, &tc](const auto& e) {
-                    auto al
-                        = attr_line_t::from_table_cell_content(e.e_content,
-                                                               tc.get_width())
-                              .highlight_fuzzy_matches(tc.get_content())
-                              .with_attr_for_all(
-                                  lnav::prompt::SUBST_TEXT.value(e.e_content));
-                    poss.emplace_back(al);
-                });
-            tc.open_popup_for_history(poss);
-            break;
-        }
-        case text_format_t::TF_PLAINTEXT:
-        case text_format_t::TF_SQL: {
-            break;
-        }
-        default:
-            ensure(false);
-            break;
-    }
-}
-
 void
 filter_sub_source::rl_completion_request_int(textinput_curses& tc,
                                              completion_request_type_t crt)
@@ -1014,6 +993,10 @@ filter_sub_source::text_filter_row::prime_text_input(textview_curses* top_view,
 {
     static auto& prompt = lnav::prompt::get();
 
+    auto context = this->tfr_filter->get_lang() == filter_lang_t::SQL
+        ? lnav::prompt::context_t::sql_filter
+        : lnav::prompt::context_t::regex_filter;
+    prompt.focus_for(*top_view, ti, context, '\0', {});
     ti.tc_text_format = this->tfr_filter->get_lang() == filter_lang_t::SQL
         ? text_format_t::TF_SQL
         : text_format_t::TF_PCRE;
@@ -1210,6 +1193,7 @@ filter_sub_source::text_filter_row::ti_perform(textview_curses* top_view,
                                                filter_sub_source& parent)
 {
     static const intern_string_t INPUT_SRC = intern_string::lookup("input");
+    static auto& prompt = lnav::prompt::get();
 
     auto* tss = top_view->get_sub_source();
     auto& fs = tss->get_filters();
@@ -1249,7 +1233,7 @@ filter_sub_source::text_filter_row::ti_perform(textview_curses* top_view,
                         this->tfr_filter->get_index(),
                         code_ptr);
 
-                    parent.fss_regexp_history.insert_plain_content(new_value);
+                    prompt.get_history_for().insert_plain_content(new_value);
 
                     auto iter
                         = std::find(fs.begin(), fs.end(), this->tfr_filter);
@@ -1289,6 +1273,7 @@ filter_sub_source::text_filter_row::ti_perform(textview_curses* top_view,
                     lnav_data.ld_exec_context.ec_msg_callback_stack.back()(um);
                     this->ti_abort(top_view, ti, parent);
                 } else {
+                    prompt.get_history_for().insert_plain_content(new_value);
                     lnav_data.ld_log_source.set_sql_filter(new_value,
                                                            stmt.release());
                     tss->text_filters_changed();

src/filter_sub_source.hh

@@ -95,8 +95,6 @@ public:
 
     void rl_change(textinput_curses& rc);
 
-    void rl_history(textinput_curses& tc);
-
     enum class completion_request_type_t {
         partial,
         full,
@@ -266,8 +264,6 @@ public:
     }
 
     std::shared_ptr<textinput_curses> fss_editor;
-    lnav::textinput::history fss_regexp_history;
-    lnav::textinput::history fss_sql_history;
     std::unordered_set<std::string> fss_view_text_possibilities;
     attr_line_t fss_curr_line;
     log_level_t fss_curr_level;

src/lnav.prompt.cc

@@ -30,6 +30,7 @@
 #include <filesystem>
 #include <string>
 #include <unordered_set>
+#include <vector>
 
 #include "lnav.prompt.hh"
 
@@ -207,6 +208,8 @@ prompt::get()
         textinput::history::for_context("cmd"_frag),
         textinput::history::for_context("search"_frag),
         textinput::history::for_context("script"_frag),
+        textinput::history::for_context("regexp-filter"_frag),
+        lnav::textinput::history::for_context("sql-filter"_frag),
     };
 
     return retval;
@@ -287,36 +290,41 @@ prompt::refresh_sql_expr_completions(textview_curses& tc)
 
 void
 prompt::focus_for(textview_curses& tc,
+                  textinput_curses& editor,
+                  context_t context,
                   char sigil,
                   const std::vector<std::string>& args)
 {
-    this->p_editor.tc_suggestion.clear();
+    editor.tc_suggestion.clear();
     this->p_remote_paths.clear();
-    switch (sigil) {
-        case '|': {
+    this->p_current_context = context;
+    switch (context) {
+        case context_t::script: {
             this->p_scripts = find_format_scripts(lnav_data.ld_config_paths);
             break;
         }
-        case ':': {
+        case context_t::cmd: {
             this->refresh_config_completions();
             this->refresh_sql_completions(tc);
             this->refresh_sql_expr_completions(tc);
             break;
         }
-        case ';': {
+        case context_t::sql: {
             this->refresh_sql_completions(tc);
             break;
         }
+        default:
+            break;
     }
 
     for (const auto& [key, item] : this->p_sql_completions) {
         this->p_sql_completion_terms.emplace(key);
     }
 
     this->p_env_vars.clear();
-    switch (sigil) {
-        case ':':
-        case '|': {
+    switch (context) {
+        case context_t::cmd:
+        case context_t::script: {
             for (char** var = environ; *var != nullptr; var++) {
                 auto pair_sf = string_fragment::from_c_str(*var);
                 auto split_sf = pair_sf.split_when(string_fragment::tag1{'='});
@@ -330,17 +338,17 @@ prompt::focus_for(textview_curses& tc,
             break;
     }
 
-    this->p_editor.tc_prefix.clear();
+    editor.tc_prefix.clear();
     if (args.size() >= 3) {
-        this->p_editor.tc_prefix.al_string = args[2];
+        editor.tc_prefix.al_string = args[2];
     } else if (sigil) {
-        this->p_editor.tc_prefix.al_string.push_back(sigil);
+        editor.tc_prefix.al_string.push_back(sigil);
     }
-    this->p_editor.set_height(1);
-    this->p_editor.set_content(cget(args, 3).value_or(""));
-    this->p_editor.move_cursor_to(textinput_curses::input_point::end());
-    this->p_editor.tc_popup.set_title("");
-    this->p_editor.focus();
+    editor.set_height(1);
+    editor.set_content(cget(args, 3).value_or(""));
+    editor.move_cursor_to(textinput_curses::input_point::end());
+    editor.tc_popup.set_title("");
+    editor.focus();
 }
 
 void
@@ -477,31 +485,30 @@ prompt::rl_history_search(textinput_curses& tc)
 void
 prompt::rl_history(textinput_curses& tc)
 {
-    auto sigil = tc.tc_prefix.al_string.front();
-    auto& hist = this->get_history_for(sigil);
+    auto& hist = this->get_history_for();
     auto width = tc.get_width() - 1;
     auto pattern = tc.get_content();
     std::vector<attr_line_t> poss;
-    auto cb = [&poss, sigil, width, &pattern](
+    auto cb = [&poss, this, width, &pattern](
                   const textinput::history::entry& e) {
         auto icon = e.e_status == log_level_t::LEVEL_ERROR ? ui_icon_t::error
                                                            : ui_icon_t::ok;
         auto al = attr_line_t::from_table_cell_content(e.e_content, width)
                       .highlight_fuzzy_matches(pattern)
                       .with_attr_for_all(SUBST_TEXT.value(e.e_content));
-        switch (sigil) {
-            case ':':
+        switch (this->p_current_context) {
+            case context_t::cmd:
                 readline_command_highlighter(al, std::nullopt);
                 al.insert(0, "  ");
                 al.al_attrs.emplace_back(line_range{0, 1}, VC_ICON.value(icon));
                 break;
-            case ';':
+            case context_t::sql:
                 readline_sql_highlighter(
                     al, lnav::sql::dialect::sqlite, std::nullopt);
                 al.insert(0, "  ");
                 al.al_attrs.emplace_back(line_range{0, 1}, VC_ICON.value(icon));
                 break;
-            case '/':
+            case context_t::search:
                 readline_regex_highlighter(al, std::nullopt);
                 break;
         }
@@ -517,11 +524,11 @@ prompt::rl_history(textinput_curses& tc)
 void
 prompt::rl_completion(textinput_curses& tc)
 {
-    if (this->p_editor.tc_popup_type == textinput_curses::popup_type_t::history
+    if (tc.tc_popup_type == textinput_curses::popup_type_t::history
         && this->p_replace_from_history)
     {
-        this->p_editor.blur();
-        this->p_editor.tc_on_perform(tc);
+        tc.blur();
+        tc.tc_on_perform(tc);
         return;
     }
 
@@ -553,8 +560,8 @@ prompt::rl_popup_change(textinput_curses& tc)
         return;
     }
 
-    if (this->p_history_changes > 0 && !this->p_editor.tc_change_log.empty()) {
-        this->p_editor.tc_change_log.pop_back();
+    if (this->p_history_changes > 0 && !tc.tc_change_log.empty()) {
+        tc.tc_change_log.pop_back();
     }
 
     const auto& al

src/lnav.prompt.hh

@@ -40,7 +40,6 @@
 #include "base/string_attr_type.hh"
 #include "format.scripts.hh"
 #include "help_text.hh"
-#include "lnav.prompt.hh"
 #include "mapbox/variant.hpp"
 #include "textinput.history.hh"
 #include "textinput_curses.hh"
@@ -90,27 +89,44 @@ struct prompt {
         role_t sim_role;
     };
 
+    enum class context_t {
+        none,
+        sql,
+        cmd,
+        search,
+        script,
+        regex_filter,
+        sql_filter,
+    };
+
     lnav::textinput::history p_sql_history;
     lnav::textinput::history p_cmd_history;
     lnav::textinput::history p_search_history;
     lnav::textinput::history p_script_history;
+    lnav::textinput::history p_regexp_filter_history;
+    lnav::textinput::history p_sql_filter_history;
 
-    lnav::textinput::history& get_history_for(char sigil)
+    lnav::textinput::history& get_history_for()
     {
-        switch (sigil) {
-            case ':':
+        switch (this->p_current_context) {
+            case context_t::cmd:
                 return this->p_cmd_history;
-            case ';':
+            case context_t::sql:
                 return this->p_sql_history;
-            case '/':
+            case context_t::search:
                 return this->p_search_history;
-            case '|':
+            case context_t::script:
                 return this->p_script_history;
+            case context_t::regex_filter:
+                return this->p_regexp_filter_history;
+            case context_t::sql_filter:
+                return this->p_sql_filter_history;
             default:
                 ensure(false);
         }
     }
 
+    context_t p_current_context{context_t::none};
     std::map<std::string, std::string> p_env_vars;
     std::multimap<std::string, sql_item_t, strnatcaseless> p_sql_completions;
     std::set<std::string, strnatless> p_sql_completion_terms;
@@ -127,6 +143,8 @@ struct prompt {
     int32_t p_history_changes{0};
 
     void focus_for(textview_curses& tc,
+                   textinput_curses& editor,
+                   context_t context,
                    char sigil,
                    const std::vector<std::string>& args);