refactor: separate format component (#88)

* refactor: separate `errors::format` and other functions to `components/format`

* style(format): wrap `formatter<errors::Error>` in `fmt` namespace

* refactor(format): separate implementation of `format` function to `format.ipp`

* build: add `NOT_SUBPROJECT` variable

* docs: add support to build docs for `format` component

Author: threeal

CMakeLists.txt

@@ -2,18 +2,19 @@ cmake_minimum_required(VERSION 3.12)
 
 project(errors)
 
-# Import dependencies
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  set(NOT_SUBPROJECT TRUE)
+endif()
+
+# Initialize CPM.cmake
 include(cmake/CPM.cmake)
-cpmaddpackage("gh:fmtlib/fmt#10.0.0")
 
 # Build the main library
 add_library(errors src/error.cpp)
 target_include_directories(errors PUBLIC include)
-target_link_libraries(errors PUBLIC fmt)
-target_compile_features(errors PRIVATE cxx_std_20)
 
 # Check if this project is the main project
-if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+if(NOT_SUBPROJECT)
   option(BUILD_DOCS "Enable documentations build" OFF)
 
   # Statically analyze code by checking for warnings
@@ -37,14 +38,11 @@ if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
     # Append the main library properties instead of linking the library.
     get_target_property(errors_SOURCES errors SOURCES)
     get_target_property(errors_INCLUDES errors INCLUDE_DIRECTORIES)
-    get_target_property(errors_LIBRARIES errors LINK_LIBRARIES)
-    get_target_property(errors_FEATURES errors COMPILE_FEATURES)
 
     # Build tests for the main library
     add_executable(errors_test test/error_test.cpp ${errors_SOURCES})
     target_include_directories(errors_test PRIVATE ${errors_INCLUDES})
-    target_link_libraries(errors_test PRIVATE Catch2::Catch2WithMain ${errors_LIBRARIES})
-    target_compile_features(errors_test PRIVATE ${errors_FEATURES})
+    target_link_libraries(errors_test PRIVATE Catch2::Catch2WithMain)
 
     # Enable support to check for test coverage
     if(NOT MSVC)
@@ -58,6 +56,8 @@ if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
   # Build XML documentation
   if(BUILD_DOCS)
     include(cmake/add_xml_docs.cmake)
-    add_xml_docs(docs include/errors/error.hpp)
+    add_xml_docs(errors_docs include/errors/error.hpp)
   endif()
 endif()
+
+add_subdirectory(components)

components/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(format)

components/format/CMakeLists.txt

@@ -0,0 +1,35 @@
+cpmaddpackage("gh:fmtlib/fmt#10.0.0")
+
+add_library(errors_format src/format.cpp)
+target_include_directories(errors_format PUBLIC include)
+target_link_libraries(errors_format PUBLIC errors fmt)
+target_compile_features(errors_format PRIVATE cxx_std_20)
+
+if(NOT_SUBPROJECT)
+  if (BUILD_TESTING)
+    # Append the main library properties instead of linking the library.
+    get_target_property(errors_format_SOURCES errors_format SOURCES)
+    get_target_property(errors_format_INCLUDES errors_format INCLUDE_DIRECTORIES)
+    get_target_property(errors_format_LIBRARIES errors_format LINK_LIBRARIES)
+    get_target_property(errors_format_FEATURES errors_format COMPILE_FEATURES)
+
+    # Build tests for the main library
+    add_executable(errors_format_test test/format_test.cpp ${errors_format_SOURCES})
+    target_include_directories(errors_format_test PRIVATE ${errors_format_INCLUDES})
+    target_link_libraries(errors_format_test PRIVATE Catch2::Catch2WithMain ${errors_format_LIBRARIES})
+    target_compile_features(errors_format_test PRIVATE ${errors_format_FEATURES})
+
+    # Enable support to check for test coverage
+    if(NOT MSVC)
+      target_compile_options(errors_format_test PRIVATE --coverage -O0 -fno-exceptions)
+      target_link_options(errors_format_test PRIVATE --coverage)
+    endif()
+
+    catch_discover_tests(errors_format_test)
+  endif()
+
+  # Build XML documentation
+  if(BUILD_DOCS)
+    add_xml_docs(errors_format_docs include/errors/format.hpp)
+  endif()
+endif()

components/format/include/errors/format.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <errors/error.hpp>
+#include <fmt/core.h>
+
+namespace errors {
+
+/**
+ * @brief Creates a new error object with a formatted message.
+ * @tparam T Variadic template parameter pack for format arguments.
+ * @param fmt A format string for the message.
+ * @param args Format arguments.
+ * @return A new error object.
+ */
+template <typename... T>
+Error format(fmt::format_string<T...> fmt, T&&... args);
+
+}  // namespace errors
+
+namespace fmt {
+
+template <>
+struct formatter<errors::Error> {
+  format_parse_context::iterator parse(format_parse_context& ctx) const;
+  format_context::iterator format(const errors::Error& err,
+                                  format_context& ctx) const;
+};
+
+}  // namespace fmt
+
+#include "format.ipp"

components/format/include/errors/format.ipp

@@ -0,0 +1,8 @@
+namespace errors {
+
+template <typename... T>
+Error format(fmt::format_string<T...> fmt, T&&... args) {
+  return errors::make(fmt::format(fmt, std::forward<T>(args)...));
+}
+
+}  // namespace errors

components/format/src/format.cpp

@@ -0,0 +1,15 @@
+#include <errors/format.hpp>
+
+namespace fmt {
+
+format_parse_context::iterator formatter<errors::Error>::parse(
+    format_parse_context& ctx) const {
+  return ctx.begin();
+}
+
+format_context::iterator formatter<errors::Error>::format(
+    const errors::Error& err, format_context& ctx) const {
+  return format_to(ctx.out(), "error: {}", err.message());
+}
+
+}  // namespace fmt

components/format/test/format_test.cpp

@@ -0,0 +1,14 @@
+#include <fmt/core.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <errors/format.hpp>
+
+TEST_CASE("Error Construction With Formatting") {
+  const errors::Error err = errors::format("HTTP error {}", 404);
+  REQUIRE(err.message() == "HTTP error 404");
+}
+
+TEST_CASE("Error Printing Using fmtlib") {
+  const auto err = errors::make("unknown error");
+  REQUIRE(fmt::format("{}", err) == "error: unknown error");
+}

docs/conf.py

@@ -7,10 +7,12 @@
 extensions = ['breathe']
 
 subprocess.call('cmake .. -B ../build -D BUILD_DOCS=ON', shell=True)
-subprocess.call('cmake --build ../build --target docs', shell=True)
+subprocess.call('cmake --build ../build --target errors_docs --target errors_format_docs', shell=True)
 
-breathe_projects = {"errors": "../build/docs"}
-breathe_default_project = "errors"
+breathe_projects = {
+    "errors": "../build/errors_docs",
+    "errors_format": "../build/components/format/errors_format_docs"
+}
 
 html_theme = 'furo'
 html_static_path = ['_static']

docs/index.rst

@@ -9,8 +9,15 @@ API Docs
 --------
 
 .. doxygenclass:: errors::Error
+   :project: errors
    :members:
 
+Format Component
+^^^^^^^^^^^^^^^^
+
+.. doxygenfunction:: errors::format
+   :project: errors_format
+
 License
 -------
 

include/errors/error.hpp

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <fmt/core.h>
-
 #include <memory>
 #include <ostream>
 #include <string>
@@ -33,9 +31,6 @@ class Error {
 
   friend Error make(const std::string& msg);
 
-  template <typename... T>
-  friend Error format(fmt::format_string<T...> fmt, T&&... args);
-
   /**
    * @brief Writes the string representation of an error object to the given
    * output stream.
@@ -64,23 +59,4 @@ class Error {
  */
 Error make(const std::string& msg);
 
-/**
- * @brief Creates a new error object with a formatted message.
- * @tparam T Variadic template parameter pack for format arguments.
- * @param fmt A format string for the message.
- * @param args Format arguments.
- * @return A new error object.
- */
-template <typename... T>
-Error format(fmt::format_string<T...> fmt, T&&... args) {
-  return errors::make(fmt::format(fmt, std::forward<T>(args)...));
-}
-
 }  // namespace error
-
-template <>
-struct fmt::formatter<errors::Error> {
-  format_parse_context::iterator parse(format_parse_context& ctx) const;
-  format_context::iterator format(const errors::Error& err,
-                                  format_context& ctx) const;
-};

src/error.cpp

@@ -18,17 +18,3 @@ Error make(const std::string& msg) {
 }
 
 }  // namespace error
-
-namespace fmt {
-
-format_parse_context::iterator formatter<errors::Error>::parse(
-    format_parse_context& ctx) const {
-  return ctx.begin();
-}
-
-format_context::iterator formatter<errors::Error>::format(
-    const errors::Error& err, format_context& ctx) const {
-  return format_to(ctx.out(), "error: {}", err.message());
-}
-
-}  // namespace fmt

test/error_test.cpp

@@ -1,29 +1,14 @@
-#include <fmt/core.h>
-
 #include <catch2/catch_test_macros.hpp>
 #include <errors/error.hpp>
 #include <sstream>
-#include <string>
 
 TEST_CASE("Error Construction") {
   const errors::Error err = errors::make("unknown error");
   REQUIRE(err.message() == "unknown error");
 }
 
-TEST_CASE("Error Construction With Formatting") {
-  const errors::Error err = errors::format("HTTP error {}", 404);
-  REQUIRE(err.message() == "HTTP error 404");
-}
-
-TEST_CASE("Error Printing") {
+TEST_CASE("Error Printing Using OStream") {
   const auto err = errors::make("unknown error");
-
-  SECTION("Using ostream") {
-    const auto ss = std::stringstream() << err;
-    REQUIRE(ss.str() == "error: unknown error");
-  }
-
-  SECTION("Using fmtlib") {
-    REQUIRE(fmt::format("{}", err) == "error: unknown error");
-  }
+  const auto ss = std::stringstream() << err;
+  REQUIRE(ss.str() == "error: unknown error");
 }