21146409233

Committed 19 Jan 2026 05:26PM UTC coverage: 93.417% (+0.7%) from 92.743%

Build # 21146409233

Build Type

push

github

Committed by

SuperFola

Commit Message

feat(tests, debugger): testing the debugger triggering on errors

Run Details

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

125 existing lines in 4 files now uncovered.

8813 of 9434 relevant lines covered (93.42%)

273848.42 hits per line

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

92.17

/src/arkscript/REPL/Utils.cpp

#include <CLI/REPL/Utils.hpp>

#include <regex>
#include <algorithm>
#include <numeric>
#include <ranges>

#include <Ark/Builtins/Builtins.hpp>
#include <Ark/Compiler/Common.hpp>

namespace Ark::internal
{
    std::vector<std::string> getAllKeywords()
    {
        std::vector<std::string> output;
        output.reserve(keywords.size() + Language::listInstructions.size() + Language::operators.size() + Builtins::builtins.size() + 2);

        std::ranges::transform(keywords, std::back_inserter(output), [](const auto& string_view) {
            return std::string(string_view);
        });
        std::ranges::transform(Language::listInstructions, std::back_inserter(output), [](const auto& string_view) {
            return std::string(string_view);
        });
        std::ranges::transform(Language::operators, std::back_inserter(output), [](const auto& string_view) {
            return std::string(string_view);
        });
        std::ranges::transform(std::ranges::views::keys(Builtins::builtins), std::back_inserter(output), [](const auto& string) {
            return string;
        });

        output.emplace_back("and");
        output.emplace_back("or");

        return output;
    }

    std::vector<std::pair<std::string, replxx::Replxx::Color>> getColorPerKeyword()
    {
        using namespace replxx;
        using K = std::string;
        using V = Replxx::Color;

        std::vector<std::pair<K, V>> output;
        output.reserve(keywords.size() + Language::listInstructions.size() + Language::operators.size() + Builtins::builtins.size() + 4);

        std::ranges::transform(keywords, std::back_inserter(output), [](const auto& string_view) {
            return std::make_pair(std::string(string_view), Replxx::Color::BRIGHTRED);
        });
        std::ranges::transform(Language::listInstructions, std::back_inserter(output), [](const auto& string_view) {
            return std::make_pair(std::string(string_view), Replxx::Color::GREEN);
        });
        std::ranges::transform(Language::operators, std::back_inserter(output), [](const auto& string_view) {
            auto safe_op = std::string(string_view);
            if (const auto it = safe_op.find_first_of(R"(-+=/*<>[]()?")"); it != std::string::npos)
                safe_op.insert(it, "\\");
            return std::make_pair(safe_op, Replxx::Color::BRIGHTBLUE);
        });
        std::ranges::transform(std::ranges::views::keys(Builtins::builtins), std::back_inserter(output), [](const auto& string) {
            return std::make_pair(string, Replxx::Color::GREEN);
        });

        output.emplace_back("and", Replxx::Color::BRIGHTBLUE);
        output.emplace_back("or", Replxx::Color::BRIGHTBLUE);
        output.emplace_back("[\\-|+]?[0-9]+(\\.[0-9]+)?", Replxx::Color::YELLOW);
        output.emplace_back("\".*\"", Replxx::Color::MAGENTA);

        return output;
    }

    std::size_t codepointLength(const std::string& str)
    {
        return std::accumulate(
            str.begin(),
            str.end(),
            std::size_t { 0 },
            [](const std::size_t acc, const char c) {
                return acc + ((c & 0xc0) != 0x80);
            });
    }

    std::size_t contextLen(const std::string& prefix)
    {
        const std::string word_break = " \t\n\r\v\f=+*&^%$#@!,./?<>;`~'\"[]{}()\\|";
        std::size_t count = 0;

        for (const auto c : std::ranges::views::reverse(prefix))
        {
            if (word_break.find(c) != std::string::npos)
                break;
            ++count;
        }

        return count;
    }

    replxx::Replxx::completions_t hookCompletion(const std::vector<std::string>& words, const std::string& context, int& length)
    {
        replxx::Replxx::completions_t completions;
        std::size_t utf8_context_len = contextLen(context);
        std::size_t prefix_len = context.size() - utf8_context_len;

        if (prefix_len > 0 && context[prefix_len - 1] == '\\')
        {
            --prefix_len;
            ++utf8_context_len;
        }

        length = static_cast<int>(codepointLength(context.substr(prefix_len, utf8_context_len)));

        const std::string prefix = context.substr(prefix_len);
        for (const auto& e : words)
        {
            if (e.starts_with(prefix))
                completions.emplace_back(e.c_str());
        }

        return completions;
    }

    void hookColor(const std::vector<std::pair<std::string, replxx::Replxx::Color>>& words_colors, const std::string& context, replxx::Replxx::colors_t& colors)
    {
        // highlight matching regex sequences
        for (const auto& [regex, color] : words_colors)
        {
            std::size_t pos = 0;
            std::string str = context;
            std::smatch match;

            while (std::regex_search(str, match, std::regex(regex)))
            {
                std::string c = match[0];
                std::string prefix = match.prefix().str();
                const std::size_t len = codepointLength(c);

                pos += codepointLength(prefix);
                for (std::size_t i = 0; i < len; ++i)
                {
                    if (colors.at(pos + i) == replxx::Replxx::Color::DEFAULT)
                        colors.at(pos + i) = color;
                }

                pos += len;
                str = match.suffix();
            }
        }
    }

    replxx::Replxx::hints_t hookHint(const std::vector<std::string>& words, const std::string& context, int& length, replxx::Replxx::Color& color)
    {
        replxx::Replxx::hints_t hints;
        // only show hint if prefix is at least 'n' chars long
        // or if prefix begins with a specific character
        const std::size_t utf8_context_len = contextLen(context);
        const std::size_t prefix_len = context.size() - utf8_context_len;
        length = static_cast<int>(codepointLength(context.substr(prefix_len, utf8_context_len)));
        const std::string prefix = context.substr(prefix_len);

        if (prefix.size() >= 2 || (!prefix.empty() && prefix.at(0) == '.'))
        {
            for (const auto& e : words)
            {
                if (e.compare(0, prefix.size(), prefix) == 0)
                    hints.emplace_back(e.c_str());
            }
        }

        if (hints.size() == 1)
            color = replxx::Replxx::Color::GREEN;

        return hints;
    }
}

1	#include <CLI/REPL/Utils.hpp>
2
3	#include <regex>
4	#include <algorithm>
5	#include <numeric>
6	#include <ranges>
7
8	#include <Ark/Builtins/Builtins.hpp>
9	#include <Ark/Compiler/Common.hpp>
10
11	namespace Ark::internal
12	{
13	std::vector<std::string> getAllKeywords()	1✔
14	{	1✔
15	std::vector<std::string> output;	1✔
16	output.reserve(keywords.size() + Language::listInstructions.size() + Language::operators.size() + Builtins::builtins.size() + 2);	1✔
17
18	std::ranges::transform(keywords, std::back_inserter(output), [](const auto& string_view) {	10✔
19	return std::string(string_view);	9✔
UNCOV 20	});	×
21	std::ranges::transform(Language::listInstructions, std::back_inserter(output), [](const auto& string_view) {	10✔
22	return std::string(string_view);	9✔
UNCOV 23	});	×
24	std::ranges::transform(Language::operators, std::back_inserter(output), [](const auto& string_view) {	25✔
25	return std::string(string_view);	24✔
UNCOV 26	});	×
27	std::ranges::transform(std::ranges::views::keys(Builtins::builtins), std::back_inserter(output), [](const auto& string) {	69✔
28	return string;	68✔
29	});
30
31	output.emplace_back("and");	1✔
32	output.emplace_back("or");	1✔
33
34	return output;	1✔
35	}	1✔
36
37	std::vector<std::pair<std::string, replxx::Replxx::Color>> getColorPerKeyword()	1✔
38	{	1✔
39	using namespace replxx;
40	using K = std::string;
41	using V = Replxx::Color;
42
43	std::vector<std::pair<K, V>> output;	1✔
44	output.reserve(keywords.size() + Language::listInstructions.size() + Language::operators.size() + Builtins::builtins.size() + 4);	1✔
45
46	std::ranges::transform(keywords, std::back_inserter(output), [](const auto& string_view) {	10✔
47	return std::make_pair(std::string(string_view), Replxx::Color::BRIGHTRED);	9✔
UNCOV 48	});	×
49	std::ranges::transform(Language::listInstructions, std::back_inserter(output), [](const auto& string_view) {	10✔
50	return std::make_pair(std::string(string_view), Replxx::Color::GREEN);	9✔
UNCOV 51	});	×
52	std::ranges::transform(Language::operators, std::back_inserter(output), [](const auto& string_view) {	25✔
53	auto safe_op = std::string(string_view);	24✔
54	if (const auto it = safe_op.find_first_of(R"(-+=/*<>[]()?")"); it != std::string::npos)	36✔
55	safe_op.insert(it, "\\");	12✔
56	return std::make_pair(safe_op, Replxx::Color::BRIGHTBLUE);	24✔
57	});	24✔
58	std::ranges::transform(std::ranges::views::keys(Builtins::builtins), std::back_inserter(output), [](const auto& string) {	69✔
59	return std::make_pair(string, Replxx::Color::GREEN);	68✔
60	});
61
62	output.emplace_back("and", Replxx::Color::BRIGHTBLUE);	1✔
63	output.emplace_back("or", Replxx::Color::BRIGHTBLUE);	1✔
64	output.emplace_back("[\\-\|+]?[0-9]+(\\.[0-9]+)?", Replxx::Color::YELLOW);	1✔
65	output.emplace_back("\".*\"", Replxx::Color::MAGENTA);	1✔
66
67	return output;	1✔
68	}	1✔
69
70	std::size_t codepointLength(const std::string& str)	4✔
71	{	4✔
72	return std::accumulate(	4✔
73	str.begin(),	4✔
74	str.end(),	4✔
75	std::size_t { 0 },
76	[](const std::size_t acc, const char c) {	16✔
77	return acc + ((c & 0xc0) != 0x80);	16✔
78	});
79	}
80
81	std::size_t contextLen(const std::string& prefix)	2✔
82	{	2✔
83	const std::string word_break = " \t\n\r\v\f=+*&^%$#@!,./?<>;`~'\"[]{}()\\\|";	2✔
84	std::size_t count = 0;	2✔
85
86	for (const auto c : std::ranges::views::reverse(prefix))	12✔
87	{
88	if (word_break.find(c) != std::string::npos)	10✔
UNCOV 89	break;	×
90	++count;	10✔
91	}	10✔
92
93	return count;	2✔
94	}	2✔
95
96	replxx::Replxx::completions_t hookCompletion(const std::vector<std::string>& words, const std::string& context, int& length)	1✔
97	{	1✔
98	replxx::Replxx::completions_t completions;	1✔
99	std::size_t utf8_context_len = contextLen(context);	1✔
100	std::size_t prefix_len = context.size() - utf8_context_len;	1✔
101
102	if (prefix_len > 0 && context[prefix_len - 1] == '\\')	1✔
103	{
104	--prefix_len;	×
UNCOV 105	++utf8_context_len;	×
UNCOV 106	}	×
107
108	length = static_cast<int>(codepointLength(context.substr(prefix_len, utf8_context_len)));	1✔
109
110	const std::string prefix = context.substr(prefix_len);	1✔
111	for (const auto& e : words)	113✔
112	{
113	if (e.starts_with(prefix))	112✔
114	completions.emplace_back(e.c_str());	2✔
115	}	112✔
116
117	return completions;	1✔
118	}	1✔
119
120	void hookColor(const std::vector<std::pair<std::string, replxx::Replxx::Color>>& words_colors, const std::string& context, replxx::Replxx::colors_t& colors)	1✔
121	{	1✔
122	// highlight matching regex sequences
123	for (const auto& [regex, color] : words_colors)	236✔
124	{
125	std::size_t pos = 0;	114✔
126	std::string str = context;	114✔
127	std::smatch match;	114✔
128
129	while (std::regex_search(str, match, std::regex(regex)))	115✔
130	{
131	std::string c = match[0];	1✔
132	std::string prefix = match.prefix().str();	1✔
133	const std::size_t len = codepointLength(c);	1✔
134
135	pos += codepointLength(prefix);	1✔
136	for (std::size_t i = 0; i < len; ++i)	7✔
137	{
138	if (colors.at(pos + i) == replxx::Replxx::Color::DEFAULT)	6✔
139	colors.at(pos + i) = color;	6✔
140	}	6✔
141
142	pos += len;	1✔
143	str = match.suffix();	1✔
144	}	1✔
145	}	114✔
146	}	1✔
147
148	replxx::Replxx::hints_t hookHint(const std::vector<std::string>& words, const std::string& context, int& length, replxx::Replxx::Color& color)	1✔
149	{	1✔
150	replxx::Replxx::hints_t hints;	1✔
151	// only show hint if prefix is at least 'n' chars long
152	// or if prefix begins with a specific character
153	const std::size_t utf8_context_len = contextLen(context);	1✔
154	const std::size_t prefix_len = context.size() - utf8_context_len;	1✔
155	length = static_cast<int>(codepointLength(context.substr(prefix_len, utf8_context_len)));	1✔
156	const std::string prefix = context.substr(prefix_len);	1✔
157
158	if (prefix.size() >= 2 \|\| (!prefix.empty() && prefix.at(0) == '.'))	1✔
159	{
160	for (const auto& e : words)	113✔
161	{
162	if (e.compare(0, prefix.size(), prefix) == 0)	112✔
163	hints.emplace_back(e.c_str());	1✔
164	}	112✔
165	}	1✔
166
167	if (hints.size() == 1)	1✔
168	color = replxx::Replxx::Color::GREEN;	1✔
169
170	return hints;	1✔
171	}	1✔
172	}

ArkScript-lang / Ark / 21146409233

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