Remove core::except completely

.github/workflows/linux.yml

@@ -65,6 +65,7 @@ jobs:
           sudo apt-get install -y -qq pkg-config cmake ${{ matrix.compiler.pacakge }}
 
       - name: Restore & Cache CMake build results
+        if: matrix.build_type != 'Coverage'
         uses: actions/[email protected]
         with:
           path: build

include/poac/config.hpp

@@ -25,7 +25,8 @@ namespace poac {
 } // end namespace
 
 namespace poac::config::path {
-    inline const std::filesystem::path root(util::misc::expand_user() / std::filesystem::path(".poac"));
+    inline const std::filesystem::path user = util::misc::expand_user().unwrap();
+    inline const std::filesystem::path root(user / ".poac");
     inline const std::filesystem::path cache_dir(root / "cache");
     inline const std::filesystem::path archive_dir(cache_dir / "archive");
     inline const std::filesystem::path extract_dir(cache_dir / "extract");

include/poac/core.hpp

@@ -2,7 +2,6 @@
 #define POAC_CORE_HPP
 
 #include <poac/core/builder.hpp>
-#include <poac/core/except.hpp>
 #include <poac/core/resolver.hpp>
 #include <poac/core/validator.hpp>
 

include/poac/core/resolver.hpp

@@ -95,7 +95,7 @@ namespace poac::core::resolver {
             std::ofstream archive(archive_path);
             const auto [host, target] = util::net::parse_url(download_link);
             const util::net::requests requests{ host };
-            requests.get(target, {}, std::move(archive));
+            static_cast<void>(requests.get(target, {}, std::move(archive)));
 
             return mitama::success(archive_path);
         } catch (...) {

include/poac/util/misc.hpp

@@ -13,9 +13,7 @@
 // external
 #include <boost/algorithm/string.hpp>
 #include <boost/predef.h>
-
-// internal
-#include <poac/core/except.hpp>
+#include <mitama/result/result.hpp>
 
 namespace poac::util::misc {
     inline namespace path_literals {
@@ -58,19 +56,18 @@ namespace poac::util::misc {
 
     // Inspired by https://stackoverflow.com/q/4891006
     // Expand ~ to user home directory.
-    std::string expand_user() {
+    [[nodiscard]] mitama::result<std::filesystem::path, std::string>
+    expand_user() {
         auto home = dupenv("HOME");
         if (home || (home = dupenv("USERPROFILE"))) {
-            return home.value();
+            return mitama::success(home.value());
         } else {
             const auto home_drive = dupenv("HOMEDRIVE");
             const auto home_path = dupenv("HOMEPATH");
             if (home_drive && home_path) {
-                return home_drive.value() + home_path.value();
+                return mitama::success(home_drive.value() + home_path.value());
             }
-            throw core::except::error(
-                "could not read environment variable"
-            );
+            return mitama::failure("could not get home directory");
         }
     }
 } // end namespace

include/poac/util/net.hpp

@@ -37,7 +37,6 @@
 
 // internal
 #include <poac/config.hpp>
-#include <poac/core/except.hpp>
 #include <poac/util/meta.hpp>
 #include <poac/util/misc.hpp>
 #include <poac/util/pretty.hpp>
@@ -268,7 +267,7 @@ namespace poac::util::net {
             typename ResponseBody,
             typename Request,
             typename Ofstream>
-        typename ResponseBody::value_type
+        [[nodiscard]] mitama::result<typename ResponseBody::value_type, std::string>
         request(Request&& req, Ofstream&& ofs) const {
             ssl_prepare();
             write_request(req);
@@ -288,7 +287,7 @@ namespace poac::util::net {
                         std::ofstream>,
                     http::vector_body<unsigned char>,
                     http::string_body>>
-        typename ResponseBody::value_type
+        [[nodiscard]] mitama::result<typename ResponseBody::value_type, std::string>
         get(
             const std::string_view target,
             const headers_t& headers={},
@@ -320,7 +319,7 @@ namespace poac::util::net {
                         std::ofstream>,
                     http::vector_body<unsigned char>,
                     http::string_body>>
-        typename ResponseBody::value_type
+        [[nodiscard]] mitama::result<typename ResponseBody::value_type, std::string>
         post(
             const std::string_view target,
             BodyType&& body,
@@ -429,7 +428,7 @@ namespace poac::util::net {
             typename ResponseBody,
             typename Request,
             typename Ofstream>
-        typename ResponseBody::value_type
+        [[nodiscard]] mitama::result<typename ResponseBody::value_type, std::string>
         read_response(Request&& old_req, Ofstream&& ofs) const {
             // This buffer is used for reading and must be persisted
             boost::beast::flat_buffer buffer;
@@ -439,9 +438,10 @@ namespace poac::util::net {
             http::read(*stream, buffer, res);
             // Handle HTTP status code
             return handle_status<method>(
-                    std::forward<Request>(old_req),
-                    std::move(res),
-                    std::forward<Ofstream>(ofs));
+                std::forward<Request>(old_req),
+                std::move(res),
+                std::forward<Ofstream>(ofs)
+            );
         }
 
         template <
@@ -450,35 +450,33 @@ namespace poac::util::net {
             typename Response,
             typename Ofstream,
             typename ResponseBody = typename Response::body_type>
-        typename ResponseBody::value_type
+        [[nodiscard]] mitama::result<typename ResponseBody::value_type, std::string>
         handle_status(Request&& old_req, Response&& res, Ofstream&& ofs) const
         {
             close_stream();
             switch (res.base().result_int() / 100) {
                 case 2:
-                    return parse_response(
-                            std::forward<Response>(res),
-                            std::forward<Ofstream>(ofs));
+                    return mitama::success(parse_response(
+                        std::forward<Response>(res),
+                        std::forward<Ofstream>(ofs)
+                    ));
                 case 3:
                     return redirect<method>(
-                            std::forward<Request>(old_req),
-                            std::forward<Response>(res),
-                            std::forward<Ofstream>(ofs));
+                        std::forward<Request>(old_req),
+                        std::forward<Response>(res),
+                        std::forward<Ofstream>(ofs)
+                    );
                 default:
                     if constexpr (!std::is_same_v<util::meta::remove_cvref_t<Ofstream>, std::ofstream>) {
-                        throw core::except::error(
-                            fmt::format(
-                                "util::net received a bad response code: {}\n{}",
-                                res.base().result_int(), res.body()
-                            )
-                        );
+                        return mitama::failure(fmt::format(
+                            "util::net received a bad response code: {}\n{}",
+                            res.base().result_int(), res.body()
+                        ));
                     } else {
-                        throw core::except::error(
-                            fmt::format(
-                                "util::net received a bad response code: {}",
-                                res.base().result_int()
-                            )
-                        );
+                        throw mitama::failure(fmt::format(
+                            "util::net received a bad response code: {}",
+                            res.base().result_int()
+                        ));
                     }
             }
         }
@@ -524,7 +522,7 @@ namespace poac::util::net {
             typename Response,
             typename Ofstream,
             typename ResponseBody = typename Response::body_type>
-        typename ResponseBody::value_type
+        [[nodiscard]] mitama::result<typename ResponseBody::value_type, std::string>
         redirect(Request&& old_req, Response&& res, Ofstream&& ofs) const {
             const std::string new_location(res.base()["Location"]);
             const auto [new_host, new_target] = parse_url(new_location);
@@ -537,7 +535,7 @@ namespace poac::util::net {
             } else if (method == http::verb::post) {
                 return req.post(new_target, old_req.body(), {}, std::forward<Ofstream>(ofs));
             } else { // verb error
-                return {};
+                return mitama::failure("[util::net::requests] unknown verb used");
             }
         }
 
@@ -593,15 +591,13 @@ namespace poac::util::net::api {
             headers.emplace("X-Algolia-API-Key", ALGOLIA_SEARCH_ONLY_KEY);
             headers.emplace("X-Algolia-Application-Id", ALGOLIA_APPLICATION_ID);
 
-            const auto response = request.post(ALGOLIA_SEARCH_INDEX_API, body, headers);
+            const auto response = MITAMA_TRY(request.post(ALGOLIA_SEARCH_INDEX_API, body, headers));
             std::stringstream response_body;
             response_body << response.data();
 
             boost::property_tree::ptree pt;
             boost::property_tree::json_parser::read_json(response_body, pt);
             return mitama::success(pt);
-        } catch (const core::except::error& e) {
-            return mitama::failure(e.what());
         } catch (...) {
             return mitama::failure("unknown error caused when calling search api");
         }

tests/CMakeLists.txt

@@ -1,6 +1,5 @@
 set(TEST_NAMES
         cfg
-        except
         meta
         misc
         net