vyn/mirai
1
Fork 0
mirror of https://codeberg.org/vyn/mirai.git synced 2025-07-03 18:23:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Convert classes and files to snake_case

Browse source
This commit is contained in:
Vyn 2025-07-01 21:42:59 +02:00
parent 686d86df6f
commit 6fa94b279c
Signed by: vyn
GPG key ID: E1B2BE34E7A971E7
26 changed files with 272 additions and 301 deletions
Download patch file Download diff file Expand all files Collapse all files

14
external/mirai-core/CMakeLists.txt vendored
View file

@ -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/Task.cpp
src/Event.cpp
src/DateTime.cpp
src/core.cpp
src/task.cpp
src/event.cpp
src/date.cpp
src/EventEmitter.cpp
src/Source.cpp
src/MarkdownDataProvider.cpp
src/MarkdownDataProvider.Parser.cpp
src/source.cpp
src/markdown_data_provider.cpp
src/markdown_data_provider.parser.cpp
src/utils.cpp
)

64
external/mirai-core/include/mirai-core/DateTime.h vendored
View file

@ -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

6
external/mirai-core/include/mirai-core/Mirai.h → external/mirai-core/include/mirai-core/core.h vendored
View file

@ -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
);

22
external/mirai-core/include/mirai-core/DataProvider.h → external/mirai-core/include/mirai-core/data_provider.h vendored
View file

@ -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 ends_at;
time starts_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> ends_at;
std::optional<time> starts_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();

59
external/mirai-core/include/mirai-core/date.h vendored Normal file
View file

@ -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

22
external/mirai-core/include/mirai-core/Event.h → external/mirai-core/include/mirai-core/event.h vendored
View file

@ -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;
Time starts_at() const;
Time ends_at() const;
class date date() const;
time starts_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_start_time(const Time &time);
void set_end_time(const Time &time);
void set_date(const class date &date);
void set_start_time(const time &time);
void set_end_time(const time &time);
int id() const;
int source_id() const;

8
external/mirai-core/include/mirai-core/MarkdownDataProvider.h → external/mirai-core/include/mirai-core/markdown_data_provider.h vendored
View file

@ -6,8 +6,8 @@
#pragma once
#include "DataProvider.h"
#include "DateTime.h"
#include "data_provider.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:

34
external/mirai-core/include/mirai-core/Source.h → external/mirai-core/include/mirai-core/source.h vendored
View file

@ -6,10 +6,10 @@
#pragma once
#include "DataProvider.h"
#include "DateTime.h"
#include "Event.h"
#include "Task.h"
#include "data_provider.h"
#include "date.h"
#include "event.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;
Time starts_at;
Time ends_at;
class date date;
time starts_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);
std::optional<Task> get_task_by_id(int taskId);
std::vector<Task> get_tasks_by_date(Date date);
std::vector<Task> get_unscheduled_tasks();
std::vector<Task> get_tasks();
void remove_task(const task &task);
std::optional<task> get_task_by_id(int taskId);
std::vector<task> get_tasks_by_date(class date date);
std::vector<task> get_unscheduled_tasks();
std::vector<task> get_tasks();
void create_event(const create_event_params &eventToCreate);
void remove_event(const Event &event);
std::vector<Event> get_events();
std::optional<Event> get_event_by_id(int eventId);
std::vector<Event> get_events_by_date(Date date);
void remove_event(const event &event);
std::vector<class event> get_events();
std::optional<class event> get_event_by_id(int eventId);
std::vector<class event> get_events_by_date(class date date);
const int id = source::generate_next_id();

14
external/mirai-core/include/mirai-core/Task.h → external/mirai-core/include/mirai-core/task.h vendored
View file

@ -6,9 +6,9 @@
#pragma once
#include "DataProvider.h"
#include "DateTime.h"
#include "Event.h"
#include "data_provider.h"
#include "date.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();

6
external/mirai-core/include/mirai-core/utils.h vendored
View file

@ -6,8 +6,8 @@
#pragma once
#include "DataProvider.h"
#include "DateTime.h"
#include "data_provider.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)
{

36
external/mirai-core/src/Mirai.cpp → external/mirai-core/src/core.cpp vendored
View file

@ -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 "DataProvider.h"
#include "MarkdownDataProvider.h"
#include "Source.h"
#include "core.h"
#include "data_provider.h"
#include "markdown_data_provider.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);
}

38
external/mirai-core/src/DateTime.cpp → external/mirai-core/src/date.cpp vendored
View file

@ -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 =
std::chrono::hh_mm_ss{std::chrono::duration_cast<std::chrono::minutes>(localTp - chronoDate)
};
auto chronoTime = std::chrono::hh_mm_ss{
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);
}

24
external/mirai-core/src/Event.cpp → external/mirai-core/src/event.cpp vendored
View file

@ -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 "Task.h"
#include "event.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});
}

8
external/mirai-core/src/MarkdownDataProvider.cpp → external/mirai-core/src/markdown_data_provider.cpp vendored
View file

@ -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 "DataProvider.h"
#include "markdown_data_provider.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; });
}

16
external/mirai-core/src/MarkdownDataProvider.Parser.cpp → external/mirai-core/src/markdown_data_provider.parser.cpp vendored
View file

@ -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 "DataProvider.h"
#include "markdown_data_provider.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)");
}

38
external/mirai-core/src/Source.cpp → external/mirai-core/src/source.cpp vendored
View file

@ -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 "DataProvider.h"
#include "source.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);
if (!event.has_value()) {
auto event_data = data->get_event_by_id(evendId);
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;
}

26
external/mirai-core/src/Task.cpp → external/mirai-core/src/task.cpp vendored
View file

@ -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 "DataProvider.h"
#include "task.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});
}

2
external/mirai-core/src/utils.cpp vendored
View file

@ -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}");*/

4
src/main.cpp
View file

@ -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;

26
src/shared/Utils.cpp
View file

@ -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(todayDate.toStdChrono())
std::chrono::sys_days(SlintDateToMiraiDate(date).to_std_chrono())
- 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) + "-" +
formatZeroPadding(date.day);
return std::to_string(date.year) + "-" + formatZeroPadding(date.month) + "-"
+ 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};
}

10
src/shared/Utils.h
View file

@ -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);
ui::Date MiraiDateToSlintDate(const mirai::Date &date);
ui::Time MiraiTimeToSlintTime(const mirai::Time &time);
mirai::Time SlintTimeToMiraiTime(const ui::Time &time);
mirai::date SlintDateToMiraiDate(const ui::Date &date);
ui::Date MiraiDateToSlintDate(const mirai::date &date);
ui::Time MiraiTimeToSlintTime(const mirai::time &time);
mirai::time SlintTimeToMiraiTime(const ui::Time &time);

24
src/view.h
View file

@ -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;
}

56
src/windows/AppWindow/AppWindow.cpp
View file

@ -7,11 +7,11 @@
#include "AppWindow.h"
#include "../../SeleniteSetup.h"
#include "../../shared/Utils.h"
#include "mirai-core/DateTime.h"
#include "mirai-core/Event.h"
#include "mirai-core/MarkdownDataProvider.h"
#include "mirai-core/Mirai.h"
#include "mirai-core/Source.h"
#include "mirai-core/core.h"
#include "mirai-core/date.h"
#include "mirai-core/event.h"
#include "mirai-core/markdown_data_provider.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>
get_events_for_date(const std::vector<mirai::Event> &events, const mirai::Date &date)
std::vector<mirai::event>
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(today.toStdChrono())
std::chrono::sys_days(current_date.to_std_chrono())
- 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(today.toStdChrono())
std::chrono::sys_days(current_date.value().to_std_chrono())
- std::chrono::sys_days(today.to_std_chrono())
)
.count();
}

8
src/windows/AppWindow/AppWindow.h
View file

@ -6,8 +6,8 @@
#pragma once
#include "mirai-core/Mirai.h"
#include "mirai-core/Source.h"
#include "mirai-core/core.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;

2
tests/format.cpp
View file

@ -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>

6
tests/saving.cpp
View file

@ -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/Mirai.h"
#include "core/StdFileSource.h"
#include "core/BaseFilesource.h"
#include "core/core.h"
#include "core/StdFilesource.h"
#include "core/TaskItem.h"
#include "core/TodoMd.h"
#include <catch2/catch_test_macros.hpp>