20625514448

Committed 31 Dec 2025 07:10PM UTC coverage: 85.145% (-0.08%) from 85.223%

Build # 20625514448

Build Type

push

github

Committed by

web-flow

Commit Message

Bump src/taskchampion-cpp/corrosion from `5a10dc1` to `56a1ed1` (#4016)

Bumps [src/taskchampion-cpp/corrosion](https://github.com/corrosion-rs/corrosion) from `5a10dc1` to `56a1ed1`.
- [Release notes](https://github.com/corrosion-rs/corrosion/releases)
- [Commits](https://github.com/corrosion-rs/corrosion/compare/5a10dc1f8...<a class=hub.com/GothenburgBitFactory/taskwarrior/commit/56a1ed11ad7841255048659024363cd0fade31f4">56a1ed11a)

---
updated-dependencies:
- dependency-name: src/taskchampion-cpp/corrosion
  dependency-version: 56a1ed11ad7841255048659024363cd0fade31f4
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

19585 of 23002 relevant lines covered (85.14%)

23452.82 hits per line

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

76.69

/src/sort.cpp

////////////////////////////////////////////////////////////////////////////////
//
// Copyright 2006 - 2021, Tomas Babej, Paul Beckingham, Federico Hernandez.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// https://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////

#include <cmake.h>
// cmake.h include header must come first

#include <Context.h>
#include <Duration.h>
#include <Task.h>
#include <format.h>
#include <shared.h>
#include <stdlib.h>
#include <util.h>

#include <algorithm>
#include <functional>
#include <list>
#include <map>
#include <random>
#include <string>
#include <vector>

static std::vector<Task>* global_data = nullptr;
static std::vector<std::string> global_keys;
static unsigned int sort_random_seed = 0;
static bool sort_compare(int, int);

////////////////////////////////////////////////////////////////////////////////
void sort_tasks(std::vector<Task>& data, std::vector<int>& order, const std::string& keys) {
  Timer timer;
  global_data = &data;

  // Split the key defs.
  global_keys = split(keys, ',');

  // Generate a random seend for sorting by "random".
  if (sort_random_seed == 0) {
    // For testing purposes, allow the seed to be specified in an undocumented configuration
    // setting.
    std::string seed_str = Context::getContext().config.get("debug.random.seed");
    if (seed_str.empty()) {
      std::random_device rd;
      sort_random_seed = rd();
    } else {
      sort_random_seed = std::stoul(seed_str);
    }
  }

  // Only sort if necessary.
  if (order.size()) std::stable_sort(order.begin(), order.end(), sort_compare);

  Context::getContext().time_sort_us += timer.total_us();
}

void sort_projects(std::list<std::pair<std::string, int>>& sorted,
                   std::map<std::string, int>& allProjects) {
  for (auto& project : allProjects) {
    const std::vector<std::string> parents = extractParents(project.first);
    if (parents.size()) {
      // if parents exist: store iterator position of last parent
      std::list<std::pair<std::string, int>>::iterator parent_pos;
      for (auto& parent : parents) {
        parent_pos = std::find_if(
            sorted.begin(), sorted.end(),
            [&parent](const std::pair<std::string, int>& item) { return item.first == parent; });

        // if parent does not exist yet: insert into sorted view
        if (parent_pos == sorted.end()) sorted.emplace_back(parent, 1);
      }

      // insert new element below latest parent
      sorted.insert((parent_pos == sorted.end()) ? parent_pos : ++parent_pos, project);
    } else {
      // if has no parents: simply push to end of list
      sorted.push_back(project);
    }
  }
}

void sort_projects(std::list<std::pair<std::string, int>>& sorted,
                   std::map<std::string, bool>& allProjects) {
  std::map<std::string, int> allProjectsInt;
  for (auto& p : allProjects) allProjectsInt[p.first] = (int)p.second;

  sort_projects(sorted, allProjectsInt);
}

////////////////////////////////////////////////////////////////////////////////
// Re-implementation, using direct Task access instead of data copies that
// require re-parsing.
//
// Essentially a static implementation of a dynamic operator<.
static bool sort_compare(int left, int right) {
  std::string field;
  bool ascending;
  bool breakIndicator;
  Column* column;
  int left_number;
  int right_number;
  float left_real;
  float right_real;

  for (auto& k : global_keys) {
    Context::getContext().decomposeSortField(k, field, ascending, breakIndicator);

    // Random.
    if (field == "random") {
      // For "random" sort, we produce a stable number for each task based on a hash of its
      // UUID plus the random seed.
      std::string left_uuid = (*global_data)[left].get("uuid");
      std::string right_uuid = (*global_data)[right].get("uuid");

      std::string left_scrambled =
          std::to_string(std::hash<std::string>{}(left_uuid + std::to_string(sort_random_seed)));
      std::string right_scrambled =
          std::to_string(std::hash<std::string>{}(right_uuid + std::to_string(sort_random_seed)));

      if (left_scrambled == right_scrambled) continue;

      return ascending ? (left_scrambled < right_scrambled) : (left_scrambled > right_scrambled);
    }

    // Urgency.
    else if (field == "urgency") {
      left_real = (*global_data)[left].urgency();
      right_real = (*global_data)[right].urgency();

      if (left_real == right_real) continue;

      return ascending ? (left_real < right_real) : (left_real > right_real);
    }

    // Number.
    else if (field == "id") {
      left_number = (*global_data)[left].id;
      right_number = (*global_data)[right].id;

      if (left_number == right_number) continue;

      return ascending ? (left_number < right_number) : (left_number > right_number);
    }

    // String.
    else if (field == "description" || field == "project" || field == "status" || field == "tags" ||
             field == "uuid" || field == "parent" || field == "imask" || field == "mask") {
      auto left_string = (*global_data)[left].get_ref(field);
      auto right_string = (*global_data)[right].get_ref(field);

      if (left_string == right_string) continue;

      return ascending ? (left_string < right_string) : (left_string > right_string);
    }

    // Due Date.
    else if (field == "due" || field == "end" || field == "entry" || field == "start" ||
             field == "until" || field == "wait" || field == "modified" || field == "scheduled") {
      auto left_string = (*global_data)[left].get_ref(field);
      auto right_string = (*global_data)[right].get_ref(field);

      if (left_string != "" && right_string == "") return true;

      if (left_string == "" && right_string != "") return false;

      if (left_string == right_string) continue;

      return ascending ? (left_string < right_string) : (left_string > right_string);
    }

    // Depends string.
    else if (field == "depends") {
      // Raw data is an un-sorted list of UUIDs.  We just need a stable
      // sort, so we sort them lexically.
      auto left_deps = (*global_data)[left].getDependencyUUIDs();
      std::sort(left_deps.begin(), left_deps.end());
      auto right_deps = (*global_data)[right].getDependencyUUIDs();
      std::sort(right_deps.begin(), right_deps.end());

      if (left_deps == right_deps) continue;

      if (left_deps.size() == 0 && right_deps.size() > 0) return ascending;

      if (left_deps.size() > 0 && right_deps.size() == 0) return !ascending;

      // Sort on the first dependency.
      left_number = Context::getContext().tdb2.id(left_deps[0]);
      right_number = Context::getContext().tdb2.id(right_deps[0]);

      if (left_number == right_number) continue;

      return ascending ? (left_number < right_number) : (left_number > right_number);
    }

    // Duration.
    else if (field == "recur") {
      auto left_string = (*global_data)[left].get_ref(field);
      auto right_string = (*global_data)[right].get_ref(field);

      if (left_string == right_string) continue;

      Duration left_duration(left_string);
      Duration right_duration(right_string);
      return ascending ? (left_duration < right_duration) : (left_duration > right_duration);
    }

    // UDAs.
    else if ((column = Context::getContext().columns[field]) != nullptr) {
      std::string type = column->type();
      if (type == "numeric") {
        auto left_real = strtof(((*global_data)[left].get_ref(field)).c_str(), nullptr);
        auto right_real = strtof(((*global_data)[right].get_ref(field)).c_str(), nullptr);

        if (left_real == right_real) continue;

        return ascending ? (left_real < right_real) : (left_real > right_real);
      } else if (type == "string") {
        auto left_string = (*global_data)[left].get_ref(field);
        auto right_string = (*global_data)[right].get_ref(field);

        if (left_string == right_string) continue;

        // UDAs of the type string can have custom sort orders, which need to be considered.
        auto order = Task::customOrder.find(field);
        if (order != Task::customOrder.end()) {
          // Guaranteed to be found, because of ColUDA::validate ().
          auto posLeft = std::find(order->second.begin(), order->second.end(), left_string);
          auto posRight = std::find(order->second.begin(), order->second.end(), right_string);
          return ascending ? (posLeft < posRight) : (posLeft > posRight);
        } else {
          // Empty values are unconditionally last, if no custom order was specified.
          if (left_string == "")
            return false;
          else if (right_string == "")
            return true;

          return ascending ? (left_string < right_string) : (left_string > right_string);
        }
      }

      else if (type == "date") {
        auto left_string = (*global_data)[left].get_ref(field);
        auto right_string = (*global_data)[right].get_ref(field);

        if (left_string != "" && right_string == "") return true;

        if (left_string == "" && right_string != "") return false;

        if (left_string == right_string) continue;

        return ascending ? (left_string < right_string) : (left_string > right_string);
      } else if (type == "duration") {
        auto left_string = (*global_data)[left].get_ref(field);
        auto right_string = (*global_data)[right].get_ref(field);

        if (left_string == right_string) continue;

        Duration left_duration(left_string);
        Duration right_duration(right_string);
        return ascending ? (left_duration < right_duration) : (left_duration > right_duration);
      }
    } else
      throw format("The '{1}' column is not a valid sort field.", field);
  }

  return false;
}

////////////////////////////////////////////////////////////////////////////////

1	////////////////////////////////////////////////////////////////////////////////
2	//
3	// Copyright 2006 - 2021, Tomas Babej, Paul Beckingham, Federico Hernandez.
4	//
5	// Permission is hereby granted, free of charge, to any person obtaining a copy
6	// of this software and associated documentation files (the "Software"), to deal
7	// in the Software without restriction, including without limitation the rights
8	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9	// copies of the Software, and to permit persons to whom the Software is
10	// furnished to do so, subject to the following conditions:
11	//
12	// The above copyright notice and this permission notice shall be included
13	// in all copies or substantial portions of the Software.
14	//
15	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18	// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21	// SOFTWARE.
22	//
23	// https://www.opensource.org/licenses/mit-license.php
24	//
25	////////////////////////////////////////////////////////////////////////////////
26
27	#include <cmake.h>
28	// cmake.h include header must come first
29
30	#include <Context.h>
31	#include <Duration.h>
32	#include <Task.h>
33	#include <format.h>
34	#include <shared.h>
35	#include <stdlib.h>
36	#include <util.h>
37
38	#include <algorithm>
39	#include <functional>
40	#include <list>
41	#include <map>
42	#include <random>
43	#include <string>
44	#include <vector>
45
46	static std::vector<Task>* global_data = nullptr;
47	static std::vector<std::string> global_keys;
48	static unsigned int sort_random_seed = 0;
49	static bool sort_compare(int, int);
50
51	////////////////////////////////////////////////////////////////////////////////
52	void sort_tasks(std::vector<Task>& data, std::vector<int>& order, const std::string& keys) {	715✔
53	Timer timer;	715✔
54	global_data = &data;	715✔
55
56	// Split the key defs.
57	global_keys = split(keys, ',');	715✔
58
59	// Generate a random seend for sorting by "random".
60	if (sort_random_seed == 0) {	715✔
61	// For testing purposes, allow the seed to be specified in an undocumented configuration
62	// setting.
63	std::string seed_str = Context::getContext().config.get("debug.random.seed");	1,430✔
64	if (seed_str.empty()) {	715✔
65	std::random_device rd;	715✔
66	sort_random_seed = rd();	715✔
67	} else {	715✔
68	sort_random_seed = std::stoul(seed_str);	×
69	}
70	}	715✔
71
72	// Only sort if necessary.
73	if (order.size()) std::stable_sort(order.begin(), order.end(), sort_compare);	715✔
74
75	Context::getContext().time_sort_us += timer.total_us();	715✔
76	}	715✔
77
78	void sort_projects(std::list<std::pair<std::string, int>>& sorted,	16✔
79	std::map<std::string, int>& allProjects) {
80	for (auto& project : allProjects) {	46✔
81	const std::vector<std::string> parents = extractParents(project.first);	30✔
82	if (parents.size()) {	30✔
83	// if parents exist: store iterator position of last parent
84	std::list<std::pair<std::string, int>>::iterator parent_pos;	6✔
85	for (auto& parent : parents) {	12✔
86	parent_pos = std::find_if(	6✔
87	sorted.begin(), sorted.end(),
88	[&parent](const std::pair<std::string, int>& item) { return item.first == parent; });	17✔
89
90	// if parent does not exist yet: insert into sorted view
91	if (parent_pos == sorted.end()) sorted.emplace_back(parent, 1);	6✔
92	}
93
94	// insert new element below latest parent
95	sorted.insert((parent_pos == sorted.end()) ? parent_pos : ++parent_pos, project);	6✔
96	} else {
97	// if has no parents: simply push to end of list
98	sorted.push_back(project);	24✔
99	}
100	}	30✔
101	}	16✔
102
103	void sort_projects(std::list<std::pair<std::string, int>>& sorted,	6✔
104	std::map<std::string, bool>& allProjects) {
105	std::map<std::string, int> allProjectsInt;	6✔
106	for (auto& p : allProjects) allProjectsInt[p.first] = (int)p.second;	17✔
107
108	sort_projects(sorted, allProjectsInt);	6✔
109	}	6✔
110
111	////////////////////////////////////////////////////////////////////////////////
112	// Re-implementation, using direct Task access instead of data copies that
113	// require re-parsing.
114	//
115	// Essentially a static implementation of a dynamic operator<.
116	static bool sort_compare(int left, int right) {	1,936✔
117	std::string field;	1,936✔
118	bool ascending;
119	bool breakIndicator;
120	Column* column;
121	int left_number;
122	int right_number;
123	float left_real;
124	float right_real;
125
126	for (auto& k : global_keys) {	3,827✔
127	Context::getContext().decomposeSortField(k, field, ascending, breakIndicator);	3,459✔
128
129	// Random.
130	if (field == "random") {	3,459✔
131	// For "random" sort, we produce a stable number for each task based on a hash of its
132	// UUID plus the random seed.
133	std::string left_uuid = (*global_data)[left].get("uuid");	×
134	std::string right_uuid = (*global_data)[right].get("uuid");	×
135
136	std::string left_scrambled =
137	std::to_string(std::hash<std::string>{}(left_uuid + std::to_string(sort_random_seed)));	×
138	std::string right_scrambled =
139	std::to_string(std::hash<std::string>{}(right_uuid + std::to_string(sort_random_seed)));	×
140
141	if (left_scrambled == right_scrambled) continue;	×
142
143	return ascending ? (left_scrambled < right_scrambled) : (left_scrambled > right_scrambled);	×
144	}	×
145
146	// Urgency.
147	else if (field == "urgency") {	3,459✔
148	left_real = (*global_data)[left].urgency();	143✔
149	right_real = (*global_data)[right].urgency();	143✔
150
151	if (left_real == right_real) continue;	143✔
152
153	return ascending ? (left_real < right_real) : (left_real > right_real);	57✔
154	}
155
156	// Number.
157	else if (field == "id") {	3,316✔
158	left_number = (*global_data)[left].id;	294✔
159	right_number = (*global_data)[right].id;	294✔
160
161	if (left_number == right_number) continue;	294✔
162
163	return ascending ? (left_number < right_number) : (left_number > right_number);	87✔
164	}
165
166	// String.
167	else if (field == "description" \|\| field == "project" \|\| field == "status" \|\| field == "tags" \|\|	5,388✔
168	field == "uuid" \|\| field == "parent" \|\| field == "imask" \|\| field == "mask") {	5,388✔
169	auto left_string = (*global_data)[left].get_ref(field);	1,114✔
170	auto right_string = (*global_data)[right].get_ref(field);	1,114✔
171
172	if (left_string == right_string) continue;	1,114✔
173
174	return ascending ? (left_string < right_string) : (left_string > right_string);	965✔
175	}	2,228✔
176
177	// Due Date.
178	else if (field == "due" \|\| field == "end" \|\| field == "entry" \|\| field == "start" \|\|	3,375✔
179	field == "until" \|\| field == "wait" \|\| field == "modified" \|\| field == "scheduled") {	3,375✔
180	auto left_string = (*global_data)[left].get_ref(field);	1,856✔
181	auto right_string = (*global_data)[right].get_ref(field);	1,856✔
182
183	if (left_string != "" && right_string == "") return true;	1,856✔
184
185	if (left_string == "" && right_string != "") return false;	1,835✔
186
187	if (left_string == right_string) continue;	1,832✔
188
189	return ascending ? (left_string < right_string) : (left_string > right_string);	384✔
190	}	3,712✔
191
192	// Depends string.
193	else if (field == "depends") {	52✔
194	// Raw data is an un-sorted list of UUIDs. We just need a stable
195	// sort, so we sort them lexically.
196	auto left_deps = (*global_data)[left].getDependencyUUIDs();	×
197	std::sort(left_deps.begin(), left_deps.end());	×
198	auto right_deps = (*global_data)[right].getDependencyUUIDs();	×
199	std::sort(right_deps.begin(), right_deps.end());	×
200
201	if (left_deps == right_deps) continue;	×
202
203	if (left_deps.size() == 0 && right_deps.size() > 0) return ascending;	×
204
205	if (left_deps.size() > 0 && right_deps.size() == 0) return !ascending;	×
206
207	// Sort on the first dependency.
208	left_number = Context::getContext().tdb2.id(left_deps[0]);	×
209	right_number = Context::getContext().tdb2.id(right_deps[0]);	×
210
211	if (left_number == right_number) continue;	×
212
213	return ascending ? (left_number < right_number) : (left_number > right_number);	×
214	}	×
215
216	// Duration.
217	else if (field == "recur") {	52✔
218	auto left_string = (*global_data)[left].get_ref(field);	7✔
219	auto right_string = (*global_data)[right].get_ref(field);	7✔
220
221	if (left_string == right_string) continue;	7✔
222
223	Duration left_duration(left_string);	7✔
224	Duration right_duration(right_string);	7✔
225	return ascending ? (left_duration < right_duration) : (left_duration > right_duration);	7✔
226	}	14✔
227
228	// UDAs.
229	else if ((column = Context::getContext().columns[field]) != nullptr) {	45✔
230	std::string type = column->type();	45✔
231	if (type == "numeric") {	45✔
232	auto left_real = strtof(((*global_data)[left].get_ref(field)).c_str(), nullptr);	12✔
233	auto right_real = strtof(((*global_data)[right].get_ref(field)).c_str(), nullptr);	12✔
234
235	if (left_real == right_real) continue;	12✔
236
237	return ascending ? (left_real < right_real) : (left_real > right_real);	12✔
238	} else if (type == "string") {	33✔
239	auto left_string = (*global_data)[left].get_ref(field);	32✔
240	auto right_string = (*global_data)[right].get_ref(field);	32✔
241
242	if (left_string == right_string) continue;	32✔
243
244	// UDAs of the type string can have custom sort orders, which need to be considered.
245	auto order = Task::customOrder.find(field);	31✔
246	if (order != Task::customOrder.end()) {	31✔
247	// Guaranteed to be found, because of ColUDA::validate ().
248	auto posLeft = std::find(order->second.begin(), order->second.end(), left_string);	22✔
249	auto posRight = std::find(order->second.begin(), order->second.end(), right_string);	22✔
250	return ascending ? (posLeft < posRight) : (posLeft > posRight);	22✔
251	} else {
252	// Empty values are unconditionally last, if no custom order was specified.
253	if (left_string == "")	9✔
254	return false;	4✔
255	else if (right_string == "")	5✔
256	return true;	3✔
257
258	return ascending ? (left_string < right_string) : (left_string > right_string);	2✔
259	}
260	}	64✔
261
262	else if (type == "date") {	1✔
263	auto left_string = (*global_data)[left].get_ref(field);	1✔
264	auto right_string = (*global_data)[right].get_ref(field);	1✔
265
266	if (left_string != "" && right_string == "") return true;	1✔
267
268	if (left_string == "" && right_string != "") return false;	×
269
270	if (left_string == right_string) continue;	×
271
272	return ascending ? (left_string < right_string) : (left_string > right_string);	×
273	} else if (type == "duration") {	2✔
274	auto left_string = (*global_data)[left].get_ref(field);	×
275	auto right_string = (*global_data)[right].get_ref(field);	×
276
277	if (left_string == right_string) continue;	×
278
279	Duration left_duration(left_string);	×
280	Duration right_duration(right_string);	×
281	return ascending ? (left_duration < right_duration) : (left_duration > right_duration);	×
282	}	×
283	} else	45✔
284	throw format("The '{1}' column is not a valid sort field.", field);	×
285	}
286
287	return false;	368✔
288	}	1,936✔
289
290	////////////////////////////////////////////////////////////////////////////////

GothenburgBitFactory / taskwarrior / 20625514448

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