22263246436

Committed 21 Feb 2026 07:51PM UTC coverage: 98.659%. Remained the same

Build # 22263246436

Build Type

push

github

Committed by

mzdun

Commit Message

ci: adding coverage comment to GitHub PR

Run Details

4562 of 4624 relevant lines covered (98.66%)

2266.46 hits per line

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

86.52

/libs/libconv/src/validators.cpp

// Copyright (c) 2026 midnightBITS
// This code is licensed under MIT license (see LICENSE for details)

#include <quick_dra/conv/low_level.hpp>
#include <quick_dra/conv/validators.hpp>
#include <quick_dra/lex/validators.hpp>
#include <string>
#include <utility>

namespace quick_dra::builtin {
        namespace {
                bool valid_nonempty_string(std::string&& value,
                                           std::optional<std::string>& dst) {
                        if (value.empty()) return false;
                        dst = std::move(value);
                        return true;
                }
        }  // namespace

        bool valid_first_name(std::string&& value,
                              std::optional<std::string>& dst,
                              bool) {
                return valid_nonempty_string(std::move(value), dst);
        }
        bool valid_last_name(std::string&& value,
                             std::optional<std::string>& dst,
                             bool) {
                return valid_nonempty_string(std::move(value), dst);
        }

        bool valid_social_id(std::string&& value,
                             std::optional<std::string>& dst,
                             bool) {
                if (!social_id_validator::is_valid(value)) {
                        comment("The social id provided seems to be invalid.");
                        return false;
                }
                dst = std::move(value);
                return true;
        }

        bool valid_id_card(std::string&& value,
                           std::optional<std::string>& dst,
                           bool) {
                if (!id_card_validator::is_valid(value)) {
                        comment("The ID card provided seems to be invalid.");
                        return false;
                }
                dst = std::move(value);
                return true;
        }

        bool valid_passport(std::string&& value,
                            std::optional<std::string>& dst,
                            bool) {
                if (!pl_passport_validator::is_valid(value)) {
                        comment("The passport number provided seems to be invalid.");
                        return false;
                }
                dst = std::move(value);
                return true;
        }

        bool valid_tax_id(std::string&& value,
                          std::optional<std::string>& dst,
                          bool) {
                std::string non_dashed{};
                non_dashed.reserve(value.size());
                for (auto const ch : value) {
                        if (ch == '-') continue;
                        non_dashed.push_back(ch);
                }
                if (!tax_id_validator::is_valid(non_dashed)) {
                        comment("The tax id provided seems to be invalid.");
                        return false;
                }
                dst = std::move(non_dashed);
                return true;
        }

        bool valid_title(std::string&& value,
                         std::optional<insurance_title>& dst,
                         bool) {
                insurance_title title{};
                if (!insurance_title::parse(value, title)) {
                        comment("The insurance title value provided seems to be invalid.");
                        return false;
                }

                dst = title;
                return true;
        }

        bool valid_part_time_scale(std::string&& value,
                                   std::optional<ratio>& dst,
                                   bool) {
                ratio scale{};
                if (!ratio::parse(value, scale)) {
                        comment("The ratio value provided seems to be invalid.");
                        return false;
                }

                dst = scale;
                return true;
        }

        bool valid_salary(std::string&& value, std::optional<currency>& dst, bool) {
                using std::literals::operator""sv;

                if (value == "minimal"sv) {
                        dst = minimal_salary;
                        return true;
                }

                currency money{};
                if (!currency::parse(value, money)) {
                        comment("The monetary value provided seems to be invalid.");
                        return false;
                }

                dst = money;
                return true;
        }
}  // namespace quick_dra::builtin

1	// Copyright (c) 2026 midnightBITS
2	// This code is licensed under MIT license (see LICENSE for details)
3
4	#include <quick_dra/conv/low_level.hpp>
5	#include <quick_dra/conv/validators.hpp>
6	#include <quick_dra/lex/validators.hpp>
7	#include <string>
8	#include <utility>
9
10	namespace quick_dra::builtin {
11	namespace {
12	bool valid_nonempty_string(std::string&& value,	480✔
13	std::optional<std::string>& dst) {	1✔
14	if (value.empty()) return false;	481✔
15	dst = std::move(value);	481✔
16	return true;	1,441✔
17	}	961✔
18	} // namespace
19
20	bool valid_first_name(std::string&& value,	240✔
21	std::optional<std::string>& dst,
22	bool) {	1✔
23	return valid_nonempty_string(std::move(value), dst);	721✔
24	}	481✔
25	bool valid_last_name(std::string&& value,	240✔
26	std::optional<std::string>& dst,
27	bool) {	1✔
28	return valid_nonempty_string(std::move(value), dst);	721✔
29	}	481✔
30
31	bool valid_social_id(std::string&& value,	84✔
32	std::optional<std::string>& dst,
33	bool) {	1✔
34	if (!social_id_validator::is_valid(value)) {	85✔
35	comment("The social id provided seems to be invalid.");	×
36	return false;	×
37	}
38	dst = std::move(value);	85✔
39	return true;	253✔
40	}	169✔
41
42	bool valid_id_card(std::string&& value,	96✔
43	std::optional<std::string>& dst,
44	bool) {	1✔
45	if (!id_card_validator::is_valid(value)) {	97✔
46	comment("The ID card provided seems to be invalid.");	×
47	return false;	×
48	}
49	dst = std::move(value);	97✔
50	return true;	289✔
51	}	193✔
52
53	bool valid_passport(std::string&& value,	84✔
54	std::optional<std::string>& dst,
55	bool) {	1✔
56	if (!pl_passport_validator::is_valid(value)) {	85✔
57	comment("The passport number provided seems to be invalid.");	19✔
58	return false;	19✔
59	}	12✔
60	dst = std::move(value);	79✔
61	return true;	235✔
62	}	169✔
63
64	bool valid_tax_id(std::string&& value,	21✔
65	std::optional<std::string>& dst,
66	bool) {	1✔
67	std::string non_dashed{};	64✔
68	non_dashed.reserve(value.size());	64✔
69	for (auto const ch : value) {	652✔
70	if (ch == '-') continue;	211✔
71	non_dashed.push_back(ch);	211✔
72	}	421✔
73	if (!tax_id_validator::is_valid(non_dashed)) {	22✔
74	comment("The tax id provided seems to be invalid.");	×
75	return false;	×
76	}
77	dst = std::move(non_dashed);	22✔
78	return true;	64✔
79	}	64✔
80
81	bool valid_title(std::string&& value,	213✔
82	std::optional<insurance_title>& dst,
83	bool) {	1✔
84	insurance_title title{};	639✔
85	if (!insurance_title::parse(value, title)) {	214✔
86	comment("The insurance title value provided seems to be invalid.");	×
87	return false;	×
88	}
89		426✔
90	dst = title;	214✔
91	return true;	640✔
92	}	640✔
93
94	bool valid_part_time_scale(std::string&& value,	126✔
95	std::optional<ratio>& dst,
96	bool) {	1✔
97	ratio scale{};	378✔
98	if (!ratio::parse(value, scale)) {	127✔
99	comment("The ratio value provided seems to be invalid.");	×
100	return false;	×
101	}
102		252✔
103	dst = scale;	127✔
104	return true;	379✔
105	}	253✔
106
107	bool valid_salary(std::string&& value, std::optional<currency>& dst, bool) {	214✔
108	using std::literals::operator""sv;	426✔
109		426✔
110	if (value == "minimal"sv) {	214✔
111	dst = minimal_salary;	298✔
112	return true;	298✔
113	}	198✔
114		228✔
115	currency money{};	115✔
116	if (!currency::parse(value, money)) {	115✔
117	comment("The monetary value provided seems to be invalid.");	×
118	return false;	×
119	}
120		228✔
121	dst = money;	115✔
122	return true;	343✔
123	}	229✔
124	} // namespace quick_dra::builtin

mbits-os / quick_dra / 22263246436

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