Convert classes and files to snake_case

external/mirai-core/CMakeLists.txt

@@ -6,14 +6,14 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
 
 add_library(mirai-core 
-	src/Mirai.cpp
+	src/core.cpp
-	src/Task.cpp
+	src/task.cpp
-	src/Event.cpp
+	src/event.cpp
-	src/DateTime.cpp
+	src/date.cpp
 	src/EventEmitter.cpp 
-	src/Source.cpp 
+	src/source.cpp 
-	src/MarkdownDataProvider.cpp 
+	src/markdown_data_provider.cpp 
-	src/MarkdownDataProvider.Parser.cpp 
+	src/markdown_data_provider.parser.cpp 
 	src/utils.cpp
 )
 

external/mirai-core/include/mirai-core/DateTime.h

@@ -1,64 +0,0 @@
-/*
- * Mirai. Copyright (C) 2024 Vyn
- * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
- * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
- */
-
-#pragma once
-
-#include <bits/chrono.h>
-#include <chrono>
-#include <ctime>
-#include <optional>
-#include <string>
-
-namespace mirai
-{
-
-struct Date {
-	explicit Date(int year, unsigned month, unsigned day);
-
-	explicit Date(std::chrono::time_point<std::chrono::system_clock> tp);
-	explicit Date(std::chrono::year_month_day chronoDate);
-
-	bool operator==(const Date &other) const;
-	bool operator<(const Date &other) const;
-	bool operator>(const Date &other) const;
-	bool operator>=(const Date &other) const;
-	bool operator<=(const Date &other) const;
-
-	std::chrono::year_month_day toStdChrono() const
-	{
-		return std::chrono::year_month_day{
-			std::chrono::year(year),
-			std::chrono::month(month),
-			std::chrono::day(day),
-		};
-	}
-
-	int toIntRepresentation()
-	{
-		return day + month * 100 + year * 10000;
-	}
-
-	int year;
-	unsigned month;
-	unsigned day;
-};
-
-struct Time {
-
-	explicit Time(int hour, int minute);
-	explicit Time(std::chrono::time_point<std::chrono::system_clock> tp);
-
-	bool operator==(const Time &other) const;
-	bool operator<(const Time &other) const;
-	bool operator>(const Time &other) const;
-
-	int hour;
-	int minute;
-};
-
-std::optional<mirai::Date> stringToDate(const std::string &dateStr);
-
-} // namespace mirai

external/mirai-core/include/mirai-core/core.h

@@ -7,7 +7,7 @@
 #pragma once
 
 #include "EventEmitter.h"
-#include "Source.h"
+#include "source.h"
 #include <functional>
 #include <memory>
 #include <optional>
@@ -16,11 +16,11 @@
 namespace mirai
 {
 
-class Mirai
+class core
 {
 
   public:
-	Mirai(const std::string &configFilePath);
+	core(const std::string &configFilePath);
 	void addSource(
 		const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&source
 	);

external/mirai-core/include/mirai-core/data_provider.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "DateTime.h"
+#include "date.h"
 #include <optional>
 #include <string>
 #include <vector>
@@ -20,28 +20,28 @@ struct task_data {
 	int id;
 	std::string title;
 	task_state state;
-	std::optional<Date> due_date;
+	std::optional<class date> due_date;
 };
 
 struct updatable_task_data {
 	std::optional<std::string> title = std::nullopt;
 	std::optional<task_state> state = std::nullopt;
-	std::optional<std::optional<Date>> due_date = std::nullopt;
+	std::optional<std::optional<class date>> due_date = std::nullopt;
 };
 
 struct event_data {
 	int id;
-	Date date;
+	class date date;
 	std::string title;
-	Time starts_at;
+	time starts_at;
-	Time ends_at;
+	time ends_at;
 };
 
 struct updatable_event_data {
-	std::optional<Date> date;
+	std::optional<class date> date;
 	std::optional<std::string> title;
-	std::optional<Time> starts_at;
+	std::optional<time> starts_at;
-	std::optional<Time> ends_at;
+	std::optional<time> ends_at;
 };
 
 class data_provider
@@ -62,7 +62,7 @@ class data_provider
 	virtual task_data insert_task(const task_data &task) = 0;
 	virtual void remove_task_by_id(int taskId) = 0;
 	virtual std::optional<task_data> get_task_by_id(int taskId) = 0;
-	virtual std::vector<task_data> get_tasks_by_date(Date date) = 0;
+	virtual std::vector<task_data> get_tasks_by_date(class date date) = 0;
 	virtual std::vector<task_data> get_tasks_without_date() = 0;
 	virtual std::vector<task_data> get_tasks() = 0;
 	virtual void update_task(int taskId, updatable_task_data updateData) = 0;
@@ -72,7 +72,7 @@ class data_provider
 	virtual void remove_event_by_id(int eventId) = 0;
 	virtual std::optional<event_data> get_event_by_id(int eventId) = 0;
 	virtual std::vector<event_data> get_events() = 0;
-	virtual std::vector<event_data> get_events_by_date(Date date) = 0;
+	virtual std::vector<event_data> get_events_by_date(class date date) = 0;
 	virtual void update_event(int eventId, updatable_event_data updateData) = 0;
 
 	const int id = data_provider::generate_next_id();

external/mirai-core/include/mirai-core/date.h

@@ -0,0 +1,59 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include <bits/chrono.h>
+#include <chrono>
+#include <ctime>
+#include <optional>
+#include <string>
+
+namespace mirai
+{
+
+struct date {
+	explicit date(int year, unsigned month, unsigned day);
+
+	explicit date(std::chrono::time_point<std::chrono::system_clock> tp);
+	explicit date(std::chrono::year_month_day chronoDate);
+
+	bool operator==(const date &other) const;
+	bool operator<(const date &other) const;
+	bool operator>(const date &other) const;
+	bool operator>=(const date &other) const;
+	bool operator<=(const date &other) const;
+
+	std::chrono::year_month_day to_std_chrono() const
+	{
+		return std::chrono::year_month_day{
+			std::chrono::year(year),
+			std::chrono::month(month),
+			std::chrono::day(day),
+		};
+	}
+
+	int year;
+	unsigned month;
+	unsigned day;
+};
+
+struct time {
+
+	explicit time(int hour, int minute);
+	explicit time(std::chrono::time_point<std::chrono::system_clock> tp);
+
+	bool operator==(const time &other) const;
+	bool operator<(const time &other) const;
+	bool operator>(const time &other) const;
+
+	int hour;
+	int minute;
+};
+
+std::optional<class date> string_to_date(const std::string &dateStr);
+
+} // namespace mirai

external/mirai-core/include/mirai-core/event.h

@@ -6,32 +6,32 @@
 
 #pragma once
 
-#include "DataProvider.h"
+#include "data_provider.h"
 #include <string>
 #include <vector>
 
 namespace mirai
 {
 
-class Task;
+class task;
 
-class Event
+class event
 {
 
   public:
-	Event(data_provider *provider, event_data data) : _provider(provider), _data(data) {};
+	event(data_provider *provider, event_data data) : _provider(provider), _data(data) {};
 
 	std::string title() const;
-	Date date() const;
+	class date date() const;
-	Time starts_at() const;
+	time starts_at() const;
-	Time ends_at() const;
+	time ends_at() const;
 
-	std::vector<Task> query_tasks() const;
+	std::vector<task> query_tasks() const;
 
 	void set_title(const std::string &newTitle);
-	void set_date(const Date &date);
+	void set_date(const class date &date);
-	void set_start_time(const Time &time);
+	void set_start_time(const time &time);
-	void set_end_time(const Time &time);
+	void set_end_time(const time &time);
 
 	int id() const;
 	int source_id() const;

external/mirai-core/include/mirai-core/markdown_data_provider.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include "DataProvider.h"
+#include "data_provider.h"
-#include "DateTime.h"
+#include "date.h"
 #include <algorithm>
 #include <fstream>
 #include <iterator>
@@ -46,7 +46,7 @@ class markdown_data_provider final : public data_provider
 	task_data insert_task(const task_data &task) override;
 	void remove_task_by_id(int taskId) override;
 	std::optional<task_data> get_task_by_id(int taskId) override;
-	std::vector<task_data> get_tasks_by_date(Date date) override;
+	std::vector<task_data> get_tasks_by_date(class date date) override;
 	std::vector<task_data> get_tasks_without_date() override;
 	std::vector<task_data> get_tasks() override;
 	void update_task(int taskId, updatable_task_data updateData) override;
@@ -56,7 +56,7 @@ class markdown_data_provider final : public data_provider
 	void remove_event_by_id(int eventId) override;
 	std::optional<event_data> get_event_by_id(int eventId) override;
 	std::vector<event_data> get_events() override;
-	std::vector<event_data> get_events_by_date(Date date) override;
+	std::vector<event_data> get_events_by_date(class date date) override;
 	void update_event(int eventId, updatable_event_data updateData) override;
 
   private:

external/mirai-core/include/mirai-core/source.h

@@ -6,10 +6,10 @@
 
 #pragma once
 
-#include "DataProvider.h"
+#include "data_provider.h"
-#include "DateTime.h"
+#include "date.h"
-#include "Event.h"
+#include "event.h"
-#include "Task.h"
+#include "task.h"
 #include <string>
 #include <vector>
 
@@ -18,14 +18,14 @@ namespace mirai
 
 struct create_task_params {
 	std::string title;
-	std::optional<Date> due_date;
+	std::optional<class date> due_date;
 };
 
 struct create_event_params {
 	std::string title;
-	Date date;
+	class date date;
-	Time starts_at;
+	time starts_at;
-	Time ends_at;
+	time ends_at;
 };
 
 struct source_constructor {
@@ -63,17 +63,17 @@ class source
 	void set_color(const std::string &color);
 
 	void create_task(const create_task_params &task);
-	void remove_task(const Task &task);
+	void remove_task(const task &task);
-	std::optional<Task> get_task_by_id(int taskId);
+	std::optional<task> get_task_by_id(int taskId);
-	std::vector<Task> get_tasks_by_date(Date date);
+	std::vector<task> get_tasks_by_date(class date date);
-	std::vector<Task> get_unscheduled_tasks();
+	std::vector<task> get_unscheduled_tasks();
-	std::vector<Task> get_tasks();
+	std::vector<task> get_tasks();
 
 	void create_event(const create_event_params &eventToCreate);
-	void remove_event(const Event &event);
+	void remove_event(const event &event);
-	std::vector<Event> get_events();
+	std::vector<class event> get_events();
-	std::optional<Event> get_event_by_id(int eventId);
+	std::optional<class event> get_event_by_id(int eventId);
-	std::vector<Event> get_events_by_date(Date date);
+	std::vector<class event> get_events_by_date(class date date);
 
 	const int id = source::generate_next_id();
 

external/mirai-core/include/mirai-core/task.h

@@ -6,9 +6,9 @@
 
 #pragma once
 
-#include "DataProvider.h"
+#include "data_provider.h"
-#include "DateTime.h"
+#include "date.h"
-#include "Event.h"
+#include "event.h"
 #include <optional>
 #include <string>
 
@@ -17,20 +17,20 @@ namespace mirai
 
 class Day;
 
-class Task
+class task
 {
 
   public:
-	Task(data_provider *data, task_data task) : data_(data), task_(task) {};
+	task(data_provider *data, task_data task) : data_(data), task_(task) {};
 
 	std::string title() const;
 	mirai::task_state state() const;
 	bool checked() const;
 	bool has_due_date() const;
-	std::optional<Date> due_date() const;
+	std::optional<class date> due_date() const;
 
 	void set_title(const std::string &newTitle);
-	void set_date(const Date &date);
+	void set_date(const date &date);
 	void set_checked(bool checked);
 	void unschedule();
 

external/mirai-core/include/mirai-core/utils.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include "DataProvider.h"
+#include "data_provider.h"
-#include "DateTime.h"
+#include "date.h"
 #include <cctype>
 #include <cpp-utils/string.h>
 #include <cpp-utils/vector.h>
@@ -20,7 +20,7 @@ namespace mirai
 namespace stringUtils = cpputils::string;
 namespace vectorUtils = cpputils::vector;
 
-bool isDate(const std::string &dateStr);
+bool is_date(const std::string &dateStr);
 
 template <typename T, typename F> T *ptrFindFirst(std::vector<T> &container, F f)
 {

external/mirai-core/src/core.cpp

@@ -4,13 +4,13 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "Mirai.h"
+#include "core.h"
-#include "DataProvider.h"
+#include "data_provider.h"
-#include "MarkdownDataProvider.h"
+#include "markdown_data_provider.h"
-#include "Source.h"
 #include "rei-json/Array.h"
 #include "rei-json/Object.h"
 #include "rei-json/json.h"
+#include "source.h"
 #include <algorithm>
 #include <cassert>
 #include <iostream>
@@ -22,7 +22,7 @@
 namespace mirai
 {
 
-void Mirai::loadConfig(const std::string &path)
+void core::loadConfig(const std::string &path)
 {
 	std::ifstream file(path);
 	if (!file) {
@@ -54,7 +54,7 @@ void Mirai::loadConfig(const std::string &path)
 	}
 }
 
-void Mirai::saveConfig()
+void core::saveConfig()
 {
 	std::ofstream file(configPath_);
 	if (!file.is_open()) {
@@ -78,12 +78,12 @@ void Mirai::saveConfig()
 	file.close();
 }
 
-Mirai::Mirai(const std::string &configFilePath) : configPath_(configFilePath)
+core::core(const std::string &configFilePath) : configPath_(configFilePath)
 {
 	loadConfig(configFilePath);
 }
 
-void Mirai::addSource(
+void core::addSource(
 	const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&new_source
 )
 {
@@ -98,7 +98,7 @@ void Mirai::addSource(
 	sourceAdded.emit(nullptr);
 };
 
-void Mirai::editSource(
+void core::editSource(
 	int id, const std::string &name, const std::string &color, const std::string &path
 )
 {
@@ -111,7 +111,7 @@ void Mirai::editSource(
 	sourceEdited.emit(nullptr);
 }
 
-void Mirai::deleteSource(int id)
+void core::deleteSource(int id)
 {
 	sources_.erase(
 		std::remove_if(
@@ -125,12 +125,12 @@ void Mirai::deleteSource(int id)
 	sourceDeleted.emit(id);
 }
 
-void Mirai::unloadAllSources()
+void core::unloadAllSources()
 {
 	sources_.clear();
 }
 
-void Mirai::save()
+void core::save()
 {
 	for (auto &source : sources_) {
 		if (source->is_dirty()) {
@@ -139,12 +139,12 @@ void Mirai::save()
 	}
 }
 
-std::vector<std::unique_ptr<source>> &Mirai::getSources()
+std::vector<std::unique_ptr<source>> &core::getSources()
 {
 	return sources_;
 }
 
-source *Mirai::getSourceById(int id)
+source *core::getSourceById(int id)
 {
 	auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
 		return source->id == id;
@@ -156,7 +156,7 @@ source *Mirai::getSourceById(int id)
 	return source_found->get();
 }
 
-source *Mirai::getSourceByName(const std::string &name)
+source *core::getSourceByName(const std::string &name)
 {
 	auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
 		return source->name() == name;
@@ -168,17 +168,17 @@ source *Mirai::getSourceByName(const std::string &name)
 	return source_found->get();
 }
 
-void Mirai::onSourceAdded(std::function<void(source *)> f)
+void core::onSourceAdded(std::function<void(source *)> f)
 {
 	sourceAdded.registerCallback(f);
 }
 
-void Mirai::onSourceEdited(std::function<void(source *)> f)
+void core::onSourceEdited(std::function<void(source *)> f)
 {
 	sourceEdited.registerCallback(f);
 }
 
-void Mirai::onSourceDeleted(std::function<void(int)> f)
+void core::onSourceDeleted(std::function<void(int)> f)
 {
 	sourceDeleted.registerCallback(f);
 }

external/mirai-core/src/date.cpp

@@ -4,7 +4,7 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "DateTime.h"
+#include "date.h"
 #include <charconv>
 #include <chrono>
 #include <optional>
@@ -15,7 +15,7 @@
 namespace mirai
 {
 
-std::optional<mirai::Date> stringToDate(const std::string &dateStr)
+std::optional<class date> string_to_date(const std::string &dateStr)
 {
 	using std::operator""sv;
 
@@ -33,14 +33,14 @@ std::optional<mirai::Date> stringToDate(const std::string &dateStr)
 	auto year = dateSplit[0];
 	auto month = dateSplit[1];
 	auto day = dateSplit[2];
-	return mirai::Date(year, static_cast<unsigned>(month), static_cast<unsigned>(day));
+	return mirai::date(year, static_cast<unsigned>(month), static_cast<unsigned>(day));
 }
 
-Date::Date(int year, unsigned month, unsigned day) : year(year), month(month), day(day)
+date::date(int year, unsigned month, unsigned day) : year(year), month(month), day(day)
 {
 }
 
-Date::Date(std::chrono::time_point<std::chrono::system_clock> tp)
+date::date(std::chrono::time_point<std::chrono::system_clock> tp)
 {
 	auto chronoDate = std::chrono::year_month_day(std::chrono::floor<std::chrono::days>(tp));
 	year = static_cast<int>(chronoDate.year());
@@ -48,19 +48,19 @@ Date::Date(std::chrono::time_point<std::chrono::system_clock> tp)
 	day = static_cast<unsigned>(chronoDate.day());
 }
 
-Date::Date(std::chrono::year_month_day chronoDate)
+date::date(std::chrono::year_month_day chronoDate)
 {
 	year = static_cast<int>(chronoDate.year());
 	month = static_cast<unsigned>(chronoDate.month());
 	day = static_cast<unsigned>(chronoDate.day());
 }
 
-bool Date::operator==(const Date &other) const
+bool date::operator==(const date &other) const
 {
 	return other.year == year && other.month == month && other.day == day;
 }
 
-bool Date::operator<(const Date &other) const
+bool date::operator<(const date &other) const
 {
 	if (year < other.year) {
 		return true;
@@ -74,42 +74,42 @@ bool Date::operator<(const Date &other) const
 	return false;
 }
 
-bool Date::operator>(const Date &other) const
+bool date::operator>(const date &other) const
 {
 	return !(*this < other) && !(*this == other);
 }
 
-bool Date::operator>=(const Date &other) const
+bool date::operator>=(const date &other) const
 {
 	return (*this > other) || (*this == other);
 }
 
-bool Date::operator<=(const Date &other) const
+bool date::operator<=(const date &other) const
 {
 	return (*this < other) || (*this == other);
 }
 
-Time::Time(int hour, int minute) : hour(hour), minute(minute)
+time::time(int hour, int minute) : hour(hour), minute(minute)
 {
 }
 
-Time::Time(std::chrono::time_point<std::chrono::system_clock> tp)
+time::time(std::chrono::time_point<std::chrono::system_clock> tp)
 {
 	auto localTp = std::chrono::zoned_time{std::chrono::current_zone(), tp}.get_local_time();
 	auto chronoDate = std::chrono::floor<std::chrono::days>(localTp);
-	auto chronoTime =
+	auto chronoTime = std::chrono::hh_mm_ss{
-		std::chrono::hh_mm_ss{std::chrono::duration_cast<std::chrono::minutes>(localTp - chronoDate)
+		std::chrono::duration_cast<std::chrono::minutes>(localTp - chronoDate)
-		};
+	};
 	hour = static_cast<int>(chronoTime.hours().count());
 	minute = static_cast<int>(chronoTime.minutes().count());
 }
 
-bool Time::operator==(const Time &other) const
+bool time::operator==(const time &other) const
 {
 	return other.hour == hour && other.minute == minute;
 }
 
-bool Time::operator<(const Time &other) const
+bool time::operator<(const time &other) const
 {
 	if (hour < other.hour) {
 		return true;
@@ -120,7 +120,7 @@ bool Time::operator<(const Time &other) const
 	return false;
 }
 
-bool Time::operator>(const Time &other) const
+bool time::operator>(const time &other) const
 {
 	return !(*this < other) && !(*this == other);
 }

external/mirai-core/src/event.cpp

@@ -4,59 +4,59 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "Event.h"
+#include "event.h"
-#include "Task.h"
+#include "task.h"
 #include <string>
 
 namespace mirai
 {
 
-int Event::id() const
+int event::id() const
 {
 	return _data.id;
 }
 
-int Event::source_id() const
+int event::source_id() const
 {
 	return _provider->id;
 }
 
-std::string Event::title() const
+std::string event::title() const
 {
 	return _data.title;
 }
 
-Date Event::date() const
+date event::date() const
 {
 	return _data.date;
 }
 
-Time Event::starts_at() const
+time event::starts_at() const
 {
 	return _data.starts_at;
 }
 
-Time Event::ends_at() const
+time event::ends_at() const
 {
 	return _data.ends_at;
 }
 
-void Event::set_title(const std::string &newTitle)
+void event::set_title(const std::string &newTitle)
 {
 	_provider->update_event(id(), {.title = newTitle});
 }
 
-void Event::set_date(const Date &date)
+void event::set_date(const class date &date)
 {
 	_provider->update_event(id(), {.date = date});
 }
 
-void Event::set_start_time(const Time &time)
+void event::set_start_time(const time &time)
 {
 	_provider->update_event(id(), {.starts_at = time});
 }
 
-void Event::set_end_time(const Time &time)
+void event::set_end_time(const time &time)
 {
 	_provider->update_event(id(), {.ends_at = time});
 }

external/mirai-core/src/markdown_data_provider.cpp

@@ -4,9 +4,9 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "MarkdownDataProvider.h"
+#include "markdown_data_provider.h"
-#include "DataProvider.h"
 #include "cpp-utils/debug.h"
+#include "data_provider.h"
 #include "utils.h"
 #include <algorithm>
 #include <cassert>
@@ -92,7 +92,7 @@ std::vector<task_data> markdown_data_provider::get_tasks_without_date()
 	return findAll(_data.tasks, [](const task_data &t) { return t.due_date == std::nullopt; });
 }
 
-std::vector<task_data> markdown_data_provider::get_tasks_by_date(Date date)
+std::vector<task_data> markdown_data_provider::get_tasks_by_date(class date date)
 {
 	return findAll(_data.tasks, [&](const task_data &t) { return t.due_date == date; });
 }
@@ -158,7 +158,7 @@ std::optional<event_data> markdown_data_provider::get_event_by_id(int eventId)
 	return findFirst(_data.events, [&](const event_data &event) { return event.id == eventId; });
 }
 
-std::vector<event_data> markdown_data_provider::get_events_by_date(Date date)
+std::vector<event_data> markdown_data_provider::get_events_by_date(class date date)
 {
 	return findAll(_data.events, [&](const event_data &event) { return event.date == date; });
 }

external/mirai-core/src/markdown_data_provider.parser.cpp

@@ -4,9 +4,9 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "MarkdownDataProvider.h"
+#include "markdown_data_provider.h"
-#include "DataProvider.h"
 #include "cpp-utils/debug.h"
+#include "data_provider.h"
 #include "utils.h"
 #include <optional>
 #include <print>
@@ -56,7 +56,7 @@ task_data stringToTask(const std::string &str, const std::string &date)
 	return taskItem;
 }
 
-Time stringToTime(const std::string &str)
+time stringToTime(const std::string &str)
 {
 	if (str.length() != 5) {
 		throw std::runtime_error("Str time length must be 5 (got '" + str + "')");
@@ -67,7 +67,7 @@ Time stringToTime(const std::string &str)
 	int hour, minute;
 	std::from_chars(str.data(), str.data() + 2, hour);
 	std::from_chars(str.data() + 3, str.data() + 5, minute);
-	Time time{hour, minute};
+	time time{hour, minute};
 
 	return time;
 }
@@ -80,7 +80,7 @@ event_data stringToEvent(const std::string &str, const std::string &dateString)
 
 	std::string text = stringUtils::trim(matches[4]);
 
-	auto date = stringToDate(dateString);
+	auto date = string_to_date(dateString);
 
 	if (!date.has_value()) {
 		throw std::runtime_error("Malformated date");
@@ -124,7 +124,7 @@ std::string markdown_data_provider::to_markdown()
 	});
 
 	while (next_event_index < _data.events.size() || next_task_index < _data.tasks.size()) {
-		std::optional<Date> current_date = std::nullopt;
+		std::optional<class date> current_date = std::nullopt;
 		// First we find the lowest date between the events and the tasks
 		if (_data.events.size() > 0 && next_event_index < _data.events.size()) {
 			current_date = _data.events.at(next_event_index).date;
@@ -199,7 +199,7 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
 	_data.name = line.substr(2);
 	std::string currentDateString = "";
 
-	std::optional<Date> current_date = std::nullopt;
+	std::optional<class date> current_date = std::nullopt;
 
 	cpputils::debug::Timer stringToTaskDuration;
 	stringToTaskDuration.reset();
@@ -211,7 +211,7 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
 				current_date = std::nullopt;
 				continue;
 			}
-			current_date = mirai::stringToDate(currentDateString);
+			current_date = mirai::string_to_date(currentDateString);
 			if (!current_date.has_value()) {
 				throw std::runtime_error("Malformated date (1)");
 			}

external/mirai-core/src/source.cpp

@@ -4,8 +4,8 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "Source.h"
+#include "source.h"
-#include "DataProvider.h"
+#include "data_provider.h"
 #include "utils.h"
 #include <algorithm>
 #include <iterator>
@@ -42,64 +42,64 @@ void source::create_event(const create_event_params &new_event)
 	});
 };
 
-std::vector<Event> source::get_events()
+std::vector<class event> source::get_events()
 {
 	auto event_data = data->get_events();
-	std::vector<Event> events;
+	std::vector<class event> events;
 	std::transform(
 		event_data.begin(), event_data.end(), std::back_inserter(events),
-		[&](const struct event_data &event_data) { return Event{data, event_data}; }
+		[&](const struct event_data &event_data) { return event{data, event_data}; }
 	);
 	return events;
 }
 
-std::optional<Event> source::get_event_by_id(int evendId)
+std::optional<class event> source::get_event_by_id(int evendId)
 {
-	auto event = data->get_event_by_id(evendId);
+	auto event_data = data->get_event_by_id(evendId);
-	if (!event.has_value()) {
+	if (!event_data.has_value()) {
 		return std::nullopt;
 	}
-	return Event{data, event.value()};
+	return event{data, event_data.value()};
 }
 
-void source::remove_event(const Event &event)
+void source::remove_event(const event &event)
 {
 	data->remove_event_by_id(event.id());
 }
 
-void source::remove_task(const Task &task)
+void source::remove_task(const task &task)
 {
 	data->remove_task_by_id(task.id());
 }
 
-std::optional<Task> source::get_task_by_id(int taskId)
+std::optional<task> source::get_task_by_id(int taskId)
 {
 	auto taskData = data->get_task_by_id(taskId);
 	if (!taskData.has_value()) {
 		return std::nullopt;
 	}
-	Task task{data, taskData.value()};
+	task task{data, taskData.value()};
 	return task;
 }
 
-std::vector<Task> source::get_tasks()
+std::vector<task> source::get_tasks()
 {
 	auto tasksData = data->get_tasks();
-	std::vector<Task> tasks;
+	std::vector<task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const task_data &taskData) { return Task{data, taskData}; }
+		[&](const task_data &taskData) { return task{data, taskData}; }
 	);
 	return tasks;
 }
 
-std::vector<Task> source::get_unscheduled_tasks()
+std::vector<task> source::get_unscheduled_tasks()
 {
 	auto tasksData = data->get_tasks_without_date();
-	std::vector<Task> tasks;
+	std::vector<task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const task_data &taskData) { return Task{data, taskData}; }
+		[&](const task_data &taskData) { return task{data, taskData}; }
 	);
 	return tasks;
 }

external/mirai-core/src/task.cpp

@@ -4,8 +4,8 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "Task.h"
+#include "task.h"
-#include "DataProvider.h"
+#include "data_provider.h"
 #include "utils.h"
 #include <optional>
 #include <string>
@@ -13,37 +13,37 @@
 namespace mirai
 {
 
-int Task::id() const
+int task::id() const
 {
 	return task_.id;
 }
 
-int Task::source_id() const
+int task::source_id() const
 {
 	return data_->id;
 }
 
-std::string Task::title() const
+std::string task::title() const
 {
 	return task_.title;
 }
 
-mirai::task_state Task::state() const
+mirai::task_state task::state() const
 {
 	return task_.state;
 }
 
-bool Task::checked() const
+bool task::checked() const
 {
 	return task_.state == mirai::DONE;
 }
 
-bool Task::has_due_date() const
+bool task::has_due_date() const
 {
 	return task_.due_date.has_value();
 }
 
-std::optional<Date> Task::due_date() const
+std::optional<class date> task::due_date() const
 {
 	if (!task_.due_date.has_value()) {
 		return std::nullopt;
@@ -51,24 +51,24 @@ std::optional<Date> Task::due_date() const
 	return task_.due_date.value();
 }
 
-void Task::set_title(const std::string &newTitle)
+void task::set_title(const std::string &newTitle)
 {
 	data_->update_task(id(), {.title = newTitle});
 }
 
-void Task::set_date(const Date &date)
+void task::set_date(const date &date)
 {
 	auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
 	data_->update_task(id(), {.due_date = date});
 }
 
-void Task::unschedule()
+void task::unschedule()
 {
 	auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
 	data_->update_task(id(), {.due_date = std::nullopt});
 }
 
-void Task::set_checked(bool checked)
+void task::set_checked(bool checked)
 {
 	data_->update_task(id(), {.state = checked ? DONE : TODO});
 }

external/mirai-core/src/utils.cpp

@@ -12,7 +12,7 @@
 namespace mirai
 {
 
-bool isDate(const std::string &dateStr)
+bool is_date(const std::string &dateStr)
 {
 	// std regex are really slow
 	/*std::regex regex("[0-9]{4}-[0-9]{2}-[0-9]{2}");*/

src/main.cpp

@@ -5,7 +5,7 @@
  */
 
 #include "evalyte-cpp-common/evalyte.h"
-#include "mirai-core/Mirai.h"
+#include "mirai-core/core.h"
 #include "ui.h"
 #include "windows/AppWindow/AppWindow.h"
 #include <cstdlib>
@@ -15,7 +15,7 @@ int main(int argc, char **argv)
 {
 	evalyte::createRequiredDirectories("mirai");
 	const auto configFilePath = evalyte::configDirectoryPath("mirai") + "/config.json";
-	mirai::Mirai mirai{configFilePath};
+	mirai::core mirai{configFilePath};
 	AppWindow appWindow{&mirai};
 	appWindow.run();
 	return 0;

src/shared/Utils.cpp

@@ -21,10 +21,10 @@ void bindSlintUtils(const ui::Utils &utils)
 		return std::format("{:%B %d}", chronoDate);
 	});
 
-	auto currentDate = MiraiDateToSlintDate(mirai::Date(std::chrono::system_clock::now()));
+	auto currentDate = MiraiDateToSlintDate(mirai::date(std::chrono::system_clock::now()));
 	utils.set_current_date(currentDate);
 
-	auto currentTime = MiraiTimeToSlintTime(mirai::Time(std::chrono::system_clock::now()));
+	auto currentTime = MiraiTimeToSlintTime(mirai::time(std::chrono::system_clock::now()));
 	utils.set_current_time(currentTime);
 }
 
@@ -38,10 +38,10 @@ std::string formatZeroPadding(const int number)
 
 std::string formatDateRelative(const ui::Date &date)
 {
-	auto todayDate = mirai::Date(std::chrono::system_clock::now());
+	auto todayDate = mirai::date(std::chrono::system_clock::now());
 	auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
-								std::chrono::sys_days(SlintDateToMiraiDate(date).toStdChrono()) -
+								std::chrono::sys_days(SlintDateToMiraiDate(date).to_std_chrono())
-								std::chrono::sys_days(todayDate.toStdChrono())
+								- std::chrono::sys_days(todayDate.to_std_chrono())
 	)
 								.count();
 
@@ -61,18 +61,18 @@ std::string capitalize(std::string str)
 
 std::string SlintDateToStdString(const ui::Date &date)
 {
-	return std::to_string(date.year) + "-" + formatZeroPadding(date.month) + "-" +
+	return std::to_string(date.year) + "-" + formatZeroPadding(date.month) + "-"
-		   formatZeroPadding(date.day);
+		 + formatZeroPadding(date.day);
 }
 
-mirai::Date SlintDateToMiraiDate(const ui::Date &date)
+mirai::date SlintDateToMiraiDate(const ui::Date &date)
 {
-	return mirai::Date(
+	return mirai::date(
 		date.year, static_cast<unsigned>(date.month), static_cast<unsigned>(date.day)
 	);
 }
 
-ui::Date MiraiDateToSlintDate(const mirai::Date &date)
+ui::Date MiraiDateToSlintDate(const mirai::date &date)
 {
 	return {
 		.year = date.year,
@@ -81,12 +81,12 @@ ui::Date MiraiDateToSlintDate(const mirai::Date &date)
 	};
 }
 
-ui::Time MiraiTimeToSlintTime(const mirai::Time &time)
+ui::Time MiraiTimeToSlintTime(const mirai::time &time)
 {
 	return {.hour = time.hour, .minute = time.minute, .second = 0};
 }
 
-mirai::Time SlintTimeToMiraiTime(const ui::Time &time)
+mirai::time SlintTimeToMiraiTime(const ui::Time &time)
 {
-	return mirai::Time{time.hour, time.minute};
+	return mirai::time{time.hour, time.minute};
 }

src/shared/Utils.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "mirai-core/DateTime.h"
+#include "mirai-core/date.h"
 #include "ui.h"
 #include <string>
 
@@ -16,7 +16,7 @@ std::string formatZeroPadding(const int number);
 std::string formatDateRelative(const ui::Date &date);
 std::string capitalize(std::string str);
 std::string SlintDateToStdString(const ui::Date &date);
-mirai::Date SlintDateToMiraiDate(const ui::Date &date);
+mirai::date SlintDateToMiraiDate(const ui::Date &date);
-ui::Date MiraiDateToSlintDate(const mirai::Date &date);
+ui::Date MiraiDateToSlintDate(const mirai::date &date);
-ui::Time MiraiTimeToSlintTime(const mirai::Time &time);
+ui::Time MiraiTimeToSlintTime(const mirai::time &time);
-mirai::Time SlintTimeToMiraiTime(const ui::Time &time);
+mirai::time SlintTimeToMiraiTime(const ui::Time &time);

src/view.h

@@ -1,24 +0,0 @@
-#include "DataProvider.h"
-#include "DateTime.h"
-#include <vector>
-
-struct source_group {
-	int source_id;
-	std::vector<mirai::event_data> events;
-	std::vector<mirai::task_data> tasks;
-};
-
-struct day_group {
-	mirai::Date date;
-	source_group sources;
-};
-
-std::vector<day_group>
-group_by_day(std::vector<mirai::event_data> events, std::vector<mirai::task_data> tasks)
-{
-	std::vector<day_group> days;
-
-	// todo
-
-	return days;
-}

src/windows/AppWindow/AppWindow.cpp

@@ -7,11 +7,11 @@
 #include "AppWindow.h"
 #include "../../SeleniteSetup.h"
 #include "../../shared/Utils.h"
-#include "mirai-core/DateTime.h"
+#include "mirai-core/core.h"
-#include "mirai-core/Event.h"
+#include "mirai-core/date.h"
-#include "mirai-core/MarkdownDataProvider.h"
+#include "mirai-core/event.h"
-#include "mirai-core/Mirai.h"
+#include "mirai-core/markdown_data_provider.h"
-#include "mirai-core/Source.h"
+#include "mirai-core/source.h"
 #include "selenite/palette.h"
 #include "slint_color.h"
 #include "slint_models.h"
@@ -32,7 +32,7 @@
 #include <string_view>
 #include <vector>
 
-AppWindow::AppWindow(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance)
+AppWindow::AppWindow(mirai::core *miraiInstance) : miraiInstance_(miraiInstance)
 {
 	_sidebar_view = ui::SidebarView();
 	_calendar_view = ui::CalendarView();
@@ -193,7 +193,7 @@ void AppWindow::setupCallbacks()
 		assert(source);
 		auto task = source->get_task_by_id(newTaskData.id);
 		assert(task.has_value());
-		const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
+		const mirai::date &date = SlintDateToMiraiDate(newTaskData.date);
 		// const auto dayOpt = source->get_day_by_date(date);
 		task->set_title(std::string(newTaskData.title));
 
@@ -204,13 +204,13 @@ void AppWindow::setupCallbacks()
 	});
 
 	actions().on_create_task([&](ui::NewTaskData newTaskData) {
-		std::optional<mirai::Date> date = std::nullopt;
+		std::optional<mirai::date> date = std::nullopt;
 		if (newTaskData.date.year != 0) {
 			date = SlintDateToMiraiDate(newTaskData.date);
 		}
 		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
 
-		std::optional<mirai::Event> event = std::nullopt;
+		std::optional<mirai::event> event = std::nullopt;
 		if (newTaskData.eventId >= 0) {
 			event = source->get_event_by_id(newTaskData.eventId);
 		}
@@ -472,10 +472,10 @@ void AppWindow::update_sidebar_view()
 	models().set_sidebar_view(_sidebar_view);
 }
 
-std::vector<mirai::Event>
+std::vector<mirai::event>
 merge_all_events_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
 {
-	std::vector<mirai::Event> all_events;
+	std::vector<mirai::event> all_events;
 	for (auto &source : sources) {
 		const auto &events = source->get_events();
 		all_events.insert(all_events.end(), events.begin(), events.end());
@@ -483,10 +483,10 @@ merge_all_events_from_sources(std::vector<std::unique_ptr<mirai::source>> &sourc
 	return all_events;
 }
 
-std::vector<mirai::Event>
+std::vector<mirai::event>
-get_events_for_date(const std::vector<mirai::Event> &events, const mirai::Date &date)
+get_events_for_date(const std::vector<mirai::event> &events, const mirai::date &date)
 {
-	auto filtered_events = events | std::ranges::views::filter([&](const mirai::Event &event) {
+	auto filtered_events = events | std::ranges::views::filter([&](const mirai::event &event) {
 							   return event.date() == date;
 						   });
 	return std::ranges::to<std::vector>(filtered_events);
@@ -494,7 +494,7 @@ get_events_for_date(const std::vector<mirai::Event> &events, const mirai::Date &
 
 void AppWindow::update_calendar_view()
 {
-	auto today = mirai::Date(std::chrono::system_clock::now());
+	auto today = mirai::date(std::chrono::system_clock::now());
 	auto new_slint_dates = std::make_shared<slint::VectorModel<ui::CalendarViewDate>>();
 
 	auto &sources = miraiInstance_->getSources();
@@ -504,11 +504,11 @@ void AppWindow::update_calendar_view()
 		std::chrono::year_month_day next_date =
 			std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())
 			+ std::chrono::days{day_index};
-		auto current_date = mirai::Date{next_date};
+		auto current_date = mirai::date{next_date};
 		auto new_slint_events = std::make_shared<slint::VectorModel<ui::CalendarViewEvent>>();
 		auto relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
-									  std::chrono::sys_days(current_date.toStdChrono())
+									  std::chrono::sys_days(current_date.to_std_chrono())
-									  - std::chrono::sys_days(today.toStdChrono())
+									  - std::chrono::sys_days(today.to_std_chrono())
 		)
 									  .count();
 		if (relative_days_diff < 0 || relative_days_diff >= 7) {
@@ -546,15 +546,15 @@ void AppWindow::update_calendar_view()
 	models().set_calendar_view(_calendar_view);
 }
 
-std::vector<mirai::Task>
+std::vector<mirai::task>
 get_all_tasks_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
 {
-	std::vector<mirai::Task> all_tasks;
+	std::vector<mirai::task> all_tasks;
 	for (auto &source : sources) {
 		const auto &tasks = source->get_tasks();
 		all_tasks.insert(all_tasks.end(), tasks.begin(), tasks.end());
 	}
-	std::sort(all_tasks.begin(), all_tasks.end(), [](const mirai::Task &t1, const mirai::Task &t2) {
+	std::sort(all_tasks.begin(), all_tasks.end(), [](const mirai::task &t1, const mirai::task &t2) {
 		if (!t1.has_due_date() && !t2.has_due_date()) {
 			return false;
 		}
@@ -571,15 +571,15 @@ get_all_tasks_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
 
 struct tasks_source_group {
 	int id;
-	std::vector<mirai::Task> tasks;
+	std::vector<mirai::task> tasks;
 };
 
 struct tasks_date_group {
-	std::optional<mirai::Date> date;
+	std::optional<mirai::date> date;
 	std::vector<tasks_source_group> sources;
 };
 
-std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::Task> &tasks)
+std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::task> &tasks)
 {
 	if (tasks.size() == 0) {
 		return {};
@@ -588,7 +588,7 @@ std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::Task>
 	std::vector<tasks_date_group> dates_group;
 	int next_task_index = 0;
 
-	mirai::Task current_task = tasks.at(next_task_index);
+	mirai::task current_task = tasks.at(next_task_index);
 
 	while (next_task_index < tasks.size()) {
 		tasks_date_group date_group{.date = current_task.due_date()};
@@ -615,7 +615,7 @@ std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::Task>
 
 void AppWindow::update_tasks_view()
 {
-	auto today = mirai::Date(std::chrono::system_clock::now());
+	auto today = mirai::date(std::chrono::system_clock::now());
 	auto new_slint_dates = std::make_shared<slint::VectorModel<ui::TasksViewDate>>();
 
 	auto &sources = miraiInstance_->getSources();
@@ -627,8 +627,8 @@ void AppWindow::update_tasks_view()
 		std::optional<int> relative_days_diff = std::nullopt;
 		if (current_date.has_value()) {
 			relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
-									 std::chrono::sys_days(current_date.value().toStdChrono())
+									 std::chrono::sys_days(current_date.value().to_std_chrono())
-									 - std::chrono::sys_days(today.toStdChrono())
+									 - std::chrono::sys_days(today.to_std_chrono())
 			)
 									 .count();
 		}

src/windows/AppWindow/AppWindow.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include "mirai-core/Mirai.h"
+#include "mirai-core/core.h"
-#include "mirai-core/Source.h"
+#include "mirai-core/source.h"
 #include "slint.h"
 #include "ui.h"
 #include <unordered_map>
@@ -17,7 +17,7 @@ class AppWindow
 {
 
   public:
-	AppWindow(mirai::Mirai *mirai);
+	AppWindow(mirai::core *mirai);
 
 	void run();
 
@@ -52,7 +52,7 @@ class AppWindow
 
 	slint::ComponentHandle<ui::AppWindow> mainWindow_ = ui::AppWindow::create();
 
-	mirai::Mirai *miraiInstance_;
+	mirai::core *miraiInstance_;
 
 	std::unordered_map<int, bool> _source_filters;
 	bool _should_hide_completed_tasks;

tests/format.cpp

@@ -4,7 +4,7 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "core/Mirai.h"
+#include "core/core.h"
 #include "core/TaskItem.h"
 #include "core/TodoMd.h"
 #include <catch2/catch_test_macros.hpp>

tests/saving.cpp

@@ -4,9 +4,9 @@
  * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
  */
 
-#include "core/BaseFileSource.h"
+#include "core/BaseFilesource.h"
-#include "core/Mirai.h"
+#include "core/core.h"
-#include "core/StdFileSource.h"
+#include "core/StdFilesource.h"
 #include "core/TaskItem.h"
 #include "core/TodoMd.h"
 #include <catch2/catch_test_macros.hpp>