20284884426-2753

Committed 16 Dec 2025 10:23PM UTC coverage: 68.23% (-0.7%) from 68.903%

Build # 20284884426-2753

Build Type

push

github

Committed by

tstack

Commit Message

[log] show invalid utf hex dump in log view too

Run Details

25 of 25 new or added lines in 2 files covered. (100.0%)

503 existing lines in 33 files now uncovered.

51170 of 74996 relevant lines covered (68.23%)

433797.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/text_overlay_menu.cc

/**
 * Copyright (c) 2024, Timothy Stack
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * * Neither the name of Timothy Stack nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <vector>

#include "text_overlay_menu.hh"

#include "command_executor.hh"
#include "config.h"
#include "lnav.hh"
#include "lnav.prompt.hh"
#include "md4cpp.hh"
#include "readline_highlighters.hh"
#include "sysclip.hh"
#include "textview_curses.hh"

using namespace md4cpp::literals;
using namespace lnav::roles::literals;

std::vector<attr_line_t>
text_overlay_menu::list_overlay_menu(const listview_curses& lv, vis_line_t row)
{
    static constexpr auto MENU_WIDTH = 25;

    const auto* tc = dynamic_cast<const textview_curses*>(&lv);
    std::vector<attr_line_t> retval;

    if (tc->tc_text_selection_active || !tc->tc_selected_text) {
        return retval;
    }

    const auto* tss = tc->get_sub_source();
    const auto& sti = tc->tc_selected_text.value();
    const auto supports_filtering
        = tss != nullptr && tss->tss_supports_filtering;

    if (sti.sti_line != row) {
        return retval;
    }
    auto title = " Actions "_status_title;
    auto left = std::max(0, sti.sti_x - 2);
    auto [height, width] = lv.get_dimensions();

    if (left + MENU_WIDTH >= (ssize_t) width) {
        left = width - MENU_WIDTH;
    }

    this->los_menu_items.clear();

    auto is_link = !sti.sti_href.empty();
    auto menu_line = vis_line_t{1};
    attr_line_t link_cmd;
    if (is_link) {
        auto href_al
            = attr_line_t(" Link: ")
                  .append(lnav::roles::table_header(sti.sti_href))
                  .with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS_INFO))
                  .move();
        retval.emplace_back(href_al);
        menu_line += 1_vl;

        std::string filepath;
        auto file_attr_opt = get_string_attr(sti.sti_attrs, &L_FILE);
        if (file_attr_opt) {
            filepath = file_attr_opt.value()
                           ->sa_value.get<std::shared_ptr<logfile>>()
                           ->get_filename();
        }

        {
            logline_value_vector values;
            exec_context ec(&values, internal_sql_callback, pipe_callback);

            auto exec_res
                = ec.execute_with(INTERNAL_SRC_LOC,
                                  "|lnav-link-callback $href $filepath",
                                  std::make_pair("href", sti.sti_href),
                                  std::make_pair("filepath", filepath));
            if (exec_res.isOk()) {
                link_cmd = exec_res.unwrap();
            }
        }
        if (link_cmd.empty()) {
            link_cmd = ":open $href";
        }
        readline_lnav_highlighter(link_cmd, std::nullopt);

        auto cmd_al
            = attr_line_t(" ")
                  .append("Command"_table_header)
                  .append(": ")
                  .append(link_cmd)
                  .with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS_INFO))
                  .with_attr_for_all(
                      VC_STYLE.value(text_attrs::with_underline()))
                  .move();
        retval.emplace_back(cmd_al);
        menu_line += 1_vl;
    }

    retval.emplace_back(attr_line_t().pad_to(left).append(title));
    {
        attr_line_t al;

        int start = left;
        if (is_link || supports_filtering) {
            if (is_link) {
                if (startswith(link_cmd.al_string, ":open")) {
                    al.append(":floppy_disk:"_emoji)
                        .append(" Open in lnav")
                        .append("  ");
                } else {
                    al.append(":play_button:"_emoji)
                        .append(" Execute")
                        .append("        ");
                }
            } else {
                al.append(" ").append("\u2714 Filter-in"_ok).append("   ");
            }
            this->los_menu_items.emplace_back(
                menu_line,
                line_range{start, start + (int) al.length()},
                [is_link, link_cmd, sti](const std::string& value) {
                    const auto cmd = is_link
                        ? link_cmd.get_string()
                        : fmt::format(FMT_STRING(":filter-in {}"),
                                      lnav::pcre2pp::quote(value));
                    auto& dls = lnav_data.ld_db_row_source;
                    auto previous_db_gen = dls.dls_generation;
                    auto exec_res
                        = lnav_data.ld_exec_context
                              .with_provenance(exec_context::mouse_input{})
                              ->execute_with(
                                  INTERNAL_SRC_LOC,
                                  cmd,
                                  std::make_pair("href", sti.sti_href));
                    if (exec_res.isOk()) {
                        lnav::prompt::get().p_editor.set_inactive_value(
                            exec_res.unwrap());
                        if (dls.dls_generation != previous_db_gen
                            && dls.dls_row_cursors.size() > 1)
                        {
                            ensure_view(&lnav_data.ld_views[LNV_DB]);
                        }
                    }
                });
            start += al.length();
        }

        if (is_link) {
            al.append("      ");
        } else {
            al.append(":mag_right:"_emoji).append(" Search ");
        }
        al.with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS));
        if (!is_link) {
            this->los_menu_items.emplace_back(
                menu_line,
                line_range{start, start + (int) al.length()},
                [](const std::string& value) {
                    auto cmd = fmt::format(FMT_STRING("/{}"),
                                           lnav::pcre2pp::quote(value));
                    lnav_data.ld_exec_context
                        .with_provenance(exec_context::mouse_input{})
                        ->execute(INTERNAL_SRC_LOC, cmd);
                });
        }
        retval.emplace_back(attr_line_t().pad_to(left).append(al));
    }
    menu_line += 1_vl;
    {
        attr_line_t al;

        int start = left;
        if (is_link || supports_filtering) {
            if (is_link) {
                al.append(":globe_with_meridians:"_emoji).append(" Open   ");
            } else {
                al.append(" ").append("\u2718 Filter-out"_error).append("  ");
            }
            this->los_menu_items.emplace_back(
                menu_line,
                line_range{start, start + (int) al.length()},
                [is_link, sti](const std::string& value) {
                    auto cmd = is_link
                        ? ":xopen $href"
                        : fmt::format(FMT_STRING(":filter-out {}"),
                                      lnav::pcre2pp::quote(value));
                    auto exec_res
                        = lnav_data.ld_exec_context
                              .with_provenance(exec_context::mouse_input{})
                              ->execute_with(
                                  INTERNAL_SRC_LOC,
                                  cmd,
                                  std::make_pair("href", sti.sti_href));
                    if (exec_res.isOk()) {
                        lnav::prompt::get().p_editor.set_inactive_value(
                            exec_res.unwrap());
                    }
                });
            start += al.length();
        }
        al.append(":clipboard:"_emoji)
            .append(is_link ? " Copy link " : " Copy   ")
            .with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS));
        this->los_menu_items.emplace_back(
            menu_line,
            line_range{start, start + (int) al.length()},
            [is_link, sti](const std::string& value) {
                auto clip_res = sysclip::open(sysclip::type_t::GENERAL);
                if (clip_res.isErr()) {
                    log_error("unable to open clipboard: %s",
                              clip_res.unwrapErr().c_str());
                    return;
                }

                auto clip_pipe = clip_res.unwrap();
                if (is_link) {
                    fwrite(sti.sti_href.c_str(),
                           1,
                           sti.sti_href.length(),
                           clip_pipe.in());
                } else {
                    fwrite(value.c_str(), 1, value.length(), clip_pipe.in());
                }
            });
        retval.emplace_back(attr_line_t().pad_to(left).append(al));
    }

    return retval;
}

1	/**
2	* Copyright (c) 2024, Timothy Stack
3	*
4	* All rights reserved.
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions are met:
8	*
9	* * Redistributions of source code must retain the above copyright notice, this
10	* list of conditions and the following disclaimer.
11	* * Redistributions in binary form must reproduce the above copyright notice,
12	* this list of conditions and the following disclaimer in the documentation
13	* and/or other materials provided with the distribution.
14	* * Neither the name of Timothy Stack nor the names of its contributors
15	* may be used to endorse or promote products derived from this software
16	* without specific prior written permission.
17	*
18	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
19	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21	* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
22	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/
29
30	#include <vector>
31
32	#include "text_overlay_menu.hh"
33
34	#include "command_executor.hh"
35	#include "config.h"
36	#include "lnav.hh"
37	#include "lnav.prompt.hh"
38	#include "md4cpp.hh"
39	#include "readline_highlighters.hh"
40	#include "sysclip.hh"
41	#include "textview_curses.hh"
42
43	using namespace md4cpp::literals;
44	using namespace lnav::roles::literals;
45
46	std::vector<attr_line_t>
UNCOV 47	text_overlay_menu::list_overlay_menu(const listview_curses& lv, vis_line_t row)	×
48	{
49	static constexpr auto MENU_WIDTH = 25;
50
UNCOV 51	const auto* tc = dynamic_cast<const textview_curses*>(&lv);	×
UNCOV 52	std::vector<attr_line_t> retval;	×
53
UNCOV 54	if (tc->tc_text_selection_active \|\| !tc->tc_selected_text) {	×
UNCOV 55	return retval;	×
56	}
57
58	const auto* tss = tc->get_sub_source();	×
59	const auto& sti = tc->tc_selected_text.value();	×
60	const auto supports_filtering	×
61	= tss != nullptr && tss->tss_supports_filtering;	×
62
63	if (sti.sti_line != row) {	×
64	return retval;	×
65	}
66	auto title = " Actions "_status_title;	×
67	auto left = std::max(0, sti.sti_x - 2);	×
68	auto [height, width] = lv.get_dimensions();	×
69
70	if (left + MENU_WIDTH >= (ssize_t) width) {	×
71	left = width - MENU_WIDTH;	×
72	}
73
74	this->los_menu_items.clear();	×
75
76	auto is_link = !sti.sti_href.empty();	×
77	auto menu_line = vis_line_t{1};	×
78	attr_line_t link_cmd;	×
79	if (is_link) {	×
80	auto href_al
81	= attr_line_t(" Link: ")	×
82	.append(lnav::roles::table_header(sti.sti_href))	×
83	.with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS_INFO))	×
84	.move();	×
85	retval.emplace_back(href_al);	×
86	menu_line += 1_vl;	×
87
88	std::string filepath;	×
89	auto file_attr_opt = get_string_attr(sti.sti_attrs, &L_FILE);	×
90	if (file_attr_opt) {	×
91	filepath = file_attr_opt.value()	×
92	->sa_value.get<std::shared_ptr<logfile>>()	×
93	->get_filename();	×
94	}
95
96	{
97	logline_value_vector values;	×
98	exec_context ec(&values, internal_sql_callback, pipe_callback);	×
99
100	auto exec_res
101	= ec.execute_with(INTERNAL_SRC_LOC,	×
102	"\|lnav-link-callback $href $filepath",
103	std::make_pair("href", sti.sti_href),	×
104	std::make_pair("filepath", filepath));	×
105	if (exec_res.isOk()) {	×
106	link_cmd = exec_res.unwrap();	×
107	}
108	}
109	if (link_cmd.empty()) {	×
110	link_cmd = ":open $href";	×
111	}
112	readline_lnav_highlighter(link_cmd, std::nullopt);	×
113
114	auto cmd_al
115	= attr_line_t(" ")	×
116	.append("Command"_table_header)	×
117	.append(": ")	×
118	.append(link_cmd)	×
119	.with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS_INFO))	×
120	.with_attr_for_all(	×
121	VC_STYLE.value(text_attrs::with_underline()))	×
122	.move();	×
123	retval.emplace_back(cmd_al);	×
124	menu_line += 1_vl;	×
125	}
126
127	retval.emplace_back(attr_line_t().pad_to(left).append(title));	×
128	{
129	attr_line_t al;	×
130
131	int start = left;	×
132	if (is_link \|\| supports_filtering) {	×
133	if (is_link) {	×
134	if (startswith(link_cmd.al_string, ":open")) {	×
135	al.append(":floppy_disk:"_emoji)	×
136	.append(" Open in lnav")	×
137	.append(" ");	×
138	} else {
139	al.append(":play_button:"_emoji)	×
140	.append(" Execute")	×
141	.append(" ");	×
142	}
143	} else {
144	al.append(" ").append("\u2714 Filter-in"_ok).append(" ");	×
145	}
146	this->los_menu_items.emplace_back(	×
147	menu_line,
148	line_range{start, start + (int) al.length()},	×
149	[is_link, link_cmd, sti](const std::string& value) {	×
150	const auto cmd = is_link	×
151	? link_cmd.get_string()	×
152	: fmt::format(FMT_STRING(":filter-in {}"),	×
153	lnav::pcre2pp::quote(value));	×
154	auto& dls = lnav_data.ld_db_row_source;	×
155	auto previous_db_gen = dls.dls_generation;	×
156	auto exec_res
157	= lnav_data.ld_exec_context
158	.with_provenance(exec_context::mouse_input{})	×
159	->execute_with(
160	INTERNAL_SRC_LOC,	×
161	cmd,
162	std::make_pair("href", sti.sti_href));	×
163	if (exec_res.isOk()) {	×
164	lnav::prompt::get().p_editor.set_inactive_value(	×
165	exec_res.unwrap());	×
166	if (dls.dls_generation != previous_db_gen	×
167	&& dls.dls_row_cursors.size() > 1)	×
168	{
169	ensure_view(&lnav_data.ld_views[LNV_DB]);	×
170	}
171	}
172	});	×
173	start += al.length();	×
174	}
175
176	if (is_link) {	×
177	al.append(" ");	×
178	} else {
179	al.append(":mag_right:"_emoji).append(" Search ");	×
180	}
181	al.with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS));	×
182	if (!is_link) {	×
183	this->los_menu_items.emplace_back(	×
184	menu_line,
185	line_range{start, start + (int) al.length()},	×
186	[](const std::string& value) {	×
187	auto cmd = fmt::format(FMT_STRING("/{}"),	×
188	lnav::pcre2pp::quote(value));	×
189	lnav_data.ld_exec_context
190	.with_provenance(exec_context::mouse_input{})	×
191	->execute(INTERNAL_SRC_LOC, cmd);	×
192	});	×
193	}
194	retval.emplace_back(attr_line_t().pad_to(left).append(al));	×
195	}
196	menu_line += 1_vl;	×
197	{
198	attr_line_t al;	×
199
200	int start = left;	×
201	if (is_link \|\| supports_filtering) {	×
202	if (is_link) {	×
203	al.append(":globe_with_meridians:"_emoji).append(" Open ");	×
204	} else {
205	al.append(" ").append("\u2718 Filter-out"_error).append(" ");	×
206	}
207	this->los_menu_items.emplace_back(	×
208	menu_line,
209	line_range{start, start + (int) al.length()},	×
210	[is_link, sti](const std::string& value) {	×
211	auto cmd = is_link	×
212	? ":xopen $href"	×
213	: fmt::format(FMT_STRING(":filter-out {}"),	×
214	lnav::pcre2pp::quote(value));	×
215	auto exec_res
216	= lnav_data.ld_exec_context
217	.with_provenance(exec_context::mouse_input{})	×
218	->execute_with(
219	INTERNAL_SRC_LOC,	×
220	cmd,
221	std::make_pair("href", sti.sti_href));	×
222	if (exec_res.isOk()) {	×
223	lnav::prompt::get().p_editor.set_inactive_value(	×
224	exec_res.unwrap());	×
225	}
226	});	×
227	start += al.length();	×
228	}
229	al.append(":clipboard:"_emoji)	×
230	.append(is_link ? " Copy link " : " Copy ")	×
231	.with_attr_for_all(VC_ROLE.value(role_t::VCR_STATUS));	×
232	this->los_menu_items.emplace_back(	×
233	menu_line,
234	line_range{start, start + (int) al.length()},	×
235	[is_link, sti](const std::string& value) {	×
236	auto clip_res = sysclip::open(sysclip::type_t::GENERAL);	×
237	if (clip_res.isErr()) {	×
238	log_error("unable to open clipboard: %s",	×
239	clip_res.unwrapErr().c_str());
240	return;	×
241	}
242
243	auto clip_pipe = clip_res.unwrap();	×
244	if (is_link) {	×
245	fwrite(sti.sti_href.c_str(),	×
246	1,
247	sti.sti_href.length(),
248	clip_pipe.in());
249	} else {
250	fwrite(value.c_str(), 1, value.length(), clip_pipe.in());	×
251	}
252	});	×
253	retval.emplace_back(attr_line_t().pad_to(left).append(al));	×
254	}
255
256	return retval;	×
257	}

tstack / lnav / 20284884426-2753

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous