11918362462-1766

Committed 19 Nov 2024 05:22PM UTC coverage: 70.222% (-0.01%) from 70.232%

Build # 11918362462-1766

Build Type

push

github

Committed by

tstack

Commit Message

[tests] update expected output

Run Details

46302 of 65937 relevant lines covered (70.22%)

467211.82 hits per line

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

61.0

/src/plain_text_source.cc

/**
 * Copyright (c) 2022, 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 "plain_text_source.hh"

#include "base/itertools.hh"
#include "config.h"
#include "scn/scn.h"

static std::vector<plain_text_source::text_line>
to_text_line(const std::vector<attr_line_t>& lines)
{
    file_off_t off = 0;

    return lines | lnav::itertools::map([&off](const auto& elem) {
               auto retval = plain_text_source::text_line{
                   off,
                   elem,
               };

               off += elem.length() + 1;
               return retval;
           });
}

plain_text_source::
plain_text_source(const std::string& text)
{
    size_t start = 0, end;

    while ((end = text.find('\n', start)) != std::string::npos) {
        size_t len = (end - start);
        this->tds_lines.emplace_back(start, text.substr(start, len));
        start = end + 1;
    }
    if (start < text.length()) {
        this->tds_lines.emplace_back(start, text.substr(start));
    }
    this->tds_longest_line = this->compute_longest_line();
}

plain_text_source::
plain_text_source(const std::vector<std::string>& text_lines)
{
    this->replace_with(text_lines);
}

plain_text_source::
plain_text_source(const std::vector<attr_line_t>& text_lines)
    : tds_lines(to_text_line(text_lines))
{
    this->tds_longest_line = this->compute_longest_line();
}

plain_text_source&
plain_text_source::replace_with(const attr_line_t& text_lines)
{
    this->tds_lines.clear();
    this->tds_doc_sections = lnav::document::discover_metadata(text_lines);
    file_off_t off = 0;
    auto lines = text_lines.split_lines();
    while (!lines.empty() && lines.back().empty()) {
        lines.pop_back();
    }
    for (auto& line : lines) {
        auto line_len = line.length() + 1;
        this->tds_lines.emplace_back(off, std::move(line));
        off += line_len;
    }
    this->tds_longest_line = this->compute_longest_line();
    if (this->tss_view != nullptr) {
        this->tss_view->set_needs_update();
    }
    return *this;
}

plain_text_source&
plain_text_source::replace_with_mutable(attr_line_t& text_lines,
                                        text_format_t tf)
{
    this->tds_text_format = tf;
    this->tds_lines.clear();
    this->tds_doc_sections
        = lnav::document::discover_structure(text_lines, line_range{0, -1}, tf);
    file_off_t off = 0;
    auto lines = text_lines.split_lines();
    while (!lines.empty() && lines.back().empty()) {
        lines.pop_back();
    }
    for (auto& line : lines) {
        auto line_len = line.length() + 1;
        this->tds_lines.emplace_back(off, std::move(line));
        off += line_len;
    }
    this->tds_longest_line = this->compute_longest_line();
    if (this->tss_view != nullptr) {
        this->tss_view->set_needs_update();
    }
    return *this;
}

plain_text_source&
plain_text_source::replace_with(const std::vector<std::string>& text_lines)
{
    file_off_t off = 0;
    for (const auto& str : text_lines) {
        this->tds_lines.emplace_back(off, str);
        off += str.length() + 1;
    }
    this->tds_longest_line = this->compute_longest_line();
    if (this->tss_view != nullptr) {
        this->tss_view->set_needs_update();
    }
    return *this;
}

plain_text_source&
plain_text_source::replace_with(const std::vector<attr_line_t>& text_lines)
{
    file_off_t off = 0;
    this->tds_lines.clear();
    for (const auto& al : text_lines) {
        this->tds_lines.emplace_back(off, al);
        off += al.length() + 1;
    }
    this->tds_longest_line = this->compute_longest_line();
    if (this->tss_view != nullptr) {
        this->tss_view->set_needs_update();
    }
    return *this;
}

void
plain_text_source::clear()
{
    this->tds_lines.clear();
    this->tds_longest_line = 0;
    this->tds_text_format = text_format_t::TF_UNKNOWN;
    if (this->tss_view != nullptr) {
        this->tss_view->set_needs_update();
    }
}

plain_text_source&
plain_text_source::truncate_to(size_t max_lines)
{
    while (this->tds_lines.size() > max_lines) {
        this->tds_lines.pop_back();
    }
    if (this->tss_view != nullptr) {
        this->tss_view->set_needs_update();
    }
    return *this;
}

size_t
plain_text_source::text_line_width(textview_curses& curses)
{
    return this->tds_longest_line;
}

void
plain_text_source::text_value_for_line(textview_curses& tc,
                                       int row,
                                       std::string& value_out,
                                       text_sub_source::line_flags_t flags)
{
    value_out = this->tds_lines[row].tl_value.get_string();
    this->tds_line_indent_size = 0;
    for (const auto& ch : value_out) {
        if (ch == ' ') {
            this->tds_line_indent_size += 1;
        } else if (ch == '\t') {
            do {
                this->tds_line_indent_size += 1;
            } while (this->tds_line_indent_size % 8);
        } else {
            break;
        }
    }
}

void
plain_text_source::text_attrs_for_line(textview_curses& tc,
                                       int line,
                                       string_attrs_t& value_out)
{
    value_out = this->tds_lines[line].tl_value.get_attrs();
    if (this->tds_reverse_selection && tc.is_selectable()
        && tc.get_selection() == line)
    {
        value_out.emplace_back(line_range{0, -1},
                               VC_STYLE.value(text_attrs{A_REVERSE}));
    }
    for (const auto& indent : this->tds_doc_sections.m_indents) {
        if (indent < this->tds_line_indent_size) {
            auto guide_lr = line_range{
                (int) indent,
                (int) (indent + 1),
                line_range::unit::codepoint,
            };
            value_out.emplace_back(guide_lr,
                                   VC_BLOCK_ELEM.value(block_elem_t{
                                       L'\u258f', role_t::VCR_INDENT_GUIDE}));
        }
    }
}

size_t
plain_text_source::text_size_for_line(textview_curses& tc,
                                      int row,
                                      text_sub_source::line_flags_t flags)
{
    return this->tds_lines[row].tl_value.length();
}

text_format_t
plain_text_source::get_text_format() const
{
    return this->tds_text_format;
}

size_t
plain_text_source::compute_longest_line()
{
    size_t retval = 0;
    for (auto& iter : this->tds_lines) {
        retval = std::max(retval, (size_t) iter.tl_value.length());
    }
    return retval;
}

std::optional<vis_line_t>
plain_text_source::line_for_offset(file_off_t off) const
{
    struct cmper {
        bool operator()(const file_off_t& lhs, const text_line& rhs)
        {
            return lhs < rhs.tl_offset;
        }

        bool operator()(const text_line& lhs, const file_off_t& rhs)
        {
            return lhs.tl_offset < rhs;
        }
    };

    if (this->tds_lines.empty()) {
        return std::nullopt;
    }

    auto iter = std::lower_bound(
        this->tds_lines.begin(), this->tds_lines.end(), off, cmper{});
    if (iter == this->tds_lines.end()) {
        if (this->tds_lines.back().contains_offset(off)) {
            return std::make_optional(
                vis_line_t(std::distance(this->tds_lines.end() - 1, iter)));
        }
        return std::nullopt;
    }

    if (!iter->contains_offset(off) && iter != this->tds_lines.begin()) {
        --iter;
    }

    return std::make_optional(
        vis_line_t(std::distance(this->tds_lines.begin(), iter)));
}

void
plain_text_source::text_crumbs_for_line(int line,
                                        std::vector<breadcrumb::crumb>& crumbs)
{
    const auto initial_size = crumbs.size();
    const auto& tl = this->tds_lines[line];

    this->tds_doc_sections.m_sections_tree.visit_overlapping(
        tl.tl_offset,
        [&crumbs, initial_size, meta = &this->tds_doc_sections, this](
            const auto& iv) {
            auto path = crumbs | lnav::itertools::skip(initial_size)
                | lnav::itertools::map(&breadcrumb::crumb::c_key)
                | lnav::itertools::append(iv.value);
            crumbs.emplace_back(
                iv.value,
                [meta, path]() { return meta->possibility_provider(path); },
                [this, meta, path](const auto& key) {
                    auto curr_node = lnav::document::hier_node::lookup_path(
                        meta->m_sections_root.get(), path);
                    if (!curr_node) {
                        return;
                    }
                    auto* parent_node = curr_node.value()->hn_parent;

                    if (parent_node == nullptr) {
                        return;
                    }
                    key.match(
                        [this, parent_node](const std::string& str) {
                            auto sib_iter
                                = parent_node->hn_named_children.find(str);
                            if (sib_iter
                                == parent_node->hn_named_children.end()) {
                                return;
                            }
                            this->line_for_offset(sib_iter->second->hn_start) |
                                [this](const auto new_top) {
                                    this->tss_view->set_selection(new_top);
                                    if (this->tss_view->is_selectable()) {
                                        this->tss_view->set_top(new_top - 2_vl,
                                                                false);
                                    }
                                };
                        },
                        [this, parent_node](size_t index) {
                            if (index >= parent_node->hn_children.size()) {
                                return;
                            }
                            auto sib = parent_node->hn_children[index].get();
                            this->line_for_offset(sib->hn_start) |
                                [this](const auto new_top) {
                                    this->tss_view->set_selection(new_top);
                                    if (this->tss_view->is_selectable()) {
                                        this->tss_view->set_top(new_top - 2_vl,
                                                                false);
                                    }
                                };
                        });
                });
        });

    auto path = crumbs | lnav::itertools::skip(initial_size)
        | lnav::itertools::map(&breadcrumb::crumb::c_key);
    auto node = lnav::document::hier_node::lookup_path(
        this->tds_doc_sections.m_sections_root.get(), path);

    if (node && !node.value()->hn_children.empty()) {
        auto poss_provider = [curr_node = node.value()]() {
            std::vector<breadcrumb::possibility> retval;
            for (const auto& child : curr_node->hn_named_children) {
                retval.emplace_back(child.first);
            }
            return retval;
        };
        auto path_performer = [this, curr_node = node.value()](
                                  const breadcrumb::crumb::key_t& value) {
            value.match(
                [this, curr_node](const std::string& str) {
                    auto child_iter = curr_node->hn_named_children.find(str);
                    if (child_iter != curr_node->hn_named_children.end()) {
                        this->line_for_offset(child_iter->second->hn_start) |
                            [this](const auto new_top) {
                                this->tss_view->set_selection(new_top);
                            };
                    }
                },
                [this, curr_node](size_t index) {
                    auto* child = curr_node->hn_children[index].get();
                    this->line_for_offset(child->hn_start) |
                        [this](const auto new_top) {
                            this->tss_view->set_selection(new_top);
                        };
                });
        };
        crumbs.emplace_back(
            "", "\u22ef", std::move(poss_provider), std::move(path_performer));
        crumbs.back().c_expected_input = node.value()->hn_named_children.empty()
            ? breadcrumb::crumb::expected_input_t::index
            : breadcrumb::crumb::expected_input_t::index_or_exact;
    }
}

std::optional<vis_line_t>
plain_text_source::row_for_anchor(const std::string& id)
{
    std::optional<vis_line_t> retval;

    if (this->tds_doc_sections.m_sections_root == nullptr) {
        return retval;
    }

    const auto& meta = this->tds_doc_sections;

    auto is_ptr = startswith(id, "#/");
    if (is_ptr) {
        auto hier_sf = string_fragment::from_str(id).consume_n(2).value();
        std::vector<lnav::document::section_key_t> path;

        while (!hier_sf.empty()) {
            auto comp_pair = hier_sf.split_when(string_fragment::tag1{'/'});
            auto scan_res
                = scn::scan_value<int64_t>(comp_pair.first.to_string_view());
            if (scan_res && scan_res.empty()) {
                path.emplace_back(scan_res.value());
            } else {
                path.emplace_back(json_ptr::decode(comp_pair.first));
            }
            hier_sf = comp_pair.second;
        }

        auto lookup_res = lnav::document::hier_node::lookup_path(
            meta.m_sections_root.get(), path);
        if (lookup_res) {
            retval = this->line_for_offset(lookup_res.value()->hn_start);
        }

        return retval;
    }

    lnav::document::hier_node::depth_first(
        meta.m_sections_root.get(),
        [this, &id, &retval](const lnav::document::hier_node* node) {
            for (const auto& child_pair : node->hn_named_children) {
                const auto& child_anchor = to_anchor_string(child_pair.first);

                if (child_anchor != id) {
                    continue;
                }

                retval = this->line_for_offset(child_pair.second->hn_start);
                break;
            }
        });

    return retval;
}

std::unordered_set<std::string>
plain_text_source::get_anchors()
{
    std::unordered_set<std::string> retval;

    lnav::document::hier_node::depth_first(
        this->tds_doc_sections.m_sections_root.get(),
        [&retval](const lnav::document::hier_node* node) {
            for (const auto& child_pair : node->hn_named_children) {
                retval.emplace(to_anchor_string(child_pair.first));
            }
        });

    return retval;
}

std::optional<std::string>
plain_text_source::anchor_for_row(vis_line_t vl)
{
    std::optional<std::string> retval;

    if (vl > this->tds_lines.size()
        || this->tds_doc_sections.m_sections_root == nullptr)
    {
        return retval;
    }

    const auto& tl = this->tds_lines[vl];
    auto& md = this->tds_doc_sections;
    auto path_for_line = md.path_for_range(
        tl.tl_offset, tl.tl_offset + tl.tl_value.al_string.length());

    if (path_for_line.empty()) {
        return std::nullopt;
    }

    if ((path_for_line.size() == 1
         || this->tds_text_format == text_format_t::TF_MARKDOWN)
        && path_for_line.back().is<std::string>())
    {
        return to_anchor_string(path_for_line.back().get<std::string>());
    }

    auto comps = path_for_line | lnav::itertools::map([](const auto& elem) {
                     return elem.match(
                         [](const std::string& str) {
                             return json_ptr::encode_str(str);
                         },
                         [](size_t index) { return fmt::to_string(index); });
                 });

    return fmt::format(FMT_STRING("#/{}"),
                       fmt::join(comps.begin(), comps.end(), "/"));
}

std::optional<vis_line_t>
plain_text_source::adjacent_anchor(vis_line_t vl, direction dir)
{
    if (vl > this->tds_lines.size()
        || this->tds_doc_sections.m_sections_root == nullptr)
    {
        return std::nullopt;
    }

    const auto& tl = this->tds_lines[vl];
    auto path_for_line = this->tds_doc_sections.path_for_range(
        tl.tl_offset, tl.tl_offset + tl.tl_value.al_string.length());

    const auto& md = this->tds_doc_sections;
    if (path_for_line.empty()) {
        auto neighbors_res = md.m_sections_root->line_neighbors(vl);
        if (!neighbors_res) {
            return std::nullopt;
        }

        switch (dir) {
            case direction::prev: {
                if (neighbors_res->cnr_previous) {
                    return this->line_for_offset(
                        neighbors_res->cnr_previous.value()->hn_start);
                }
                break;
            }
            case direction::next: {
                if (neighbors_res->cnr_next) {
                    return this->line_for_offset(
                        neighbors_res->cnr_next.value()->hn_start);
                } else if (!md.m_sections_root->hn_children.empty()) {
                    return this->line_for_offset(
                        md.m_sections_root->hn_children[0]->hn_start);
                }
                break;
            }
        }
        return std::nullopt;
    }

    auto last_key = path_for_line.back();
    path_for_line.pop_back();

    auto parent_opt = lnav::document::hier_node::lookup_path(
        md.m_sections_root.get(), path_for_line);
    if (!parent_opt) {
        return std::nullopt;
    }
    auto parent = parent_opt.value();

    auto child_hn = parent->lookup_child(last_key);
    if (!child_hn) {
        // XXX "should not happen"
        return std::nullopt;
    }

    auto neighbors_res = parent->child_neighbors(
        child_hn.value(), tl.tl_offset + tl.tl_value.al_string.length() + 1);
    if (!neighbors_res) {
        return std::nullopt;
    }

    if (neighbors_res->cnr_previous && last_key.is<std::string>()) {
        auto neighbor_sub
            = neighbors_res->cnr_previous.value()->lookup_child(last_key);
        if (neighbor_sub) {
            neighbors_res->cnr_previous = neighbor_sub;
        }
    }

    if (neighbors_res->cnr_next && last_key.is<std::string>()) {
        auto neighbor_sub
            = neighbors_res->cnr_next.value()->lookup_child(last_key);
        if (neighbor_sub) {
            neighbors_res->cnr_next = neighbor_sub;
        }
    }

    switch (dir) {
        case direction::prev: {
            if (neighbors_res->cnr_previous) {
                return this->line_for_offset(
                    neighbors_res->cnr_previous.value()->hn_start);
            }
            break;
        }
        case direction::next: {
            if (neighbors_res->cnr_next) {
                return this->line_for_offset(
                    neighbors_res->cnr_next.value()->hn_start);
            }
            break;
        }
    }

    return std::nullopt;
}

1	/**
2	* Copyright (c) 2022, 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 "plain_text_source.hh"
31
32	#include "base/itertools.hh"
33	#include "config.h"
34	#include "scn/scn.h"
35
36	static std::vector<plain_text_source::text_line>
37	to_text_line(const std::vector<attr_line_t>& lines)	×
38	{
39	file_off_t off = 0;	×
40
41	return lines \| lnav::itertools::map([&off](const auto& elem) {	×
42	auto retval = plain_text_source::text_line{	×
43	off,
44	elem,
45	};
46
47	off += elem.length() + 1;	×
48	return retval;	×
49	});	×
50	}
51
52	plain_text_source::	×
53	plain_text_source(const std::string& text)	×
54	{
55	size_t start = 0, end;	×
56
57	while ((end = text.find('\n', start)) != std::string::npos) {	×
58	size_t len = (end - start);	×
59	this->tds_lines.emplace_back(start, text.substr(start, len));	×
60	start = end + 1;	×
61	}
62	if (start < text.length()) {	×
63	this->tds_lines.emplace_back(start, text.substr(start));	×
64	}
65	this->tds_longest_line = this->compute_longest_line();	×
66	}
67
68	plain_text_source::	×
69	plain_text_source(const std::vector<std::string>& text_lines)	×
70	{
71	this->replace_with(text_lines);	×
72	}
73
74	plain_text_source::	×
75	plain_text_source(const std::vector<attr_line_t>& text_lines)	×
76	: tds_lines(to_text_line(text_lines))	×
77	{
78	this->tds_longest_line = this->compute_longest_line();	×
79	}
80
81	plain_text_source&
82	plain_text_source::replace_with(const attr_line_t& text_lines)	138✔
83	{
84	this->tds_lines.clear();	138✔
85	this->tds_doc_sections = lnav::document::discover_metadata(text_lines);	138✔
86	file_off_t off = 0;	138✔
87	auto lines = text_lines.split_lines();	138✔
88	while (!lines.empty() && lines.back().empty()) {	240✔
89	lines.pop_back();	102✔
90	}
91	for (auto& line : lines) {	28,267✔
92	auto line_len = line.length() + 1;	28,129✔
93	this->tds_lines.emplace_back(off, std::move(line));	28,129✔
94	off += line_len;	28,129✔
95	}
96	this->tds_longest_line = this->compute_longest_line();	138✔
97	if (this->tss_view != nullptr) {	138✔
98	this->tss_view->set_needs_update();	116✔
99	}
100	return *this;	138✔
101	}	138✔
102
103	plain_text_source&
104	plain_text_source::replace_with_mutable(attr_line_t& text_lines,	18✔
105	text_format_t tf)
106	{
107	this->tds_text_format = tf;	18✔
108	this->tds_lines.clear();	18✔
109	this->tds_doc_sections
110	= lnav::document::discover_structure(text_lines, line_range{0, -1}, tf);	18✔
111	file_off_t off = 0;	18✔
112	auto lines = text_lines.split_lines();	18✔
113	while (!lines.empty() && lines.back().empty()) {	30✔
114	lines.pop_back();	12✔
115	}
116	for (auto& line : lines) {	3,195✔
117	auto line_len = line.length() + 1;	3,177✔
118	this->tds_lines.emplace_back(off, std::move(line));	3,177✔
119	off += line_len;	3,177✔
120	}
121	this->tds_longest_line = this->compute_longest_line();	18✔
122	if (this->tss_view != nullptr) {	18✔
123	this->tss_view->set_needs_update();	×
124	}
125	return *this;	18✔
126	}	18✔
127
128	plain_text_source&
129	plain_text_source::replace_with(const std::vector<std::string>& text_lines)	×
130	{
131	file_off_t off = 0;	×
132	for (const auto& str : text_lines) {	×
133	this->tds_lines.emplace_back(off, str);	×
134	off += str.length() + 1;	×
135	}
136	this->tds_longest_line = this->compute_longest_line();	×
137	if (this->tss_view != nullptr) {	×
138	this->tss_view->set_needs_update();	×
139	}
140	return *this;	×
141	}
142
143	plain_text_source&
144	plain_text_source::replace_with(const std::vector<attr_line_t>& text_lines)	17✔
145	{
146	file_off_t off = 0;	17✔
147	this->tds_lines.clear();	17✔
148	for (const auto& al : text_lines) {	538✔
149	this->tds_lines.emplace_back(off, al);	521✔
150	off += al.length() + 1;	521✔
151	}
152	this->tds_longest_line = this->compute_longest_line();	17✔
153	if (this->tss_view != nullptr) {	17✔
154	this->tss_view->set_needs_update();	17✔
155	}
156	return *this;	17✔
157	}
158
159	void
160	plain_text_source::clear()	566✔
161	{
162	this->tds_lines.clear();	566✔
163	this->tds_longest_line = 0;	566✔
164	this->tds_text_format = text_format_t::TF_UNKNOWN;	566✔
165	if (this->tss_view != nullptr) {	566✔
166	this->tss_view->set_needs_update();	474✔
167	}
168	}	566✔
169
170	plain_text_source&
171	plain_text_source::truncate_to(size_t max_lines)	×
172	{
173	while (this->tds_lines.size() > max_lines) {	×
174	this->tds_lines.pop_back();	×
175	}
176	if (this->tss_view != nullptr) {	×
177	this->tss_view->set_needs_update();	×
178	}
179	return *this;	×
180	}
181
182	size_t
183	plain_text_source::text_line_width(textview_curses& curses)	4,350✔
184	{
185	return this->tds_longest_line;	4,350✔
186	}
187
188	void
189	plain_text_source::text_value_for_line(textview_curses& tc,	6,775✔
190	int row,
191	std::string& value_out,
192	text_sub_source::line_flags_t flags)
193	{
194	value_out = this->tds_lines[row].tl_value.get_string();	6,775✔
195	this->tds_line_indent_size = 0;	6,775✔
196	for (const auto& ch : value_out) {	19,787✔
197	if (ch == ' ') {	18,436✔
198	this->tds_line_indent_size += 1;	13,012✔
199	} else if (ch == '\t') {	5,424✔
200	do {
201	this->tds_line_indent_size += 1;	×
202	} while (this->tds_line_indent_size % 8);	×
203	} else {
204	break;	5,424✔
205	}
206	}
207	}	6,775✔
208
209	void
210	plain_text_source::text_attrs_for_line(textview_curses& tc,	6,775✔
211	int line,
212	string_attrs_t& value_out)
213	{
214	value_out = this->tds_lines[line].tl_value.get_attrs();	6,775✔
215	if (this->tds_reverse_selection && tc.is_selectable()	26✔
216	&& tc.get_selection() == line)	6,801✔
217	{
218	value_out.emplace_back(line_range{0, -1},	8✔
219	VC_STYLE.value(text_attrs{A_REVERSE}));	16✔
220	}
221	for (const auto& indent : this->tds_doc_sections.m_indents) {	7,195✔
222	if (indent < this->tds_line_indent_size) {	420✔
223	auto guide_lr = line_range{
224	(int) indent,	60✔
225	(int) (indent + 1),	60✔
226	line_range::unit::codepoint,
227	};	60✔
228	value_out.emplace_back(guide_lr,	60✔
229	VC_BLOCK_ELEM.value(block_elem_t{	120✔
230	L'\u258f', role_t::VCR_INDENT_GUIDE}));
231	}
232	}
233	}	6,775✔
234
235	size_t
236	plain_text_source::text_size_for_line(textview_curses& tc,	×
237	int row,
238	text_sub_source::line_flags_t flags)
239	{
240	return this->tds_lines[row].tl_value.length();	×
241	}
242
243	text_format_t
244	plain_text_source::get_text_format() const	5,898✔
245	{
246	return this->tds_text_format;	5,898✔
247	}
248
249	size_t
250	plain_text_source::compute_longest_line()	173✔
251	{
252	size_t retval = 0;	173✔
253	for (auto& iter : this->tds_lines) {	32,000✔
254	retval = std::max(retval, (size_t) iter.tl_value.length());	31,827✔
255	}
256	return retval;	173✔
257	}
258
259	std::optional<vis_line_t>
260	plain_text_source::line_for_offset(file_off_t off) const	7✔
261	{
262	struct cmper {
263	bool operator()(const file_off_t& lhs, const text_line& rhs)
264	{
265	return lhs < rhs.tl_offset;
266	}
267
268	bool operator()(const text_line& lhs, const file_off_t& rhs)	75✔
269	{
270	return lhs.tl_offset < rhs;	75✔
271	}
272	};
273
274	if (this->tds_lines.empty()) {	7✔
275	return std::nullopt;	×
276	}
277
278	auto iter = std::lower_bound(	7✔
279	this->tds_lines.begin(), this->tds_lines.end(), off, cmper{});
280	if (iter == this->tds_lines.end()) {	7✔
281	if (this->tds_lines.back().contains_offset(off)) {	×
282	return std::make_optional(	×
283	vis_line_t(std::distance(this->tds_lines.end() - 1, iter)));	×
284	}
285	return std::nullopt;	×
286	}
287
288	if (!iter->contains_offset(off) && iter != this->tds_lines.begin()) {	7✔
289	--iter;	×
290	}
291
292	return std::make_optional(	7✔
293	vis_line_t(std::distance(this->tds_lines.begin(), iter)));	14✔
294	}
295
296	void
297	plain_text_source::text_crumbs_for_line(int line,	10✔
298	std::vector<breadcrumb::crumb>& crumbs)
299	{
300	const auto initial_size = crumbs.size();	10✔
301	const auto& tl = this->tds_lines[line];	10✔
302
303	this->tds_doc_sections.m_sections_tree.visit_overlapping(	10✔
304	tl.tl_offset,	10✔
305	[&crumbs, initial_size, meta = &this->tds_doc_sections, this](	10✔
306	const auto& iv) {	48✔
307	auto path = crumbs \| lnav::itertools::skip(initial_size)	48✔
308	\| lnav::itertools::map(&breadcrumb::crumb::c_key)	24✔
309	\| lnav::itertools::append(iv.value);	12✔
310	crumbs.emplace_back(	24✔
311	iv.value,	12✔
312	[meta, path]() { return meta->possibility_provider(path); },	6✔
313	[this, meta, path](const auto& key) {	2✔
314	auto curr_node = lnav::document::hier_node::lookup_path(	1✔
315	meta->m_sections_root.get(), path);	1✔
316	if (!curr_node) {	1✔
317	return;	×
318	}
319	auto* parent_node = curr_node.value()->hn_parent;	1✔
320
321	if (parent_node == nullptr) {	1✔
322	return;	×
323	}
324	key.match(	1✔
325	[this, parent_node](const std::string& str) {	3✔
326	auto sib_iter
327	= parent_node->hn_named_children.find(str);	1✔
328	if (sib_iter	1✔
329	== parent_node->hn_named_children.end()) {	2✔
330	return;	×
331	}
332	this->line_for_offset(sib_iter->second->hn_start) \|	1✔
333	[this](const auto new_top) {	1✔
334	this->tss_view->set_selection(new_top);	1✔
335	if (this->tss_view->is_selectable()) {	1✔
336	this->tss_view->set_top(new_top - 2_vl,	×
337	false);
338	}
339	};
340	},
341	[this, parent_node](size_t index) {	×
342	if (index >= parent_node->hn_children.size()) {	×
343	return;	×
344	}
345	auto sib = parent_node->hn_children[index].get();	×
346	this->line_for_offset(sib->hn_start) \|	×
347	[this](const auto new_top) {	×
348	this->tss_view->set_selection(new_top);	×
349	if (this->tss_view->is_selectable()) {	×
350	this->tss_view->set_top(new_top - 2_vl,	×
351	false);
352	}
353	};
354	});
355	});
356	});	12✔
357
358	auto path = crumbs \| lnav::itertools::skip(initial_size)	10✔
359	\| lnav::itertools::map(&breadcrumb::crumb::c_key);	20✔
360	auto node = lnav::document::hier_node::lookup_path(	10✔
361	this->tds_doc_sections.m_sections_root.get(), path);	10✔
362
363	if (node && !node.value()->hn_children.empty()) {	10✔
364	auto poss_provider = [curr_node = node.value()]() {	9✔
365	std::vector<breadcrumb::possibility> retval;	2✔
366	for (const auto& child : curr_node->hn_named_children) {	17✔
367	retval.emplace_back(child.first);	15✔
368	}
369	return retval;	2✔
370	};
371	auto path_performer = [this, curr_node = node.value()](	19✔
372	const breadcrumb::crumb::key_t& value) {	1✔
373	value.match(	1✔
374	[this, curr_node](const std::string& str) {	3✔
375	auto child_iter = curr_node->hn_named_children.find(str);	1✔
376	if (child_iter != curr_node->hn_named_children.end()) {	1✔
377	this->line_for_offset(child_iter->second->hn_start) \|	1✔
378	[this](const auto new_top) {	1✔
379	this->tss_view->set_selection(new_top);	1✔
380	};	1✔
381	}
382	},	1✔
383	[this, curr_node](size_t index) {	×
384	auto* child = curr_node->hn_children[index].get();	×
385	this->line_for_offset(child->hn_start) \|	×
386	[this](const auto new_top) {	×
387	this->tss_view->set_selection(new_top);	×
388	};
389	});	×
390	};	10✔
391	crumbs.emplace_back(	9✔
392	"", "\u22ef", std::move(poss_provider), std::move(path_performer));	9✔
393	crumbs.back().c_expected_input = node.value()->hn_named_children.empty()	18✔
394	? breadcrumb::crumb::expected_input_t::index	9✔
395	: breadcrumb::crumb::expected_input_t::index_or_exact;
396	}
397	}	10✔
398
399	std::optional<vis_line_t>
400	plain_text_source::row_for_anchor(const std::string& id)	3✔
401	{
402	std::optional<vis_line_t> retval;	3✔
403
404	if (this->tds_doc_sections.m_sections_root == nullptr) {	3✔
405	return retval;	×
406	}
407
408	const auto& meta = this->tds_doc_sections;	3✔
409
410	auto is_ptr = startswith(id, "#/");	3✔
411	if (is_ptr) {	3✔
412	auto hier_sf = string_fragment::from_str(id).consume_n(2).value();	×
413	std::vector<lnav::document::section_key_t> path;	×
414
415	while (!hier_sf.empty()) {	×
416	auto comp_pair = hier_sf.split_when(string_fragment::tag1{'/'});	×
417	auto scan_res
418	= scn::scan_value<int64_t>(comp_pair.first.to_string_view());	×
419	if (scan_res && scan_res.empty()) {	×
420	path.emplace_back(scan_res.value());	×
421	} else {
422	path.emplace_back(json_ptr::decode(comp_pair.first));	×
423	}
424	hier_sf = comp_pair.second;	×
425	}
426
427	auto lookup_res = lnav::document::hier_node::lookup_path(	×
428	meta.m_sections_root.get(), path);	×
429	if (lookup_res) {	×
430	retval = this->line_for_offset(lookup_res.value()->hn_start);	×
431	}
432
433	return retval;	×
434	}
435
436	lnav::document::hier_node::depth_first(	3✔
437	meta.m_sections_root.get(),
438	[this, &id, &retval](const lnav::document::hier_node* node) {	85✔
439	for (const auto& child_pair : node->hn_named_children) {	79✔
440	const auto& child_anchor = to_anchor_string(child_pair.first);	34✔
441
442	if (child_anchor != id) {	34✔
443	continue;	31✔
444	}
445
446	retval = this->line_for_offset(child_pair.second->hn_start);	3✔
447	break;	3✔
448	}	34✔
449	});	48✔
450
451	return retval;	3✔
452	}
453
454	std::unordered_set<std::string>
455	plain_text_source::get_anchors()	×
456	{
457	std::unordered_set<std::string> retval;	×
458
459	lnav::document::hier_node::depth_first(	×
460	this->tds_doc_sections.m_sections_root.get(),
461	[&retval](const lnav::document::hier_node* node) {	×
462	for (const auto& child_pair : node->hn_named_children) {	×
463	retval.emplace(to_anchor_string(child_pair.first));	×
464	}
465	});	×
466
467	return retval;	×
468	}	×
469
470	std::optional<std::string>
471	plain_text_source::anchor_for_row(vis_line_t vl)	3✔
472	{
473	std::optional<std::string> retval;	3✔
474
475	if (vl > this->tds_lines.size()	3✔
476	\|\| this->tds_doc_sections.m_sections_root == nullptr)	3✔
477	{
478	return retval;	×
479	}
480
481	const auto& tl = this->tds_lines[vl];	3✔
482	auto& md = this->tds_doc_sections;	3✔
483	auto path_for_line = md.path_for_range(
484	tl.tl_offset, tl.tl_offset + tl.tl_value.al_string.length());	3✔
485
486	if (path_for_line.empty()) {	3✔
487	return std::nullopt;	1✔
488	}
489
490	if ((path_for_line.size() == 1	2✔
491	\|\| this->tds_text_format == text_format_t::TF_MARKDOWN)	1✔
492	&& path_for_line.back().is<std::string>())	3✔
493	{
494	return to_anchor_string(path_for_line.back().get<std::string>());	2✔
495	}
496
497	auto comps = path_for_line \| lnav::itertools::map([](const auto& elem) {	×
498	return elem.match(
499	[](const std::string& str) {	×
500	return json_ptr::encode_str(str);	×
501	},
502	[](size_t index) { return fmt::to_string(index); });	×
503	});	×
504
505	return fmt::format(FMT_STRING("#/{}"),	×
506	fmt::join(comps.begin(), comps.end(), "/"));	×
507	}	×
508		×
509	std::optional<vis_line_t>	3✔
510	plain_text_source::adjacent_anchor(vis_line_t vl, direction dir)
511	{
512	if (vl > this->tds_lines.size()	2✔
513	\|\| this->tds_doc_sections.m_sections_root == nullptr)
514	{	2✔
515	return std::nullopt;	2✔
516	}
517		×
518	const auto& tl = this->tds_lines[vl];
519	auto path_for_line = this->tds_doc_sections.path_for_range(
520	tl.tl_offset, tl.tl_offset + tl.tl_value.al_string.length());	2✔
521
522	const auto& md = this->tds_doc_sections;	2✔
523	if (path_for_line.empty()) {
524	auto neighbors_res = md.m_sections_root->line_neighbors(vl);	2✔
525	if (!neighbors_res) {	2✔
526	return std::nullopt;	×
527	}	×
528		×
529	switch (dir) {
530	case direction::prev: {
531	if (neighbors_res->cnr_previous) {	×
532	return this->line_for_offset(	×
533	neighbors_res->cnr_previous.value()->hn_start);	×
534	}	×
535	break;	×
536	}
537	case direction::next: {	×
538	if (neighbors_res->cnr_next) {
539	return this->line_for_offset(	×
540	neighbors_res->cnr_next.value()->hn_start);	×
541	} else if (!md.m_sections_root->hn_children.empty()) {	×
542	return this->line_for_offset(	×
543	md.m_sections_root->hn_children[0]->hn_start);	×
544	}	×
545	break;	×
546	}
547	}	×
548	return std::nullopt;
549	}
550		×
551	auto last_key = path_for_line.back();
552	path_for_line.pop_back();
553		2✔
554	auto parent_opt = lnav::document::hier_node::lookup_path(	2✔
555	md.m_sections_root.get(), path_for_line);
556	if (!parent_opt) {	2✔
557	return std::nullopt;	2✔
558	}	2✔
559	auto parent = parent_opt.value();	×
560
561	auto child_hn = parent->lookup_child(last_key);	2✔
562	if (!child_hn) {
563	// XXX "should not happen"	2✔
564	return std::nullopt;	2✔
565	}
566		×
567	auto neighbors_res = parent->child_neighbors(
568	child_hn.value(), tl.tl_offset + tl.tl_value.al_string.length() + 1);
569	if (!neighbors_res) {	6✔
570	return std::nullopt;	2✔
571	}	2✔
572		×
573	if (neighbors_res->cnr_previous && last_key.is<std::string>()) {
574	auto neighbor_sub
575	= neighbors_res->cnr_previous.value()->lookup_child(last_key);	2✔
576	if (neighbor_sub) {
577	neighbors_res->cnr_previous = neighbor_sub;	2✔
578	}	2✔
579	}	1✔
580
581	if (neighbors_res->cnr_next && last_key.is<std::string>()) {
582	auto neighbor_sub
583	= neighbors_res->cnr_next.value()->lookup_child(last_key);	2✔
584	if (neighbor_sub) {
585	neighbors_res->cnr_next = neighbor_sub;	2✔
586	}	2✔
587	}	×
588
589	switch (dir) {
590	case direction::prev: {
591	if (neighbors_res->cnr_previous) {	2✔
592	return this->line_for_offset(	×
593	neighbors_res->cnr_previous.value()->hn_start);	×
594	}	×
595	break;	×
596	}
597	case direction::next: {	×
598	if (neighbors_res->cnr_next) {
599	return this->line_for_offset(	2✔
600	neighbors_res->cnr_next.value()->hn_start);	2✔
601	}	2✔
602	break;	2✔
603	}
604	}	×
605
606	return std::nullopt;
607	}

tstack / lnav / 11918362462-1766

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