Merge Output into src/build (#713)

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

src/build/CMakeLists.txt

@@ -1,2 +1,5 @@
 sourcemeta_library(NAMESPACE sourcemeta PROJECT one NAME build
   SOURCES build.cc)
+target_link_libraries(sourcemeta_one_build
+  PUBLIC sourcemeta::core::json
+  PRIVATE sourcemeta::core::jsonschema)

src/build/build.cc

@@ -1,5 +1,7 @@
 #include <sourcemeta/one/build.h>
 
+#include <sourcemeta/core/jsonschema.h>
+
 #include <cassert>     // assert
 #include <chrono>      // std::chrono::nanoseconds, std::chrono::duration_cast
 #include <cstdint>     // std::int64_t
@@ -18,7 +20,13 @@ auto Build::dependency(std::filesystem::path node)
 }
 
 Build::Build(const std::filesystem::path &output_root)
-    : root{std::filesystem::canonical(output_root)} {
+    : root{(static_cast<void>(std::filesystem::create_directories(output_root)),
+            std::filesystem::canonical(output_root))} {
+  for (const auto &entry :
+       std::filesystem::recursive_directory_iterator(this->root)) {
+    this->tracker.emplace(entry.path(), false);
+  }
+
   const auto deps_path{this->root / DEPENDENCIES_FILE};
   if (!std::filesystem::exists(deps_path)) {
     return;
@@ -114,15 +122,14 @@ auto Build::has_dependencies(const std::filesystem::path &path) const -> bool {
   return match != this->dependencies_map.end() && !match->second.empty();
 }
 
-auto Build::write_dependencies(
-    const std::function<bool(const std::filesystem::path &)> &filter) -> void {
+auto Build::finish() -> void {
   const auto deps_path{this->root / DEPENDENCIES_FILE};
   std::ofstream stream{deps_path};
   assert(!stream.fail());
 
   std::shared_lock dependencies_lock{this->dependencies_mutex};
   for (const auto &entry : this->dependencies_map) {
-    if (!filter(this->root / entry.first)) {
+    if (this->is_untracked_file(this->root / entry.first)) {
       continue;
     }
 
@@ -156,6 +163,13 @@ auto Build::write_dependencies(
 
   stream.flush();
   stream.close();
+  this->track(deps_path);
+
+  for (const auto &entry : this->tracker) {
+    if (!entry.second) {
+      std::filesystem::remove_all(entry.first);
+    }
+  }
 }
 
 auto Build::refresh(const std::filesystem::path &path) -> void {
@@ -198,4 +212,53 @@ auto Build::mark(const std::filesystem::path &path)
   }
 }
 
+auto Build::track(const std::filesystem::path &path)
+    -> const std::filesystem::path & {
+  assert(path.is_absolute());
+  assert(std::filesystem::exists(path));
+  std::unique_lock lock{this->tracker_mutex};
+  assert(!this->tracker.contains(path) || !this->tracker.at(path));
+  const auto &result{this->tracker.insert_or_assign(path, true).first->first};
+  for (auto current = path; !current.empty() && current != this->root;
+       current = current.parent_path()) {
+    this->tracker.insert_or_assign(current, true);
+  }
+
+  return result;
+}
+
+auto Build::is_untracked_file(const std::filesystem::path &path) const -> bool {
+  std::shared_lock lock{this->tracker_mutex};
+  const auto match{this->tracker.find(path)};
+  return match == this->tracker.cend() || !match->second;
+}
+
+auto Build::output_write_json(const std::filesystem::path &path,
+                              const sourcemeta::core::JSON &document)
+    -> const std::filesystem::path & {
+  assert(path.is_absolute());
+  std::filesystem::create_directories(path.parent_path());
+  std::ofstream stream{path};
+  assert(!stream.fail());
+  sourcemeta::core::stringify(document, stream);
+  return this->track(path);
+}
+
+auto Build::write_json_if_different(const std::filesystem::path &path,
+                                    const sourcemeta::core::JSON &document)
+    -> void {
+  if (std::filesystem::exists(path)) {
+    const auto current{sourcemeta::core::read_json(path)};
+    if (current != document) {
+      this->output_write_json(path, document);
+      this->refresh(path);
+    } else {
+      this->track(path);
+    }
+  } else {
+    this->output_write_json(path, document);
+    this->refresh(path);
+  }
+}
+
 } // namespace sourcemeta::one

src/build/include/sourcemeta/one/build.h

@@ -5,6 +5,8 @@
 #include <sourcemeta/one/build_export.h>
 #endif
 
+#include <sourcemeta/core/json.h>
+
 #include <algorithm>     // std::ranges::none_of
 #include <cassert>       // assert
 #include <cstdint>       // std::uint8_t
@@ -38,13 +40,14 @@ class SOURCEMETA_ONE_BUILD_EXPORT Build {
 
   Build(const std::filesystem::path &output_root);
 
+  auto path() const -> const std::filesystem::path & { return this->root; }
+
   static auto dependency(std::filesystem::path node)
       -> std::pair<DependencyKind, std::filesystem::path>;
 
   [[nodiscard]] auto has_dependencies(const std::filesystem::path &path) const
       -> bool;
-  auto write_dependencies(
-      const std::function<bool(const std::filesystem::path &)> &filter) -> void;
+  auto finish() -> void;
   auto refresh(const std::filesystem::path &path) -> void;
   [[nodiscard]] auto mark(const std::filesystem::path &path)
       -> std::optional<mark_type>;
@@ -88,6 +91,7 @@ class SOURCEMETA_ONE_BUILD_EXPORT Build {
                 return !dependency_mark.has_value() ||
                        dependency_mark.value() > destination_mark.value();
               })) {
+        this->track(destination);
         return false;
       }
     }
@@ -113,6 +117,7 @@ class SOURCEMETA_ONE_BUILD_EXPORT Build {
     assert(destination.is_absolute());
     assert(std::filesystem::exists(destination));
     this->refresh(destination);
+    this->track(destination);
     const auto key{destination.lexically_relative(this->root).string()};
     {
       std::unique_lock lock{this->dependencies_mutex};
@@ -123,13 +128,27 @@ class SOURCEMETA_ONE_BUILD_EXPORT Build {
     return true;
   }
 
+  auto track(const std::filesystem::path &path)
+      -> const std::filesystem::path &;
+  [[nodiscard]] auto is_untracked_file(const std::filesystem::path &path) const
+      -> bool;
+
+  auto write_json_if_different(const std::filesystem::path &path,
+                               const sourcemeta::core::JSON &document) -> void;
+
 private:
+  auto output_write_json(const std::filesystem::path &path,
+                         const sourcemeta::core::JSON &document)
+      -> const std::filesystem::path &;
+
   std::filesystem::path root;
   std::unordered_map<std::filesystem::path, mark_type> marks;
   std::shared_mutex mutex;
   std::unordered_map<std::string, Dependencies> dependencies_map;
   mutable std::shared_mutex dependencies_mutex;
   bool has_previous_run{false};
+  std::unordered_map<std::filesystem::path, bool> tracker;
+  mutable std::shared_mutex tracker_mutex;
 };
 
 } // namespace sourcemeta::one

src/index/CMakeLists.txt

@@ -1,6 +1,6 @@
 sourcemeta_executable(NAMESPACE sourcemeta PROJECT one NAME index
   FOLDER "One/Index"
-  SOURCES index.cc output.h generators.h explorer.h)
+  SOURCES index.cc generators.h explorer.h)
 
 set_target_properties(sourcemeta_one_index PROPERTIES OUTPUT_NAME sourcemeta-one-index)
 

src/index/explorer.h

@@ -8,7 +8,7 @@
 #include <sourcemeta/core/json.h>
 #include <sourcemeta/core/jsonschema.h>
 
-#include "output.h"
+#include <sourcemeta/one/build.h>
 
 #include <algorithm>  // std::sort
 #include <cassert>    // assert
@@ -283,7 +283,7 @@ struct GENERATE_EXPLORER_DIRECTORY_LIST {
   struct Context {
     const std::filesystem::path &directory;
     const sourcemeta::one::Configuration &configuration;
-    const sourcemeta::one::Output &output;
+    const sourcemeta::one::Build &output;
     const std::filesystem::path &explorer_path;
     const std::filesystem::path &schemas_path;
   };