Add:isValidTitle function and unit testing

Author: kazuhidetonylee

.vscode/settings.json

@@ -0,0 +1,65 @@
+{
+  "files.associations": {
+    "string": "cpp",
+    "__bit_reference": "cpp",
+    "__bits": "cpp",
+    "__config": "cpp",
+    "__debug": "cpp",
+    "__errc": "cpp",
+    "__hash_table": "cpp",
+    "__locale": "cpp",
+    "__mutex_base": "cpp",
+    "__node_handle": "cpp",
+    "__split_buffer": "cpp",
+    "__threading_support": "cpp",
+    "__tree": "cpp",
+    "__tuple": "cpp",
+    "__verbose_abort": "cpp",
+    "array": "cpp",
+    "atomic": "cpp",
+    "bit": "cpp",
+    "bitset": "cpp",
+    "cctype": "cpp",
+    "clocale": "cpp",
+    "cmath": "cpp",
+    "cstdarg": "cpp",
+    "cstddef": "cpp",
+    "cstdint": "cpp",
+    "cstdio": "cpp",
+    "cstdlib": "cpp",
+    "cstring": "cpp",
+    "ctime": "cpp",
+    "cwchar": "cpp",
+    "cwctype": "cpp",
+    "exception": "cpp",
+    "initializer_list": "cpp",
+    "ios": "cpp",
+    "iosfwd": "cpp",
+    "iostream": "cpp",
+    "istream": "cpp",
+    "limits": "cpp",
+    "locale": "cpp",
+    "map": "cpp",
+    "memory": "cpp",
+    "mutex": "cpp",
+    "new": "cpp",
+    "optional": "cpp",
+    "ostream": "cpp",
+    "ratio": "cpp",
+    "sstream": "cpp",
+    "stdexcept": "cpp",
+    "streambuf": "cpp",
+    "string_view": "cpp",
+    "system_error": "cpp",
+    "tuple": "cpp",
+    "type_traits": "cpp",
+    "typeinfo": "cpp",
+    "unordered_map": "cpp",
+    "variant": "cpp",
+    "vector": "cpp",
+    "chrono": "cpp",
+    "compare": "cpp",
+    "algorithm": "cpp",
+    "regex": "cpp"
+  }
+}

src/zimwriterfs/zimcreatorfs.cpp

@@ -19,34 +19,34 @@
  */
 
 #include "zimcreatorfs.h"
-#include "../tools.h"
-#include "tools.h"
 
-#include <fstream>
 #include <dirent.h>
+#include <limits.h>
 #include <sys/stat.h>
-#include <regex>
 #include <unistd.h>
-#include <limits.h>
+
 #include <cassert>
+#include <fstream>
+#include <regex>
+
+#include "../tools.h"
+#include "tools.h"
 
-void parse_redirectArticles(std::istream& in_stream, redirect_handler handler) {
+void parse_redirectArticles(std::istream& in_stream, redirect_handler handler)
+{
   std::string line;
   int line_number = 1;
   while (std::getline(in_stream, line)) {
     std::regex line_regex("^([^\\t]+)\\t([^\\t]+)\\t([^\\t]+)$");
     std::smatch matches;
     if (!std::regex_search(line, matches, line_regex) || matches.size() != 4) {
-      throw std::runtime_error(
-        Formatter() << "Invalid line #" << line_number << " : '" << line << "'"
-      );
+      throw std::runtime_error(Formatter() << "Invalid line #" << line_number
+                                           << " : '" << line << "'");
     }
 
-    Redirect redirect = {
-      .path= matches[1].str(),
-      .title = matches[2].str(),
-      .target = matches[3].str()
-    };
+    Redirect redirect = {.path = matches[1].str(),
+                         .title = matches[2].str(),
+                         .target = matches[3].str()};
     handler(redirect);
     ++line_number;
   }
@@ -55,14 +55,14 @@ void parse_redirectArticles(std::istream& in_stream, redirect_handler handler) {
 bool isVerbose();
 
 ZimCreatorFS::ZimCreatorFS(std::string _directoryPath)
-  : directoryPath(_directoryPath)
+    : directoryPath(_directoryPath)
 {
   char buf[PATH_MAX];
 
   if (realpath(directoryPath.c_str(), buf) != buf) {
-    throw std::invalid_argument(
-          Formatter() << "Unable to canonicalize HTML directory path "
-                      << directoryPath << ": " << strerror(errno));
+    throw std::invalid_argument(Formatter()
+                                << "Unable to canonicalize HTML directory path "
+                                << directoryPath << ": " << strerror(errno));
   }
 
   canonical_basedir = buf;
@@ -74,17 +74,13 @@ void ZimCreatorFS::add_redirectArticles_from_file(const std::string& path)
 
   in_stream.open(path.c_str());
   try {
-    parse_redirectArticles(in_stream,
-      [this](Redirect redirect) {
-        this->addRedirection(
-          redirect.path,
-          redirect.title,
-          redirect.target,
-          {{zim::writer::HintKeys::FRONT_ARTICLE, 1}}
-        );
-      }
-    );
-  } catch(const std::runtime_error& e) {
+    parse_redirectArticles(in_stream, [this](Redirect redirect) {
+      this->addRedirection(redirect.path,
+                           redirect.title,
+                           redirect.target,
+                           {{zim::writer::HintKeys::FRONT_ARTICLE, 1}});
+    });
+  } catch (const std::runtime_error& e) {
     std::cerr << e.what() << "\nin redirect file " << path << std::endl;
     in_stream.close();
     exit(1);
@@ -171,14 +167,14 @@ void ZimCreatorFS::visitDirectory(const std::string& path)
 
 void ZimCreatorFS::addFile(const std::string& path)
 {
-  auto url = path.substr(directoryPath.size()+1);
+  auto url = path.substr(directoryPath.size() + 1);
   auto mimetype = getMimeTypeForFile(directoryPath, url);
   auto title = std::string{};
   zim::writer::Hints hints;
 
   std::shared_ptr<zim::writer::Item> item;
-  if ( mimetype.find("text/html") != std::string::npos
-    || mimetype.find("text/css") != std::string::npos) {
+  if (mimetype.find("text/html") != std::string::npos
+      || mimetype.find("text/css") != std::string::npos) {
     auto content = getFileContent(path);
 
     if (mimetype.find("text/html") != std::string::npos) {
@@ -193,14 +189,17 @@ void ZimCreatorFS::addFile(const std::string& path)
       adaptCss(content, url);
     }
 
-    item = zim::writer::StringItem::create(url, mimetype, title, hints, content);
+    item
+        = zim::writer::StringItem::create(url, mimetype, title, hints, content);
   } else {
-    item = std::make_shared<zim::writer::FileItem>(url, mimetype, title, hints, path);
+    item = std::make_shared<zim::writer::FileItem>(
+        url, mimetype, title, hints, path);
   }
   addItem(item);
 }
 
-void ZimCreatorFS::processSymlink(const std::string& curdir, const std::string& symlink_path)
+void ZimCreatorFS::processSymlink(const std::string& curdir,
+                                  const std::string& symlink_path)
 {
   /* #102 Links can be 3 different types:
    *  - dandling (not pointing to a valid file)
@@ -211,26 +210,28 @@ void ZimCreatorFS::processSymlink(const std::string& curdir, const std::string&
   if (realpath(symlink_path.c_str(), resolved) != resolved) {
     // looping symlinks also fall here: Too many levels of symbolic links
     // It also handles dangling symlink: No such file or directory
-    std::cerr << "Unable to resolve symlink " << symlink_path
-              << ": " << strerror(errno) << std::endl;
+    std::cerr << "Unable to resolve symlink " << symlink_path << ": "
+              << strerror(errno) << std::endl;
     return;
   }
 
   if (isDirectory(resolved)) {
-    std::cerr << "Skip symlink " << symlink_path
-              << ": points to a directory" << std::endl;
+    std::cerr << "Skip symlink " << symlink_path << ": points to a directory"
+              << std::endl;
     return;
   }
 
-  if (strncmp(canonical_basedir.c_str(), resolved, canonical_basedir.size()) != 0
+  if (strncmp(canonical_basedir.c_str(), resolved, canonical_basedir.size())
+          != 0
       || resolved[canonical_basedir.size()] != '/') {
     std::cerr << "Skip symlink " << symlink_path
               << ": points outside of HTML directory" << std::endl;
     return;
   }
 
   std::string source_url = symlink_path.substr(directoryPath.size() + 1);
-  std::string target_url = std::string(resolved).substr(canonical_basedir.size() + 1);
+  std::string target_url
+      = std::string(resolved).substr(canonical_basedir.size() + 1);
   addRedirection(source_url, "", target_url);
 }
 
@@ -256,11 +257,34 @@ inline std::string removeLocalTagAndParameters(const std::string& url)
 
 struct GumboOutputDestructor {
   GumboOutputDestructor(GumboOutput* output) : output(output) {}
-  ~GumboOutputDestructor() { gumbo_destroy_output(&kGumboDefaultOptions, output); }
+  ~GumboOutputDestructor()
+  {
+    gumbo_destroy_output(&kGumboDefaultOptions, output);
+  }
   GumboOutput* output;
 };
 
-std::string ZimCreatorFS::parseAndAdaptHtml(std::string& data, std::string& title, const std::string& url)
+inline bool isValidTitle(const std::string& title, size_t min_length)
+{
+  static const std::regex numeric_regex("[0-9]+");
+  static const std::regex alphanumeric_regex("[a-zA-Z0-9]");
+
+  /* 1. Ensure the title has at least 3 characters */
+  bool isLongEnough = title.length() >= min_length;
+
+  /* 2. Ensure the title is not only numeric */
+  bool isNotNumeric = !std::regex_match(title, numeric_regex);
+
+  /* 3. Ensure the title contains at least one alphanumeric character
+   * (not all special chars) */
+  bool hasAlphanumeric = std::regex_search(title, alphanumeric_regex);
+
+  return isLongEnough && isNotNumeric && hasAlphanumeric;
+}
+
+std::string ZimCreatorFS::parseAndAdaptHtml(std::string& data,
+                                            std::string& title,
+                                            const std::string& url)
 {
   GumboOutput* output = gumbo_parse(data.c_str());
   GumboOutputDestructor outputDestructor(output);
@@ -310,7 +334,8 @@ std::string ZimCreatorFS::parseAndAdaptHtml(std::string& data, std::string& titl
         auto redirectUrl = computeAbsolutePath(url, decodeUrl(targetUrl));
         auto redirectUrlPath = directoryPath + "/" + redirectUrl;
         if (!fileExists(redirectUrlPath)) {
-          throw std::runtime_error("'" + url + "' HTML redirection target path '"
+          throw std::runtime_error("'" + url
+                                   + "' HTML redirection target path '"
                                    + redirectUrlPath + "' doesn't exist.");
         }
         return redirectUrl;
@@ -331,29 +356,32 @@ std::string ZimCreatorFS::parseAndAdaptHtml(std::string& data, std::string& titl
         std::replace(title.begin(), title.end(), '_', ' ');
       }
     }
+    // Extra validation the title
+    if (!isValidTitle(title, 3)) {
+      std::cerr << "Warning: Generated title is invalid for URL: " << url
+                << std::endl;
+      title = "Unknown title";  // or some other default title
+    }
   }
   return "";
 }
 
-void ZimCreatorFS::adaptCss(std::string& data, const std::string& url) {
+void ZimCreatorFS::adaptCss(std::string& data, const std::string& url)
+{
   /* Rewrite url() values in the CSS */
   size_t startPos = 0;
   size_t endPos = 0;
   std::string targetUrl;
 
   while ((startPos = data.find("url(", endPos))
          && startPos != std::string::npos) {
-
     /* URL delimiters */
     endPos = data.find(")", startPos);
-    startPos = startPos + (data[startPos + 4] == '\''
-                                   || data[startPos + 4] == '"'
-                               ? 5
-                               : 4);
-    endPos = endPos - (data[endPos - 1] == '\''
-                               || data[endPos - 1] == '"'
-                           ? 1
-                           : 0);
+    startPos
+        = startPos
+          + (data[startPos + 4] == '\'' || data[startPos + 4] == '"' ? 5 : 4);
+    endPos = endPos
+             - (data[endPos - 1] == '\'' || data[endPos - 1] == '"' ? 1 : 0);
     targetUrl = data.substr(startPos, endPos - startPos);
     std::string startDelimiter = data.substr(startPos - 1, 1);
     std::string endDelimiter = data.substr(endPos, 1);
@@ -385,9 +413,9 @@ void ZimCreatorFS::adaptCss(std::string& data, const std::string& url) {
             data,
             startDelimiter + targetUrl + endDelimiter,
             startDelimiter + "data:" + mimeType + ";base64,"
-                + base64_encode(reinterpret_cast<const unsigned char*>(
-                                    fontContent.c_str()),
-                                fontContent.length())
+                + base64_encode(
+                    reinterpret_cast<const unsigned char*>(fontContent.c_str()),
+                    fontContent.length())
                 + endDelimiter);
       } catch (...) {
       }