merge html frontend headers (#429)

Author: andiwand

.github/workflows/build_test.yml

@@ -205,7 +205,7 @@ jobs:
         with:
           python-version: 3.12
       - name: install python dependencies
-        run: pip install htmlcmp==1.0.11
+        run: pip install htmlcmp==1.0.12
 
       - name: download binaries
         uses: actions/download-artifact@v4

CMakeLists.txt

@@ -81,7 +81,6 @@ set(ODR_SOURCE_FILES
         "src/odr/filesystem.cpp"
         "src/odr/global_params.cpp"
         "src/odr/html.cpp"
-        "src/odr/html_service.cpp"
         "src/odr/http_server.cpp"
         "src/odr/odr.cpp"
         "src/odr/quantity.cpp"

cli/src/translate.cpp

@@ -1,7 +1,6 @@
 #include <odr/exceptions.hpp>
 #include <odr/file.hpp>
 #include <odr/html.hpp>
-#include <odr/html_service.hpp>
 
 #include <filesystem>
 #include <iostream>

src/odr/html.cpp

@@ -6,26 +6,52 @@
 #include <odr/exceptions.hpp>
 #include <odr/filesystem.hpp>
 #include <odr/global_params.hpp>
-#include <odr/html_service.hpp>
 
+#include <odr/internal/abstract/html_service.hpp>
+#include <odr/internal/common/path.hpp>
 #include <odr/internal/html/document.hpp>
 #include <odr/internal/html/filesystem.hpp>
+#include <odr/internal/html/html_writer.hpp>
 #include <odr/internal/html/image_file.hpp>
 #include <odr/internal/html/pdf2htmlex_wrapper.hpp>
 #include <odr/internal/html/pdf_file.hpp>
 #include <odr/internal/html/text_file.hpp>
 #include <odr/internal/html/wvware_wrapper.hpp>
 #include <odr/internal/oldms_wvware/wvware_oldms_file.hpp>
 #include <odr/internal/pdf_poppler/poppler_pdf_file.hpp>
+#include <odr/internal/util/file_util.hpp>
 
+#include <algorithm>
 #include <filesystem>
+#include <fstream>
+#include <iostream>
 
 #include <nlohmann/json.hpp>
 
 using namespace odr::internal;
 
 namespace odr {
 
+namespace {
+
+void bring_offline(const HtmlResources &resources,
+                   const std::string &output_path) {
+  for (const auto &[resource, location] : resources) {
+    if (!location.has_value() || resource.is_shipped() ||
+        resource.is_external() || !resource.is_accessible()) {
+      continue;
+    }
+    auto path = odr::internal::common::Path(output_path)
+                    .join(odr::internal::common::Path(*location));
+
+    std::filesystem::create_directories(path.parent());
+    std::ofstream ostream = internal::util::file::create(path.string());
+    resource.write_resource(ostream);
+  }
+}
+
+} // namespace
+
 HtmlConfig::HtmlConfig() { init(); }
 
 HtmlConfig::HtmlConfig(std::string output_path_)
@@ -48,6 +74,144 @@ const std::vector<HtmlPage> &Html::pages() const { return m_pages; }
 HtmlPage::HtmlPage(std::string name, std::string path)
     : name{std::move(name)}, path{std::move(path)} {}
 
+HtmlService::HtmlService() = default;
+
+HtmlService::HtmlService(std::shared_ptr<internal::abstract::HtmlService> impl)
+    : m_impl{std::move(impl)} {}
+
+const HtmlConfig &HtmlService::config() const { return m_impl->config(); }
+
+const HtmlViews &HtmlService::list_views() const {
+  return m_impl->list_views();
+}
+
+void HtmlService::warmup() const { m_impl->warmup(); }
+
+bool HtmlService::exists(const std::string &path) const {
+  return m_impl->exists(path);
+}
+
+std::string HtmlService::mimetype(const std::string &path) const {
+  return m_impl->mimetype(path);
+}
+
+void HtmlService::write(const std::string &path, std::ostream &out) const {
+  m_impl->write(path, out);
+}
+
+HtmlResources HtmlService::write_html(const std::string &path,
+                                      std::ostream &out) const {
+  internal::html::HtmlWriter writer(out, config());
+  return m_impl->write_html(path, writer);
+}
+
+Html HtmlService::bring_offline(const std::string &output_path) const {
+  return bring_offline(output_path, list_views());
+}
+
+Html HtmlService::bring_offline(const std::string &output_path,
+                                const std::vector<HtmlView> &views) const {
+  std::vector<HtmlPage> pages;
+
+  HtmlResources resources;
+
+  for (const auto &view : views) {
+    auto path = odr::internal::common::Path(output_path)
+                    .join(odr::internal::common::Path(view.path()));
+
+    std::filesystem::create_directories(path.parent());
+    std::ofstream ostream = internal::util::file::create(path.string());
+    HtmlResources view_resources = view.write_html(ostream);
+
+    resources.insert(resources.end(), view_resources.begin(),
+                     view_resources.end());
+
+    pages.emplace_back(view.name(), path.string());
+  }
+
+  {
+    auto it = std::unique(resources.begin(), resources.end(),
+                          [](const auto &lhs, const auto &rhs) {
+                            return lhs.first.path() == rhs.first.path();
+                          });
+    resources.erase(it, resources.end());
+  }
+
+  odr::bring_offline(resources, output_path);
+
+  return {config(), std::move(pages)};
+}
+
+const std::shared_ptr<internal::abstract::HtmlService> &
+HtmlService::impl() const {
+  return m_impl;
+}
+
+HtmlView::HtmlView() = default;
+
+HtmlView::HtmlView(std::shared_ptr<internal::abstract::HtmlView> impl)
+    : m_impl{std::move(impl)} {}
+
+const std::string &HtmlView::name() const { return m_impl->name(); }
+
+const std::string &HtmlView::path() const { return m_impl->path(); }
+
+const HtmlConfig &HtmlView::config() const { return m_impl->config(); }
+
+HtmlResources HtmlView::write_html(std::ostream &out) const {
+  internal::html::HtmlWriter writer(out, config());
+  return m_impl->write_html(writer);
+}
+
+Html HtmlView::bring_offline(const std::string &output_path) const {
+  HtmlResources resources;
+
+  auto path = odr::internal::common::Path(output_path)
+                  .join(odr::internal::common::Path(this->path()));
+
+  {
+    std::filesystem::create_directories(path.parent());
+    std::ofstream ostream = internal::util::file::create(path.string());
+    resources = write_html(ostream);
+  }
+
+  odr::bring_offline(resources, output_path);
+
+  return {config(), {{name(), path.string()}}};
+}
+
+const std::shared_ptr<internal::abstract::HtmlView> &HtmlView::impl() const {
+  return m_impl;
+}
+
+HtmlResource::HtmlResource() = default;
+
+HtmlResource::HtmlResource(
+    std::shared_ptr<internal::abstract::HtmlResource> impl)
+    : m_impl{std::move(impl)} {}
+
+HtmlResourceType HtmlResource::type() const { return m_impl->type(); }
+
+const std::string &HtmlResource::mime_type() const {
+  return m_impl->mime_type();
+}
+
+const std::string &HtmlResource::name() const { return m_impl->name(); }
+
+const std::string &HtmlResource::path() const { return m_impl->path(); }
+
+const std::optional<File> &HtmlResource::file() const { return m_impl->file(); }
+
+bool HtmlResource::is_shipped() const { return m_impl->is_shipped(); }
+
+bool HtmlResource::is_external() const { return m_impl->is_external(); }
+
+bool HtmlResource::is_accessible() const { return m_impl->is_accessible(); }
+
+void HtmlResource::write_resource(std::ostream &os) const {
+  m_impl->write_resource(os);
+}
+
 HtmlService html::translate(const DecodedFile &decoded_file,
                             const std::string &output_path,
                             const HtmlConfig &config) {

src/odr/html.hpp

@@ -9,16 +9,51 @@
 #include <string>
 #include <vector>
 
+namespace odr::internal::abstract {
+class HtmlService;
+class HtmlView;
+class HtmlResource;
+} // namespace odr::internal::abstract
+
 namespace odr {
 class Archive;
 struct HtmlPage;
 class HtmlService;
-class HtmlResource;
 struct HtmlConfig;
 
+enum class HtmlResourceType {
+  html_fragment,
+  css,
+  js,
+  image,
+  font,
+};
+
+class HtmlResource final {
+public:
+  HtmlResource();
+  explicit HtmlResource(std::shared_ptr<internal::abstract::HtmlResource> impl);
+
+  [[nodiscard]] HtmlResourceType type() const;
+  [[nodiscard]] const std::string &mime_type() const;
+  [[nodiscard]] const std::string &name() const;
+  [[nodiscard]] const std::string &path() const;
+  [[nodiscard]] const std::optional<File> &file() const;
+  [[nodiscard]] bool is_shipped() const;
+  [[nodiscard]] bool is_external() const;
+  [[nodiscard]] bool is_accessible() const;
+
+  void write_resource(std::ostream &os) const;
+
+private:
+  std::shared_ptr<internal::abstract::HtmlResource> m_impl;
+};
+
 using HtmlResourceLocation = std::optional<std::string>;
 using HtmlResourceLocator = std::function<HtmlResourceLocation(
     const HtmlResource &resource, const HtmlConfig &config)>;
+using HtmlResources =
+    std::vector<std::pair<HtmlResource, HtmlResourceLocation>>;
 
 /// @brief HTML table gridlines.
 enum class HtmlTableGridlines {
@@ -96,6 +131,55 @@ struct HtmlPage final {
   HtmlPage(std::string name, std::string path);
 };
 
+class HtmlView final {
+public:
+  HtmlView();
+  explicit HtmlView(std::shared_ptr<internal::abstract::HtmlView> impl);
+
+  [[nodiscard]] const std::string &name() const;
+  [[nodiscard]] const std::string &path() const;
+  [[nodiscard]] const HtmlConfig &config() const;
+
+  HtmlResources write_html(std::ostream &out) const;
+
+  [[nodiscard]] Html bring_offline(const std::string &output_path) const;
+
+  [[nodiscard]] const std::shared_ptr<internal::abstract::HtmlView> &
+  impl() const;
+
+private:
+  std::shared_ptr<internal::abstract::HtmlView> m_impl;
+};
+
+using HtmlViews = std::vector<HtmlView>;
+
+class HtmlService final {
+public:
+  HtmlService();
+  explicit HtmlService(std::shared_ptr<internal::abstract::HtmlService> impl);
+
+  [[nodiscard]] const HtmlConfig &config() const;
+  [[nodiscard]] const HtmlViews &list_views() const;
+
+  void warmup() const;
+
+  [[nodiscard]] bool exists(const std::string &path) const;
+  [[nodiscard]] std::string mimetype(const std::string &path) const;
+
+  void write(const std::string &path, std::ostream &out) const;
+  HtmlResources write_html(const std::string &path, std::ostream &out) const;
+
+  [[nodiscard]] Html bring_offline(const std::string &output_path) const;
+  [[nodiscard]] Html bring_offline(const std::string &output_path,
+                                   const std::vector<HtmlView> &views) const;
+
+  [[nodiscard]] const std::shared_ptr<internal::abstract::HtmlService> &
+  impl() const;
+
+private:
+  std::shared_ptr<internal::abstract::HtmlService> m_impl;
+};
+
 namespace html {
 
 HtmlResourceLocator standard_resource_locator();