fable: Accept // comments in JSON files

This can be configured by a Conan package option named
"allow_comments", which is set to True by default.

Author: cassava

engine/conanfile.py

@@ -14,6 +14,9 @@ class CloeEngine(ConanFile):
         "pedantic": [True, False],
     }
     default_options = {
+        "fable:allow_comments": True,
+
+        # These don't change the output.
         "test": True,
         "pedantic": True,
     }

fable/CMakeLists.txt

@@ -39,6 +39,13 @@ target_link_libraries(${target}
     CONAN_PKG::nlohmann_json
 )
 
+option(AllowComments "Allow comments when parsing JSON?" ON)
+if(AllowComments)
+    target_compile_definitions(${target} PRIVATE PARSE_JSON_WITH_COMMENTS=true)
+else()
+    target_compile_definitions(${target} PRIVATE PARSE_JSON_WITH_COMMENTS=false)
+endif()
+
 # Testing ------------------------------------------------------------
 option(BuildTests "Build tests?" ON)
 if(BuildTests)

fable/conanfile.py

@@ -9,11 +9,13 @@ class Fable(ConanFile):
     description = "JSON schema and configuration library"
     settings = "os", "compiler", "build_type", "arch"
     options = {
+        "allow_comments": [True, False],
         "shared": [True, False],
         "fPIC": [True, False],
         "test": [True, False],
     }
     default_options = {
+        "allow_comments": True,
         "shared": False,
         "fPIC": True,
         "test": True,
@@ -53,6 +55,7 @@ def _configure_cmake(self):
         self._cmake = CMake(self)
         self._cmake.definitions["CMAKE_EXPORT_COMPILE_COMMANDS"] = True
         self._cmake.definitions["FABLE_VERSION"] = self.version
+        self._cmake.definitions["AllowComments"] = self.options.allow_comments
         self._cmake.definitions["BuildTests"] = self.options.test
         self._cmake.configure()
         return self._cmake

fable/include/fable/json.hpp

@@ -32,6 +32,25 @@
 
 namespace fable {
 
+/**
+ * When parsing JSON from fable, should comments be allowed or lead to an
+ * exception? Value is controlled by `PARSE_JSON_WITH_COMMENTS` define.
+ * Default value is true.
+ *
+ * This does not automatically apply to use of `Json::parse`. Instead you
+ * should use the parse_json helper function defined in this file.
+ */
+extern bool NLOHMANN_JSON_ALLOW_COMMENTS;
+
+/**
+ * When parsing JSON from fable, should exceptions be used?
+ * Default value is set by `PARSE_JSON_WITH_COMMENTS` define.
+ *
+ * This is here for completeness. The fable library will not work
+ * correctly if exceptions are disabled, so this should always be set to true.
+ */
+extern bool NLOHMANN_JSON_USE_EXCEPTIONS;
+
 /**
  * The Json type maps to nlohmann::json.
  *
@@ -75,6 +94,19 @@ using JsonType = Json::value_t;
  */
 std::string to_string(JsonType);
 
+/**
+ * Return the result of Json::parse, with the options to use exceptions and
+ * allow comments as set in this library, from NLOHMANN_JSON_USE_EXCEPTIONS and
+ * NLOHMANN_JSON_ALLOW_COMMENTS.
+ *
+ * See the documentation on each of these global variables for more details.
+ */
+template <typename InputType>
+inline Json parse_json(InputType&& input) {
+  return Json::parse(std::forward<InputType>(input), nullptr, NLOHMANN_JSON_USE_EXCEPTIONS,
+                     NLOHMANN_JSON_ALLOW_COMMENTS);
+}
+
 }  // namespace fable
 
 #endif  // FABLE_JSON_HPP_

fable/include/fable/utility/gtest.hpp

@@ -47,7 +47,7 @@ inline void assert_schema_eq(const Confable& x, const Json& expect) {
 }
 
 inline void assert_schema_eq(const Confable& x, const char expect[]) {
-  assert_eq(x.schema().json_schema(), Json::parse(expect));
+  assert_eq(x.schema().json_schema(), parse_json(expect));
 }
 
 inline void assert_validate(const Confable& x, const Conf& input) {
@@ -60,15 +60,15 @@ inline void assert_validate(const Confable& x, const Conf& input) {
 }
 
 inline void assert_validate(const Confable& x, const char json_input[]) {
-  assert_validate(x, Conf{Json::parse(json_input)});
+  assert_validate(x, Conf{parse_json(json_input)});
 }
 
 inline void assert_invalidate(const Confable& x, const Conf& input) {
   ASSERT_THROW(x.schema().validate(input), SchemaError);
 }
 
 inline void assert_invalidate(const Confable& x, const char json_input[]) {
-  assert_invalidate(x, Conf{Json::parse(json_input)});
+  assert_invalidate(x, Conf{parse_json(json_input)});
 }
 
 template <typename T>
@@ -78,7 +78,7 @@ inline void assert_to_json(const T& x, const Json& expect) {
 
 template <typename T>
 inline void assert_to_json(const T& x, const char json_expect[]) {
-  assert_to_json(x, Json::parse(json_expect));
+  assert_to_json(x, parse_json(json_expect));
 }
 
 inline void assert_from_conf_throw(Confable& x, const Conf& input) {
@@ -88,7 +88,7 @@ inline void assert_from_conf_throw(Confable& x, const Conf& input) {
 }
 
 inline void assert_from_conf_throw(Confable& x, const char json_input[]) {
-  assert_from_conf_throw(x, Conf{Json::parse(json_input)});
+  assert_from_conf_throw(x, Conf{parse_json(json_input)});
 }
 
 template <typename T>
@@ -98,7 +98,7 @@ inline void assert_from_conf(T& x, const Conf& input) {
 
 template <typename T>
 inline void assert_from_conf(T& x, const char json_input[]) {
-  assert_from_conf(x, Conf{Json::parse(json_input)});
+  assert_from_conf(x, Conf{parse_json(json_input)});
 }
 
 template <typename T>
@@ -109,7 +109,7 @@ inline void assert_from_eq_to(T& x, const Json& identity) {
 
 template <typename T>
 inline void assert_from_eq_to(T& x, const char json_input[]) {
-  assert_from_eq_to(x, Json::parse(json_input));
+  assert_from_eq_to(x, parse_json(json_input));
 }
 
 }  // namespace fable

fable/src/fable/conf.cpp

@@ -30,6 +30,7 @@
 #include <boost/filesystem.hpp>  // for path
 
 #include <fable/error.hpp>  // for ConfError, WrongType, MissingProperty
+#include <fable/json.hpp>   // for NLOHMANN_JSON_ALLOW_COMMENTS
 
 namespace fable {
 
@@ -39,7 +40,7 @@ Conf::Conf(const std::string& file) : file_(file) {
     throw Error("could not open file {}: {}", file, strerror(errno));
   }
   try {
-    ifs >> data_;
+    data_ = parse_json(ifs);
   } catch (std::exception& e) {
     throw Error("unable to parse file {}: {}", file, e.what());
   }

fable/src/fable/json.cpp

@@ -20,12 +20,23 @@
  * \see  fable/json.hpp
  */
 
+#ifndef PARSE_JSON_USE_EXCEPTIONS
+#define PARSE_JSON_USE_EXCEPTIONS true
+#endif
+
+#ifndef PARSE_JSON_WITH_COMMENTS
+#define PARSE_JSON_WITH_COMMENTS true
+#endif
+
 #include <fable/json.hpp>
 
 #include <string>  // for string
 
 namespace fable {
 
+bool NLOHMANN_JSON_USE_EXCEPTIONS = PARSE_JSON_USE_EXCEPTIONS;
+bool NLOHMANN_JSON_ALLOW_COMMENTS = PARSE_JSON_WITH_COMMENTS;
+
 std::string to_string(JsonType type) {
   switch (type) {
     case JsonType::null:

fable/src/fable/utility.cpp

@@ -40,9 +40,7 @@ Json read_json_from_file(const char* filepath) {
     throw std::runtime_error(std::string("could not open file: ") + filepath);
   }
 
-  Json j;
-  ifs >> j;
-  return j;
+  return parse_json(ifs);
 }
 
 Json read_json_from_stdin() {
@@ -64,7 +62,7 @@ Json read_json_with_interpolation(const std::string& filepath_or_stdin, const En
     std::istreambuf_iterator<char> begin(std::cin), end;
     std::string s(begin, end);
     s = interpolate_vars(s, env);
-    return Json::parse(s);
+    return parse_json(s);
   } else {
     std::ifstream ifs(filepath_or_stdin);
     if (ifs.fail()) {
@@ -73,7 +71,7 @@ Json read_json_with_interpolation(const std::string& filepath_or_stdin, const En
     std::istreambuf_iterator<char> begin(ifs), end;
     std::string s(begin, end);
     s = interpolate_vars(s, env);
-    return Json::parse(s);
+    return parse_json(s);
   }
 }