fix zip tests

Author: andiwand

src/odr/internal/cfb/cfb_util.hpp

@@ -84,8 +84,6 @@ class Archive final : public std::enable_shared_from_this<Archive> {
     using reference = const Entry &;
 
     Iterator() = default;
-    Iterator(const Iterator &) = default;
-    Iterator(Iterator &&) noexcept = default;
     Iterator(const Archive &parent, const impl::CompoundFileEntry &entry)
         : m_entry{Entry(parent, entry)} {
       dig_left_();
@@ -95,19 +93,13 @@ class Archive final : public std::enable_shared_from_this<Archive> {
         : m_entry{Entry(parent, entry, parent_path)} {
       dig_left_();
     }
-    ~Iterator() = default;
-    Iterator &operator=(const Iterator &) = default;
-    Iterator &operator=(Iterator &&) noexcept = default;
 
     [[nodiscard]] reference operator*() const { return *m_entry; }
     [[nodiscard]] pointer operator->() const { return &*m_entry; }
 
     [[nodiscard]] bool operator==(const Iterator &other) const {
       return m_entry == other.m_entry;
     }
-    [[nodiscard]] bool operator!=(const Iterator &other) const {
-      return m_entry != other.m_entry;
-    }
 
     Iterator &operator++() {
       next_();

src/odr/internal/common/path.cpp

@@ -158,6 +158,13 @@ AbsPath Path::make_absolute() const {
   return AbsPath("/" + m_path);
 }
 
+RelPath Path::make_relative() const {
+  if (!m_absolute) {
+    return RelPath(*this);
+  }
+  return RelPath(m_path.substr(1));
+}
+
 std::string Path::basename() const noexcept {
   const auto find = m_path.rfind('/');
   if (find == std::string::npos) {

src/odr/internal/common/path.hpp

@@ -44,6 +44,7 @@ class Path {
   [[nodiscard]] RelPath as_relative() &&;
 
   [[nodiscard]] AbsPath make_absolute() const;
+  [[nodiscard]] RelPath make_relative() const;
 
   [[nodiscard]] std::string basename() const noexcept;
   [[nodiscard]] std::string extension() const noexcept;

src/odr/internal/odf/odf_document.cpp

@@ -44,29 +44,30 @@ void Document::save(const Path &path) const {
 
   // `mimetype` has to be the first file and uncompressed
   if (m_filesystem->is_file(AbsPath("/mimetype"))) {
-    archive.insert_file(std::end(archive), AbsPath("/mimetype"),
+    archive.insert_file(std::end(archive), RelPath("mimetype"),
                         m_filesystem->open(AbsPath("/mimetype")), 0);
   }
 
   for (auto walker = m_filesystem->file_walker(AbsPath("/")); !walker->end();
        walker->next()) {
-    auto p = walker->path();
-    if (p == Path("/mimetype")) {
+    const AbsPath &abs_path = walker->path();
+    RelPath rel_path = abs_path.rebase(AbsPath("/"));
+    if (abs_path == Path("/mimetype")) {
       continue;
     }
-    if (m_filesystem->is_directory(p)) {
-      archive.insert_directory(std::end(archive), p);
+    if (walker->is_directory()) {
+      archive.insert_directory(std::end(archive), rel_path);
       continue;
     }
-    if (p == Path("/content.xml")) {
+    if (abs_path == Path("/content.xml")) {
       // TODO stream
       std::stringstream out;
       m_content_xml.print(out, "", pugi::format_raw);
       auto tmp = std::make_shared<MemoryFile>(out.str());
-      archive.insert_file(std::end(archive), p, tmp);
+      archive.insert_file(std::end(archive), rel_path, tmp);
       continue;
     }
-    if (p == Path("/META-INF/manifest.xml")) {
+    if (abs_path == Path("/META-INF/manifest.xml")) {
       // TODO
       auto manifest =
           util::xml::parse(*m_filesystem, AbsPath("/META-INF/manifest.xml"));
@@ -78,11 +79,12 @@ void Document::save(const Path &path) const {
       std::stringstream out;
       manifest.print(out, "", pugi::format_raw);
       auto tmp = std::make_shared<MemoryFile>(out.str());
-      archive.insert_file(std::end(archive), p, tmp);
+      archive.insert_file(std::end(archive), rel_path, tmp);
 
       continue;
     }
-    archive.insert_file(std::end(archive), p, m_filesystem->open(p));
+    archive.insert_file(std::end(archive), rel_path,
+                        m_filesystem->open(abs_path));
   }
 
   std::ofstream ostream = util::file::create(path.string());

src/odr/internal/ooxml/text/ooxml_text_document.cpp

@@ -43,20 +43,22 @@ void Document::save(const Path &path) const {
 
   for (auto walker = m_filesystem->file_walker(AbsPath("/")); !walker->end();
        walker->next()) {
-    auto p = walker->path();
-    if (m_filesystem->is_directory(p)) {
-      archive.insert_directory(std::end(archive), p);
+    const AbsPath &abs_path = walker->path();
+    RelPath rel_path = walker->path().rebase(AbsPath("/"));
+    if (walker->is_directory()) {
+      archive.insert_directory(std::end(archive), rel_path);
       continue;
     }
-    if (p == Path("/word/document.xml")) {
+    if (abs_path == AbsPath("/word/document.xml")) {
       // TODO stream
       std::stringstream out;
       m_document_xml.print(out, "", pugi::format_raw);
       auto tmp = std::make_shared<MemoryFile>(out.str());
-      archive.insert_file(std::end(archive), p, tmp);
+      archive.insert_file(std::end(archive), rel_path, tmp);
       continue;
     }
-    archive.insert_file(std::end(archive), p, m_filesystem->open(p));
+    archive.insert_file(std::end(archive), rel_path,
+                        m_filesystem->open(abs_path));
   }
 
   std::ofstream ostream = util::file::create(path.string());

src/odr/internal/zip/zip_archive.cpp

@@ -14,16 +14,16 @@
 
 namespace odr::internal::zip {
 
-ZipArchive::Entry::Entry(Path path, std::shared_ptr<abstract::File> file,
+ZipArchive::Entry::Entry(RelPath path, std::shared_ptr<abstract::File> file,
                          std::uint32_t compression_level)
     : m_path{std::move(path)}, m_file{std::move(file)},
       m_compression_level{compression_level} {}
 
-bool ZipArchive::Entry::is_file() const { return m_file.operator bool(); }
+bool ZipArchive::Entry::is_file() const { return m_file != nullptr; }
 
-bool ZipArchive::Entry::is_directory() const { return !m_file; }
+bool ZipArchive::Entry::is_directory() const { return m_file == nullptr; }
 
-Path ZipArchive::Entry::path() const { return m_path; }
+const RelPath &ZipArchive::Entry::path() const { return m_path; }
 
 std::shared_ptr<abstract::File> ZipArchive::Entry::file() const {
   return m_file;
@@ -41,14 +41,15 @@ ZipArchive::ZipArchive() = default;
 
 ZipArchive::ZipArchive(const std::shared_ptr<util::Archive> &archive) {
   for (auto &&entry : *archive) {
+    RelPath path(entry.path());
     if (entry.is_file()) {
       std::uint8_t compression_level = 6;
       if (entry.method() == util::Method::STORED) {
         compression_level = 0;
       }
-      insert_file(end(), entry.path(), entry.file(), compression_level);
+      insert_file(end(), std::move(path), entry.file(), compression_level);
     } else if (entry.is_directory()) {
-      insert_directory(end(), entry.path());
+      insert_directory(end(), std::move(path));
     }
   }
 }
@@ -58,7 +59,7 @@ std::shared_ptr<abstract::Filesystem> ZipArchive::as_filesystem() const {
   auto filesystem = std::make_shared<VirtualFilesystem>();
 
   for (const auto &e : *this) {
-    AbsPath path = e.path().make_absolute();
+    AbsPath path = Path(e.path()).make_absolute();
 
     if (e.is_directory()) {
       filesystem->create_directory(path);
@@ -80,7 +81,8 @@ void ZipArchive::save(std::ostream &out) const {
   archive.m_pWrite = [](void *opaque, std::uint64_t /*offset*/,
                         const void *buffer, std::size_t size) {
     auto out = static_cast<std::ostream *>(opaque);
-    out->write(static_cast<const char *>(buffer), size);
+    out->write(static_cast<const char *>(buffer),
+               static_cast<std::streamsize>(size));
     return size;
   };
   state = mz_zip_writer_init(&archive, 0);
@@ -89,7 +91,7 @@ void ZipArchive::save(std::ostream &out) const {
   }
 
   for (auto &&entry : *this) {
-    auto path = entry.path().make_absolute();
+    RelPath path = entry.path().make_relative();
 
     if (entry.is_file()) {
       auto file = entry.file();
@@ -128,7 +130,7 @@ ZipArchive::Iterator ZipArchive::begin() const {
 
 ZipArchive::Iterator ZipArchive::end() const { return std::cend(m_entries); }
 
-ZipArchive::Iterator ZipArchive::find(const Path &path) const {
+ZipArchive::Iterator ZipArchive::find(const RelPath &path) const {
   for (auto it = begin(); it != end(); ++it) {
     if (it->path() == path) {
       return it;
@@ -139,15 +141,15 @@ ZipArchive::Iterator ZipArchive::find(const Path &path) const {
 }
 
 ZipArchive::Iterator
-ZipArchive::insert_file(Iterator at, Path path,
+ZipArchive::insert_file(Iterator at, RelPath path,
                         std::shared_ptr<abstract::File> file,
                         std::uint32_t compression_level) {
   return m_entries.insert(
       at,
       ZipArchive::Entry(std::move(path), std::move(file), compression_level));
 }
 
-ZipArchive::Iterator ZipArchive::insert_directory(Iterator at, Path path) {
+ZipArchive::Iterator ZipArchive::insert_directory(Iterator at, RelPath path) {
   return m_entries.insert(at, ZipArchive::Entry(std::move(path), nullptr, 0));
 }
 

src/odr/internal/zip/zip_archive.hpp

@@ -40,28 +40,28 @@ class ZipArchive final : public abstract::Archive {
   [[nodiscard]] Iterator begin() const;
   [[nodiscard]] Iterator end() const;
 
-  [[nodiscard]] Iterator find(const Path &path) const;
+  [[nodiscard]] Iterator find(const RelPath &path) const;
 
-  Iterator insert_file(Iterator at, Path path,
+  Iterator insert_file(Iterator at, RelPath path,
                        std::shared_ptr<abstract::File> file,
                        std::uint32_t compression_level = 6);
-  Iterator insert_directory(Iterator at, Path path);
+  Iterator insert_directory(Iterator at, RelPath path);
 
   class Entry {
   public:
-    Entry(Path path, std::shared_ptr<abstract::File> file,
+    Entry(RelPath path, std::shared_ptr<abstract::File> file,
           std::uint32_t compression_level);
 
     [[nodiscard]] bool is_file() const;
     [[nodiscard]] bool is_directory() const;
-    [[nodiscard]] Path path() const;
+    [[nodiscard]] const RelPath &path() const;
     [[nodiscard]] std::shared_ptr<abstract::File> file() const;
     [[nodiscard]] std::uint32_t compression_level() const;
 
     void file(std::shared_ptr<abstract::File> file);
 
   private:
-    Path m_path;
+    RelPath m_path;
     std::shared_ptr<abstract::File> m_file;
     std::uint32_t m_compression_level{6};
 

src/odr/internal/zip/zip_util.cpp

@@ -145,12 +145,12 @@ bool Archive::Entry::is_directory() const {
   return mz_zip_reader_is_file_a_directory(m_archive->zip(), m_index);
 }
 
-Path Archive::Entry::path() const {
+RelPath Archive::Entry::path() const {
   std::lock_guard lock(m_archive->mutex());
   char filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
   mz_zip_reader_get_filename(m_archive->zip(), m_index, filename,
                              MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE);
-  return Path(filename).make_absolute();
+  return RelPath(filename);
 }
 
 Method Archive::Entry::method() const {
@@ -208,7 +208,7 @@ Archive::Iterator Archive::end() const {
   return {*this, mz_zip_reader_get_num_files(&m_zip)};
 }
 
-Archive::Iterator Archive::find(const Path &path) const {
+Archive::Iterator Archive::find(const RelPath &path) const {
   return std::find_if(begin(), end(), [&path](const Entry &entry) {
     return entry.path() == path;
   });
@@ -224,8 +224,8 @@ void util::open_from_file(mz_zip_archive &archive, const abstract::File &file,
   archive.m_pRead = [](void *opaque, std::uint64_t offset, void *buffer,
                        std::size_t size) {
     auto in = static_cast<std::istream *>(opaque);
-    in->seekg(offset);
-    in->read(static_cast<char *>(buffer), size);
+    in->seekg(static_cast<std::streamsize>(offset));
+    in->read(static_cast<char *>(buffer), static_cast<std::streamsize>(size));
     return size;
   };
   const bool state = mz_zip_reader_init(
@@ -242,7 +242,8 @@ bool util::append_file(mz_zip_archive &archive, const std::string &path,
   auto read_callback = [](void *opaque, std::uint64_t /*offset*/, void *buffer,
                           std::size_t size) -> std::size_t {
     auto istream = static_cast<std::istream *>(opaque);
-    istream->read(static_cast<char *>(buffer), size);
+    istream->read(static_cast<char *>(buffer),
+                  static_cast<std::streamsize>(size));
     return istream->gcount();
   };
 

src/odr/internal/zip/zip_util.hpp

@@ -15,7 +15,7 @@
 #include <miniz/miniz_zip.h>
 
 namespace odr::internal {
-class Path;
+class RelPath;
 class MemoryFile;
 class DiskFile;
 } // namespace odr::internal
@@ -44,7 +44,7 @@ class Archive final : public std::enable_shared_from_this<Archive> {
   [[nodiscard]] Iterator begin() const;
   [[nodiscard]] Iterator end() const;
 
-  [[nodiscard]] Iterator find(const Path &path) const;
+  [[nodiscard]] Iterator find(const RelPath &path) const;
 
   class Entry {
   public:
@@ -59,13 +59,10 @@ class Archive final : public std::enable_shared_from_this<Archive> {
     [[nodiscard]] bool operator==(const Entry &other) const {
       return m_index == other.m_index;
     }
-    [[nodiscard]] bool operator!=(const Entry &other) const {
-      return m_index != other.m_index;
-    }
 
     [[nodiscard]] bool is_file() const;
     [[nodiscard]] bool is_directory() const;
-    [[nodiscard]] Path path() const;
+    [[nodiscard]] RelPath path() const;
     [[nodiscard]] Method method() const;
     [[nodiscard]] std::shared_ptr<abstract::File> file() const;
 
@@ -84,22 +81,14 @@ class Archive final : public std::enable_shared_from_this<Archive> {
     using pointer = const Entry *;
     using reference = const Entry &;
 
-    Iterator(const Iterator &) = default;
-    Iterator(Iterator &&) noexcept = default;
     Iterator(const Archive &zip, std::uint32_t index) : m_entry{zip, index} {}
-    ~Iterator() = default;
-    Iterator &operator=(const Iterator &) = default;
-    Iterator &operator=(Iterator &&) noexcept = default;
 
     [[nodiscard]] reference operator*() const { return m_entry; }
     [[nodiscard]] pointer operator->() const { return &m_entry; }
 
     [[nodiscard]] bool operator==(const Iterator &other) const {
       return m_entry == other.m_entry;
     }
-    [[nodiscard]] bool operator!=(const Iterator &other) const {
-      return m_entry != other.m_entry;
-    }
 
     Iterator &operator++() {
       m_entry.m_index++;

test/src/internal/cfb/cfb_archive_test.cpp

@@ -30,6 +30,6 @@ TEST(CfbArchive, open_encrypted_docx) {
   util::Archive cfb(std::make_shared<MemoryFile>(
       DiskFile(TestData::test_file_path("odr-public/docx/encrypted.docx"))));
 
-  EXPECT_TRUE(cfb.find(AbsPath("Encryption")) == std::end(cfb));
+  EXPECT_TRUE(cfb.find(AbsPath("/Encryption")) == std::end(cfb));
   EXPECT_TRUE(cfb.find(AbsPath("/EncryptionInfo")) != std::end(cfb));
 }