Html views (#412)

Author: andiwand

cli/src/server.cpp

@@ -40,13 +40,16 @@ int main(int argc, char **argv) {
   HtmlConfig html_config;
   html_config.embed_images = false;
   html_config.embed_shipped_resources = false;
+  html_config.relative_resource_paths = false;
 
   {
     std::string prefix = "one_file";
-    server.serve_file(decoded_file, prefix, html_config);
+    HtmlViews views = server.serve_file(decoded_file, prefix, html_config);
     std::cout << "hosted decoded file with id: " << prefix << std::endl;
-    std::cout << "http://localhost:8080/file/" << prefix << "/document.html"
-              << std::endl;
+    for (const auto &view : views) {
+      std::cout << "http://localhost:8080/file/" << prefix << "/" << view.path()
+                << std::endl;
+    }
   }
 
   server.listen("localhost", 8080);

src/odr/html_service.cpp

@@ -18,6 +18,10 @@ const HtmlResourceLocator &HtmlService::resource_locator() const {
   return m_impl->resource_locator();
 }
 
+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 {
@@ -43,6 +47,26 @@ 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);
+}
+
+const std::shared_ptr<internal::abstract::HtmlView> &HtmlView::impl() const {
+  return m_impl;
+}
+
 HtmlResource::HtmlResource() = default;
 
 HtmlResource::HtmlResource(

src/odr/html_service.hpp

@@ -9,6 +9,7 @@
 
 namespace odr::internal::abstract {
 class HtmlService;
+class HtmlView;
 class HtmlResource;
 } // namespace odr::internal::abstract
 
@@ -17,6 +18,7 @@ enum class FileType;
 class File;
 struct HtmlConfig;
 
+class HtmlView;
 class HtmlResource;
 
 enum class HtmlResourceType {
@@ -27,6 +29,7 @@ enum class HtmlResourceType {
   font,
 };
 
+using HtmlViews = std::vector<HtmlView>;
 using HtmlResourceLocation = std::optional<std::string>;
 using HtmlResourceLocator =
     std::function<HtmlResourceLocation(const HtmlResource &resource)>;
@@ -40,11 +43,11 @@ class HtmlService final {
 
   [[nodiscard]] const HtmlConfig &config() const;
   [[nodiscard]] const HtmlResourceLocator &resource_locator() 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;
@@ -57,6 +60,24 @@ class HtmlService final {
   std::shared_ptr<internal::abstract::HtmlService> m_impl;
 };
 
+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]] const std::shared_ptr<internal::abstract::HtmlView> &
+  impl() const;
+
+private:
+  std::shared_ptr<internal::abstract::HtmlView> m_impl;
+};
+
 class HtmlResource final {
 public:
   HtmlResource();

src/odr/http_server.cpp

@@ -4,7 +4,6 @@
 #include <odr/file.hpp>
 #include <odr/filesystem.hpp>
 #include <odr/html.hpp>
-#include <odr/html_service.hpp>
 #include <odr/internal/html/document.hpp>
 #include <odr/internal/html/pdf2htmlex_wrapper.hpp>
 #include <odr/internal/pdf_poppler/poppler_pdf_file.hpp>
@@ -99,8 +98,8 @@ void HttpServer::connect_service(HtmlService service,
   m_impl->connect_service(std::move(service), prefix);
 }
 
-void HttpServer::serve_file(DecodedFile file, const std::string &prefix,
-                            const HtmlConfig &config) {
+HtmlViews HttpServer::serve_file(DecodedFile file, const std::string &prefix,
+                                 const HtmlConfig &config) {
   static std::regex prefix_regex(prefix_pattern);
   if (!std::regex_match(prefix, prefix_regex)) {
     throw InvalidPrefix(prefix);
@@ -128,7 +127,9 @@ void HttpServer::serve_file(DecodedFile file, const std::string &prefix,
     throw std::runtime_error("Unsupported file type.");
   }
 
-  m_impl->connect_service(std::move(service), prefix);
+  m_impl->connect_service(service, prefix);
+
+  return service.list_views();
 }
 
 void HttpServer::listen(const std::string &host, std::uint32_t port) {

src/odr/http_server.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <odr/html_service.hpp>
+
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -23,8 +25,8 @@ class HttpServer {
 
   void connect_service(HtmlService service, const std::string &prefix);
 
-  void serve_file(DecodedFile file, const std::string &prefix,
-                  const HtmlConfig &config);
+  HtmlViews serve_file(DecodedFile file, const std::string &prefix,
+                       const HtmlConfig &config);
 
   void listen(const std::string &host, std::uint32_t port);
 

src/odr/internal/abstract/html_service.hpp

@@ -21,18 +21,29 @@ class HtmlService {
 
   [[nodiscard]] virtual const HtmlConfig &config() const = 0;
   [[nodiscard]] virtual const HtmlResourceLocator &resource_locator() const = 0;
+  [[nodiscard]] virtual const HtmlViews &list_views() const = 0;
 
   virtual void warmup() const = 0;
 
   [[nodiscard]] virtual bool exists(const std::string &path) const = 0;
-
   [[nodiscard]] virtual std::string mimetype(const std::string &path) const = 0;
 
   virtual void write(const std::string &path, std::ostream &out) const = 0;
   virtual HtmlResources write_html(const std::string &path,
                                    html::HtmlWriter &out) const = 0;
 };
 
+class HtmlView {
+public:
+  virtual ~HtmlView() = default;
+
+  [[nodiscard]] virtual const std::string &name() const = 0;
+  [[nodiscard]] virtual const std::string &path() const = 0;
+  [[nodiscard]] virtual const HtmlConfig &config() const = 0;
+
+  virtual HtmlResources write_html(html::HtmlWriter &out) const = 0;
+};
+
 class HtmlResource {
 public:
   virtual ~HtmlResource() = default;

src/odr/internal/html/document.cpp

@@ -163,13 +163,41 @@ class HtmlFragmentBase {
   Document m_document;
 };
 
+class HtmlFragmentView final : public HtmlView {
+public:
+  HtmlFragmentView(const abstract::HtmlService &service, std::string name,
+                   std::string path, std::shared_ptr<HtmlFragmentBase> fragment)
+      : HtmlView(service, std::move(name), std::move(path)),
+        m_fragment{std::move(fragment)} {}
+
+  HtmlResources write_html(html::HtmlWriter &out) const final {
+    HtmlResources resources;
+    WritingState state(out, service().config(), service().resource_locator(),
+                       resources);
+    m_fragment->write_document(out, state);
+    return resources;
+  }
+
+private:
+  std::shared_ptr<HtmlFragmentBase> m_fragment;
+};
+
 class HtmlServiceImpl : public HtmlService {
 public:
   HtmlServiceImpl(Document document,
                   std::vector<std::shared_ptr<HtmlFragmentBase>> fragments,
                   HtmlConfig config, HtmlResourceLocator resource_locator)
       : HtmlService(std::move(config), std::move(resource_locator)),
-        m_document{std::move(document)}, m_fragments{std::move(fragments)} {}
+        m_document{std::move(document)}, m_fragments{std::move(fragments)} {
+    m_views.emplace_back(
+        std::make_shared<HtmlView>(*this, "document", "document.html"));
+    for (const auto &fragment : m_fragments) {
+      m_views.emplace_back(std::make_shared<HtmlFragmentView>(
+          *this, fragment->name(), fragment->name() + ".html", fragment));
+    }
+  }
+
+  const HtmlViews &list_views() const final { return m_views; }
 
   [[nodiscard]] Document document() const { return m_document; }
 
@@ -191,7 +219,9 @@ class HtmlServiceImpl : public HtmlService {
   }
 
   bool exists(const std::string &path) const final {
-    if (path == "document.html") {
+    if (std::ranges::any_of(m_views, [&path](const auto &view) {
+          return view.path() == path;
+        })) {
       return true;
     }
 
@@ -206,7 +236,9 @@ class HtmlServiceImpl : public HtmlService {
   }
 
   std::string mimetype(const std::string &path) const final {
-    if (path == "document.html") {
+    if (std::ranges::any_of(m_views, [&path](const auto &view) {
+          return view.path() == path;
+        })) {
       return "text/html";
     }
 
@@ -220,10 +252,12 @@ class HtmlServiceImpl : public HtmlService {
   }
 
   void write(const std::string &path, std::ostream &out) const final {
-    if (path == "document.html") {
-      HtmlWriter writer(out, config());
-      write_document(writer);
-      return;
+    for (const auto &view : m_views) {
+      if (view.path() == path) {
+        HtmlWriter writer(out, config());
+        write_html(path, writer);
+        return;
+      }
     }
 
     warmup();
@@ -244,6 +278,12 @@ class HtmlServiceImpl : public HtmlService {
       return write_document(out);
     }
 
+    for (const auto &view : m_views) {
+      if (view.path() == path) {
+        return view.impl()->write_html(out);
+      }
+    }
+
     throw FileNotFound("Unknown path: " + path);
   }
 
@@ -264,6 +304,9 @@ class HtmlServiceImpl : public HtmlService {
 protected:
   Document m_document;
   std::vector<std::shared_ptr<HtmlFragmentBase>> m_fragments;
+
+  HtmlViews m_views;
+
   mutable bool m_warm = false;
   mutable HtmlResources m_resources;
 };

src/odr/internal/html/html_service.cpp

@@ -18,6 +18,22 @@ const HtmlResourceLocator &HtmlService::resource_locator() const {
   return m_resource_locator;
 }
 
+HtmlView::HtmlView(const abstract::HtmlService &service, std::string name,
+                   std::string path)
+    : m_service{&service}, m_name{std::move(name)}, m_path{std::move(path)} {}
+
+const std::string &HtmlView::name() const { return m_name; }
+
+const std::string &HtmlView::path() const { return m_path; }
+
+const HtmlConfig &HtmlView::config() const { return m_service->config(); }
+
+const abstract::HtmlService &HtmlView::service() const { return *m_service; }
+
+HtmlResources HtmlView::write_html(html::HtmlWriter &out) const {
+  return m_service->write_html(path(), out);
+}
+
 odr::HtmlResource HtmlResource::create(HtmlResourceType type,
                                        std::string mime_type, std::string name,
                                        std::string path, odr::File file,

src/odr/internal/html/html_service.hpp

@@ -19,6 +19,24 @@ class HtmlService : public abstract::HtmlService {
   HtmlResourceLocator m_resource_locator;
 };
 
+class HtmlView : public abstract::HtmlView {
+public:
+  HtmlView(const abstract::HtmlService &service, std::string name,
+           std::string path);
+
+  [[nodiscard]] const std::string &name() const override;
+  [[nodiscard]] const std::string &path() const override;
+  [[nodiscard]] const HtmlConfig &config() const override;
+  [[nodiscard]] const abstract::HtmlService &service() const;
+
+  HtmlResources write_html(html::HtmlWriter &out) const override;
+
+private:
+  const abstract::HtmlService *m_service;
+  std::string m_name;
+  std::string m_path;
+};
+
 class HtmlResource : public abstract::HtmlResource {
 public:
   static odr::HtmlResource create(HtmlResourceType type, std::string mime_type,