✨ (config_kit): Add 'ConfigKit'

libs/CMakeLists.txt

@@ -6,6 +6,7 @@ add_subdirectory(${LIBS_DIR}/BatteryKit)
 add_subdirectory(${LIBS_DIR}/BehaviorKit)
 add_subdirectory(${LIBS_DIR}/BLEKit)
 add_subdirectory(${LIBS_DIR}/ColorKit)
+add_subdirectory(${LIBS_DIR}/ConfigKit)
 add_subdirectory(${LIBS_DIR}/ContainerKit)
 add_subdirectory(${LIBS_DIR}/FileSystemKit)
 add_subdirectory(${LIBS_DIR}/FirmwareKit)

libs/ConfigKit/CMakeLists.txt

@@ -0,0 +1,28 @@
+# Leka - LekaOS
+# Copyright 2021 APF France handicap
+# SPDX-License-Identifier: Apache-2.0
+
+add_library(ConfigKit STATIC)
+
+target_include_directories(ConfigKit
+	PUBLIC
+		include
+)
+
+target_sources(ConfigKit
+	PRIVATE
+		source/Config.cpp
+)
+
+target_link_libraries(ConfigKit
+	mbed-os
+	FileSystemKit
+)
+
+if (${CMAKE_PROJECT_NAME} STREQUAL "LekaOSUnitTests")
+
+	leka_unit_tests_sources(
+		tests/Config_test.cpp
+	)
+
+endif()

libs/ConfigKit/include/ConfigKit.h

@@ -0,0 +1,40 @@
+// Leka - LekaOS
+// Copyright 2022 APF France handicap
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <span>
+
+#include "FileSystemKit.h"
+#include "interface/platform/File.h"
+
+namespace leka {
+
+struct Config {
+  public:
+	Config(const std::filesystem::path &path) : _path(path) {};
+
+	auto path() -> std::filesystem::path { return _path; }
+
+  private:
+	const std::filesystem::path &_path;
+};
+
+class ConfigKit
+{
+  public:
+	explicit ConfigKit() = default;
+	auto read(Config &_config) -> uint8_t;
+	auto write(uint8_t data, Config &_config) -> bool;
+
+	static constexpr uint8_t default_content_value = 0xFF;
+
+  private:
+	FileSystemKit::File _configuration_file {};
+};
+
+}	// namespace leka

libs/ConfigKit/include/ConfigList.h

@@ -0,0 +1,21 @@
+// Leka - LekaOS
+// Copyright 2022 APF France handicap
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <filesystem>
+
+#include "ConfigKit.h"
+
+namespace leka::config {
+
+namespace format {
+	const std::filesystem::path parent_path = "/fs/conf";
+}	// namespace format
+
+namespace list {
+	const Config _bootloader_battery_hysteresis(format::parent_path / "bootloader_battery_hysteresis.conf");
+}
+
+}	// namespace leka::config

libs/ConfigKit/source/Config.cpp

@@ -0,0 +1,38 @@
+// Leka - LekaOS
+// Copyright 2021 APF France handicap
+// SPDX-License-Identifier: Apache-2.0
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <span>
+
+#include "ConfigKit.h"
+#include "LogKit.h"
+
+using namespace leka;
+
+auto ConfigKit::read(Config &_config) -> uint8_t
+{
+	_configuration_file.open(_config.path().c_str(), "r");
+	if (!_configuration_file.is_open()) {
+		return ConfigKit::default_content_value;
+	}
+	auto input = std::array<uint8_t, 1> {};
+	_configuration_file.read(input);
+	_configuration_file.close();
+	auto data = input.front();
+	return data;
+}
+
+auto ConfigKit::write(uint8_t data, Config &_config) -> bool
+{
+	_configuration_file.open(_config.path().c_str(), "r+");
+	if (!_configuration_file.is_open()) {
+		return false;
+	}
+	auto output = std::array<uint8_t, 1> {data};
+	_configuration_file.write(output);
+	_configuration_file.close();
+	return true;
+}

libs/ConfigKit/tests/Config_test.cpp

@@ -0,0 +1,100 @@
+// Leka - LekaOS
+// Copyright 2021 APF France handicap
+// SPDX-License-Identifier: Apache-2.0
+
+#include <array>
+#include <fstream>
+#include <iostream>
+#include <span>
+#include <string>
+
+#include "ConfigKit.h"
+#include "FileSystemKit.h"
+#include "LogKit.h"
+#include "gtest/gtest.h"
+#include "mocks/leka/File.h"
+
+using namespace leka;
+
+class ConfigTest : public ::testing::Test
+{
+  protected:
+	void SetUp() override {}
+
+	auto readFirstValueTempFile() -> uint8_t
+	{
+		auto input_data = std::array<uint8_t, 1> {};
+		FileSystemKit::File _configuration_temp_file {temp_path.c_str()};
+		_configuration_temp_file.read(input_data);
+		_configuration_temp_file.close();
+		return input_data.front();
+	}
+
+	void writeFirstValueTempFile(uint8_t data)
+	{
+		auto output_data = std::array<uint8_t, 1> {data};
+		FileSystemKit::File _configuration_temp_file {temp_path.c_str(), "r+"};
+		_configuration_temp_file.write(output_data);
+		_configuration_temp_file.close();
+	}
+
+	void touchTempFile()
+	{
+		FileSystemKit::File _configuration_temp_file {temp_path.c_str(), "w"};
+		_configuration_temp_file.close();
+	}
+	void removeTempFile() { std::remove(temp_path.c_str()); }
+
+	const std::filesystem::path temp_path = "/tmp/temp.conf";
+
+	Config temp {temp_path};
+};
+
+TEST_F(ConfigTest, initializationWithPath)
+{
+	auto _config_manager = ConfigKit();
+	ASSERT_NE(&_config_manager, nullptr);
+}
+
+TEST_F(ConfigTest, readNotOpenFile)
+{
+	auto _config_manager = ConfigKit();
+	removeTempFile();
+	auto data = _config_manager.read(temp);
+	ASSERT_EQ(ConfigKit::default_content_value, data);
+}
+
+TEST_F(ConfigTest, readEmptyFile)
+{
+	auto _config_manager = ConfigKit();
+	removeTempFile();
+	touchTempFile();
+	auto data = _config_manager.read(temp);
+	ASSERT_EQ(0, data);
+}
+
+TEST_F(ConfigTest, read)
+{
+	auto _config_manager = ConfigKit();
+	writeFirstValueTempFile(5);
+	auto data = _config_manager.read(temp);
+	ASSERT_EQ(5, data);
+}
+
+TEST_F(ConfigTest, writeNotOpenFile)
+{
+	auto _config_manager = ConfigKit();
+	removeTempFile();
+	auto write = _config_manager.write(5, temp);
+	ASSERT_FALSE(write);
+}
+
+TEST_F(ConfigTest, write)
+{
+	auto _config_manager = ConfigKit();
+	touchTempFile();
+	auto write = _config_manager.write(5, temp);
+	ASSERT_TRUE(write);
+	auto data = readFirstValueTempFile();
+	ASSERT_EQ(5, data);
+}

libs/FileSystemKit/include/FileSystemKit.h

@@ -11,50 +11,46 @@
 
 #include "interface/platform/File.h"
 
-namespace leka {
+namespace leka::FileSystemKit {
 
-class FileSystemKit
-{
-  public:
-	struct File : public interface::File, public mbed::NonCopyable<File> {
-		File(const char *path = nullptr, const char *mode = "r");
+struct File : public interface::File, public mbed::NonCopyable<File> {
+	File(const char *path = nullptr, const char *mode = "r");
 
-		auto open(const char *path, const char *mode = "r") -> bool final;
-		void close() final;
+	auto open(const char *path, const char *mode = "r") -> bool final;
+	void close() final;
 
-		auto read(std::span<uint8_t> buffer) -> size_t final;
-		auto write(std::span<uint8_t> data) -> size_t final;
+	auto read(std::span<uint8_t> buffer) -> size_t final;
+	auto write(std::span<uint8_t> data) -> size_t final;
 
-		auto read(std::span<char> buffer) -> size_t final;
-		auto write(std::span<char> data) -> size_t final;
+	auto read(std::span<char> buffer) -> size_t final;
+	auto write(std::span<char> data) -> size_t final;
 
-		auto read(uint8_t *buffer, uint32_t size) -> size_t final;
-		auto write(const uint8_t *data, uint32_t size) -> size_t final;
+	auto read(uint8_t *buffer, uint32_t size) -> size_t final;
+	auto write(const uint8_t *data, uint32_t size) -> size_t final;
 
-		auto read(char *buffer, uint32_t size) -> size_t final;
-		auto write(const char *data, uint32_t size) -> size_t final;
+	auto read(char *buffer, uint32_t size) -> size_t final;
+	auto write(const char *data, uint32_t size) -> size_t final;
 
-		void seek(size_t pos, int origin = SEEK_SET) final;
-		void rewind() final;
-		auto size() -> size_t final;
+	void seek(size_t pos, int origin = SEEK_SET) final;
+	void rewind() final;
+	auto size() -> size_t final;
 
-		auto tell() -> size_t final;
+	auto tell() -> size_t final;
 
-		auto reopen(const char *path, const char *mode = "r") -> bool final;
+	auto reopen(const char *path, const char *mode = "r") -> bool final;
 
-		auto setBuffer(std::span<char> buffer, int mode = _IOFBF) -> bool final;
-		auto setBuffer(char *buffer, uint32_t size = BUFSIZ, int mode = _IOFBF) -> bool final;
-		auto unsetBuffer() -> bool final;
-		auto flush() -> bool final;
+	auto setBuffer(std::span<char> buffer, int mode = _IOFBF) -> bool final;
+	auto setBuffer(char *buffer, uint32_t size = BUFSIZ, int mode = _IOFBF) -> bool final;
+	auto unsetBuffer() -> bool final;
+	auto flush() -> bool final;
 
-		auto error() -> bool final;
-		void clearerr() final;
+	auto error() -> bool final;
+	void clearerr() final;
 
-		[[nodiscard]] auto is_open() const -> bool final;
+	[[nodiscard]] auto is_open() const -> bool final;
 
-	  private:
-		std::unique_ptr<FILE, decltype(&fclose)> _file {nullptr, fclose};
-	};
+  private:
+	std::unique_ptr<FILE, decltype(&fclose)> _file {nullptr, fclose};
 };
 
-}	// namespace leka
+}	// namespace leka::FileSystemKit

spikes/CMakeLists.txt

@@ -7,6 +7,7 @@ add_subdirectory(${SPIKES_DIR}/lk_ble)
 add_subdirectory(${SPIKES_DIR}/lk_bluetooth)
 add_subdirectory(${SPIKES_DIR}/lk_cg_animations)
 add_subdirectory(${SPIKES_DIR}/lk_color_kit)
+add_subdirectory(${SPIKES_DIR}/lk_config_kit)
 add_subdirectory(${SPIKES_DIR}/lk_coreled)
 add_subdirectory(${SPIKES_DIR}/lk_event_queue)
 add_subdirectory(${SPIKES_DIR}/lk_file_reception)

spikes/lk_config_kit/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Leka - LekaOS
+# Copyright 2022 APF France handicap
+# SPDX-License-Identifier: Apache-2.0
+
+add_mbed_executable(spike_lk_config_kit)
+
+target_include_directories(spike_lk_config_kit
+	PRIVATE
+		.
+)
+
+target_sources(spike_lk_config_kit
+	PRIVATE
+		main.cpp
+)
+
+target_link_libraries(spike_lk_config_kit
+	FileSystemKit
+	ConfigKit
+)
+
+target_link_custom_leka_targets(spike_lk_config_kit)