fable: Implement Path schema for std::filesystem::path and boost::filesystem::path

BREAKING CHANGE: If you want to use boost::filesystem::path, you now need to
include `fable/schema/boost_path.hpp`.

Author: cassava

engine/src/stack.hpp

@@ -33,6 +33,7 @@
 #include <boost/filesystem/path.hpp>        // for path
 #include <boost/optional.hpp>               // for optional<>
 #include <fable/schema/boost_optional.hpp>  // for Optional<>
+#include <fable/schema/boost_path.hpp>      // for Path
 #include <fable/schema/custom.hpp>          // for CustomDeserializer
 #include <fable/schema/factory.hpp>         // for Factory
 

fable/CMakeLists.txt

@@ -19,17 +19,18 @@ add_library(fable
     # find src -type f -name "*.cpp" \! -name "*_test.cpp"
     src/fable/conf.cpp
     src/fable/confable.cpp
+    src/fable/environment.cpp
     src/fable/json.cpp
     src/fable/schema.cpp
     src/fable/schema/boolean.cpp
     src/fable/schema/number.cpp
-    src/fable/schema/struct.cpp
+    src/fable/schema/path.cpp
     src/fable/schema/string.cpp
+    src/fable/schema/struct.cpp
     src/fable/schema/variant.cpp
-    src/fable/schema/path.cpp
-    src/fable/environment.cpp
     src/fable/utility.cpp
     src/fable/utility/chrono.cpp
+    src/fable/utility/path.cpp
     src/fable/utility/string.cpp
 
     # For IDE integration
@@ -76,13 +77,14 @@ if(BUILD_TESTING)
         src/fable/schema/const_test.cpp
         src/fable/schema/custom_test.cpp
         src/fable/schema/enum_test.cpp
-        src/fable/schema/factory_test.cpp
         src/fable/schema/factory_advanced_test.cpp
+        src/fable/schema/factory_test.cpp
         src/fable/schema/ignore_test.cpp
         src/fable/schema/map_nested_test.cpp
         src/fable/schema/map_test.cpp
         src/fable/schema/number_test.cpp
         src/fable/schema/optional_test.cpp
+        src/fable/schema/path_test.cpp
         src/fable/schema/string_test.cpp
         src/fable/schema/struct_test.cpp
         src/fable/schema_test.cpp

fable/include/fable/schema/boost_path.hpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2023 Robert Bosch GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * \file fable/schema/boost_path.hpp
+ * \see  fable/schema/path.cpp
+ */
+
+#pragma once
+
+#include <fable/schema/path.hpp>
+#include <fable/schema/path_impl.hpp>
+#include <fable/utility/boost_path.hpp>
+
+#include <boost/filesystem/path.hpp>
+#include <boost/process/search_path.hpp>
+
+namespace fable {
+namespace schema {
+
+template <>
+struct is_path<boost::filesystem::path> : std::true_type {};
+
+namespace detail {
+
+template <>
+inline bool exists(const boost::filesystem::path& path) {
+  return boost::filesystem::exists(path);
+}
+
+template <>
+inline bool is_regular_file(const boost::filesystem::path& path) {
+  return boost::filesystem::is_regular_file(path);
+}
+
+template <>
+inline bool is_directory(const boost::filesystem::path& path) {
+  return boost::filesystem::is_directory(path);
+}
+
+template <>
+inline bool is_other(const boost::filesystem::path& path) {
+  return boost::filesystem::is_other(path);
+}
+
+template <>
+inline boost::filesystem::path canonical(const boost::filesystem::path& path) {
+  return boost::filesystem::canonical(path);
+}
+
+template <>
+inline std::optional<boost::filesystem::path> search_path(const boost::filesystem::path& executable) {
+  boost::filesystem::path path = boost::process::search_path(executable);
+  if (path.empty()) {
+    return std::nullopt;
+  }
+  return path;
+}
+
+}  // namespace detail
+
+}  // namespace schema
+}  // namespace fable

fable/include/fable/schema/path.hpp

@@ -23,20 +23,46 @@
 
 #pragma once
 
-#include <limits>   // for numeric_limits<>
-#include <string>   // for string
-#include <utility>  // for move
-
-#include <boost/filesystem/path.hpp>  // for path
+#include <filesystem>  // for path
+#include <limits>      // for numeric_limits<>
+#include <string>      // for string
+#include <utility>     // for move
 
+#include <fable/fable_fwd.hpp>         // for Environment
 #include <fable/schema/interface.hpp>  // for Base<>
+#include <fable/utility/path.hpp>      // for adl_serializer<>
 
 namespace fable {
+namespace schema {
 
-// Forward declarations:
-class Environment;  // from <fable/environment.hpp>
+/**
+ * Helper type trait class to use with std::enable_if and friends.
+ *
+ * The value `is_path<T>::value` is true if T is one of:
+ * - std::filesystem::path
+ * - boost::filesystem::path, if boost_path.hpp is included
+ *
+ * \see fable/schema/boost_path.hpp
+ */
+template <typename T>
+struct is_path : std::false_type {};
 
-namespace schema {
+template <>
+struct is_path<std::filesystem::path> : std::true_type {};
+
+/**
+ * State represents valid states a path can be in relative to the filesystem.
+ */
+enum class PathState {
+  Any,         /// any valid path
+  Absent,      /// path does not exist
+  Exists,      /// path exists
+  Executable,  /// path exists in search path or locally and has executable permission
+  FileExists,  /// path exists and is a file
+  DirExists,   /// path exists and is a directory
+  NotFile,     /// path does not exist or is a directory
+  NotDir,      /// path does not exist or is a file
+};
 
 /**
  * Path de-/serializes a string that represents a filesystem path.
@@ -52,26 +78,20 @@ namespace schema {
  *
  * The Path schema type allows the user to specify these properties and will
  * validate these during deserialization.
+ *
+ * Path is a template class that supports both:
+ * - std::filesystem::path
+ * - boost::filesystem::path, if boost_path.hpp is included
  */
-class Path : public Base<Path> {
+template <typename T>
+class Path : public Base<Path<T>> {
+  static_assert(is_path<T>::value);
+
  public:  // Types and Constructors
-  using Type = boost::filesystem::path;
+  using Type = T;
+  using State = PathState;
 
-  /**
-   * State represents valid states a path can be in relative to the filesystem.
-   */
-  enum class State {
-    Any,         /// any valid path
-    Absent,      /// path does not exist
-    Exists,      /// path exists
-    Executable,  /// path exists in search path or locally and has executable permission
-    FileExists,  /// path exists and is a file
-    DirExists,   /// path exists and is a directory
-    NotFile,     /// path does not exist or is a directory
-    NotDir,      /// path does not exist or is a file
-  };
-
-  Path(Type* ptr, std::string desc) : Base(JsonType::string, std::move(desc)), ptr_(ptr) {}
+  Path(Type* ptr, std::string desc) : Base<Path<T>>(JsonType::string, std::move(desc)), ptr_(ptr) {}
 
  public:  // Special
   /**
@@ -213,20 +233,10 @@ class Path : public Base<Path> {
   Type* ptr_{nullptr};
 };
 
-template <typename S>
-inline Path make_schema(boost::filesystem::path* ptr, S&& desc) {
+template <typename T, typename S, std::enable_if_t<is_path<T>::value, bool> = true>
+inline Path<T> make_schema(T* ptr, S&& desc) {
   return Path(ptr, std::forward<S>(desc));
 }
 
 }  // namespace schema
 }  // namespace fable
-
-namespace nlohmann {
-
-template <>
-struct adl_serializer<boost::filesystem::path> {
-  static void to_json(json& j, const boost::filesystem::path& p) { j = p.native(); }
-  static void from_json(const json& j, boost::filesystem::path& p) { p = j.get<std::string>(); }
-};
-
-}  // namespace nlohmann