archive_r_ruby 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcd3f5a0a9f170a6ee4a822bdd790801d91e4e2dfca60066af52d476c53cf33c
-  data.tar.gz: 653bd71f6ef6a36c977b7881f7954d9838745ac316e87534d6199ddde8f434c4
+  metadata.gz: a67077047d1881a2760f1e04788746c09f7476ac86543d0edf506446f3c95d27
+  data.tar.gz: 7c9c88796f1382285ff08cbcc2e61e59cbe517ef81d72eb7d41ef2c20ddb438a
 SHA512:
-  metadata.gz: af0d8b32e8823256e7b2f92ca7f1fe653890c77ada2c8a08829cb89d1ef285e93b6f85a30f43a52373c66b3417ae708654676816be3d1df627eaabfadc848b31
-  data.tar.gz: cca473ded868f07468f5b3dd59d6d7f737594af4f3470940ebed7287fbaaf33f173fbc167d2febfcc73eb4c836dd51b352c08558519f329e4cee8cd8604d77cf
+  metadata.gz: a5129e0027a2f4bd1d9bf99f98589f9713408deb0a3ebf207101af4ea25b371ee81396579396590e6b659187967a84fb967d9cbc5dae6cf167eeb3f4345b43ed
+  data.tar.gz: 118cb09083a9ca57fa4a90ad719a16178bcdd4d5f7926892f31c5849a9af0e40487dfe1d4f6bdaee61c684d942db3b3c43195fcee7d510ddcf0ed5b8f34a1f00

data/VERSION

@@ -0,0 +1 @@
+0.1.9

data/ext/archive_r/archive_r_ext.cc

@@ -15,13 +15,13 @@
 #ifdef memcpy
 #undef memcpy
 #endif
+#include <limits>
+#include <optional>
 #include <stdexcept>
 #include <string>
 #include <utility>
 #include <variant>
 #include <vector>
-#include <limits>
-#include <optional>
 
 using namespace archive_r;
 
@@ -295,16 +295,14 @@ static void stream_wrapper_free(void *ptr) {
   delete wrapper;
 }
 
-static size_t stream_wrapper_memsize(const void *ptr) {
-  return sizeof(RubyStreamWrapper);
-}
+static size_t stream_wrapper_memsize(const void *ptr) { return sizeof(RubyStreamWrapper); }
 
 static const rb_data_type_t stream_wrapper_type = {
   "ArchiveR::Stream",
   {
-    nullptr,
-    stream_wrapper_free,
-    stream_wrapper_memsize,
+      nullptr,
+      stream_wrapper_free,
+      stream_wrapper_memsize,
   },
   nullptr,
   nullptr,

data/ext/archive_r/vendor/archive_r/include/archive_r/data_stream.h

@@ -3,12 +3,12 @@
 
 #pragma once
 
-#include "archive_r/platform_compat.h"
 #include "archive_r/path_hierarchy.h"
+#include "archive_r/platform_compat.h"
 
+#include <cstdint>
 #include <functional>
 #include <memory>
-#include <cstdint>
 
 namespace archive_r {
 

data/ext/archive_r/vendor/archive_r/include/archive_r/entry.h

@@ -97,8 +97,8 @@ public:
   /**
    * @brief Read data from the entry
    *
-    * Each call uses an internal ArchiveStackOrchestrator so reads remain valid even
-    * if the owning iterator advances.
+   * Each call uses an internal ArchiveStackOrchestrator so reads remain valid even
+   * if the owning iterator advances.
    *
    * @param buffer Buffer to read data into
    * @param length Maximum number of bytes to read
@@ -109,9 +109,9 @@ public:
   /**
    * @brief Enable or disable automatic descent into this entry
    * @param enabled true to descend (default), false to keep traversal at current level
-    *
-    * This control is only available for entries that are managed by a Traverser.
-    * Calling this on an Entry that is not traverser-managed reports a fault.
+   *
+   * This control is only available for entries that are managed by a Traverser.
+   * Calling this on an Entry that is not traverser-managed reports a fault.
    */
   void set_descent(bool enabled);
 
@@ -139,9 +139,9 @@ public:
    *     }
    * }
    * @endcode
-  *
-  * This control is only available for entries that are managed by a Traverser.
-  * Calling this on an Entry that is not traverser-managed reports a fault.
+   *
+   * This control is only available for entries that are managed by a Traverser.
+   * Calling this on an Entry that is not traverser-managed reports a fault.
    */
   void set_multi_volume_group(const std::string &base_name, const MultiVolumeGroupOptions &options = {});
 

data/ext/archive_r/vendor/archive_r/include/archive_r/multi_volume_stream_base.h

@@ -30,8 +30,8 @@ protected:
   virtual void open_single_part(const PathHierarchy &single_part) = 0;
   virtual void close_single_part() = 0;
   virtual ssize_t read_from_single_part(void *buffer, size_t size) = 0;
-  virtual int64_t seek_within_single_part(int64_t offset, int whence) = 0;
-  virtual int64_t size_of_single_part(const PathHierarchy &single_part) = 0;
+  virtual int64_t seek_within_single_part(int64_t offset, int whence);
+  virtual int64_t size_of_single_part(const PathHierarchy &single_part);
 
   PathHierarchy _logical_path;
   void deactivate_active_part();

data/ext/archive_r/vendor/archive_r/include/archive_r/path_hierarchy_utils.h

@@ -33,5 +33,4 @@ bool entry_name_from_component(const PathEntry &entry, std::string &output);
 std::string path_entry_display(const PathEntry &entry);
 std::string hierarchy_display(const PathHierarchy &hierarchy);
 
-
 } // namespace archive_r

data/ext/archive_r/vendor/archive_r/include/archive_r/platform_compat.h

@@ -6,16 +6,16 @@
 #include <sys/types.h>
 
 #if defined(_WIN32)
-#  include <sys/stat.h>
-#  include <BaseTsd.h>
-#  if !defined(_SSIZE_T_DEFINED)
+#include <BaseTsd.h>
+#include <sys/stat.h>
+#if !defined(_SSIZE_T_DEFINED)
 using ssize_t = SSIZE_T;
-#    define _SSIZE_T_DEFINED
-#  endif
-#  if !defined(_MODE_T_DEFINED)
+#define _SSIZE_T_DEFINED
+#endif
+#if !defined(_MODE_T_DEFINED)
 using mode_t = unsigned short; // MSVC does not expose POSIX mode_t by default
-#    define _MODE_T_DEFINED
-#  endif
+#define _MODE_T_DEFINED
+#endif
 #endif
 
 namespace archive_r {

data/ext/archive_r/vendor/archive_r/include/archive_r/traverser.h

@@ -75,8 +75,8 @@ public:
    * Provide one or more paths to traverse. Single-path traversal can be
    * achieved by passing a container with one element:
    *   Traverser traverser({make_single_path("archive.tar.gz")});
-  *
-  * @throws std::invalid_argument if paths is empty or contains an empty hierarchy
+   *
+   * @throws std::invalid_argument if paths is empty or contains an empty hierarchy
    */
   explicit Traverser(std::vector<PathHierarchy> paths, TraverserOptions options = {});
 

data/ext/archive_r/vendor/archive_r/src/archive_stack_cursor.cc

@@ -125,9 +125,7 @@ EntryPayloadStream::EntryPayloadStream(std::shared_ptr<StreamArchive> parent_arc
   }
 }
 
-EntryPayloadStream::~EntryPayloadStream() {
-  deactivate_active_part();
-}
+EntryPayloadStream::~EntryPayloadStream() { deactivate_active_part(); }
 
 std::shared_ptr<StreamArchive> EntryPayloadStream::parent_archive() const { return _parent_archive; }
 
@@ -154,19 +152,7 @@ void EntryPayloadStream::close_single_part() {
   // so explicit skipping here is unnecessary and avoids potential exceptions in destructor.
 }
 
-ssize_t EntryPayloadStream::read_from_single_part(void *buffer, size_t size) {
-  if (size == 0) {
-    return 0;
-  }
-  return _parent_archive->read_current(buffer, size);
-}
-
-int64_t EntryPayloadStream::seek_within_single_part(int64_t offset, int whence) { return -1; }
-
-int64_t EntryPayloadStream::size_of_single_part(const PathHierarchy &single_part) {
-  (void)single_part;
-  return -1;
-}
+ssize_t EntryPayloadStream::read_from_single_part(void *buffer, size_t size) { return _parent_archive->read_current(buffer, size); }
 
 // ============================================================================
 // ArchiveStackCursor Implementation
@@ -177,9 +163,7 @@ ArchiveStackCursor::ArchiveStackCursor()
     , _current_stream(nullptr)
     , _current_archive(nullptr) {}
 
-void ArchiveStackCursor::configure(const ArchiveOption &options) {
-  options_snapshot = options;
-}
+void ArchiveStackCursor::configure(const ArchiveOption &options) { options_snapshot = options; }
 
 void ArchiveStackCursor::reset() {
   options_snapshot = ArchiveOption{};
@@ -207,17 +191,12 @@ bool ArchiveStackCursor::descend() {
 }
 
 bool ArchiveStackCursor::ascend() {
-  if (depth() <= 0) {
+  if (!_current_archive) {
     return false;
   }
 
-  if (_current_archive) {
-    _current_stream = _current_archive->get_stream();
-    _current_archive = _current_archive->parent_archive();
-  } else {
-    _current_stream = nullptr;
-  }
-
+  _current_stream = _current_archive->get_stream();
+  _current_archive = _current_archive->parent_archive();
   return true;
 }
 
@@ -250,8 +229,7 @@ bool ArchiveStackCursor::synchronize_to_hierarchy(const PathHierarchy &target_hi
   // 1. Ascend until we find a common ancestor
   while (depth() > 0) {
     auto current_h = _current_archive->source_hierarchy();
-    if (current_h.size() <= target_hierarchy.size() &&
-        hierarchies_equal(current_h, pathhierarchy_prefix_until(target_hierarchy, current_h.size() - 1))) {
+    if (current_h.size() <= target_hierarchy.size() && hierarchies_equal(current_h, pathhierarchy_prefix_until(target_hierarchy, current_h.size() - 1))) {
       break;
     }
     ascend();
@@ -289,12 +267,10 @@ ssize_t ArchiveStackCursor::read(void *buff, size_t len) {
   return 0;
 }
 
-StreamArchive *ArchiveStackCursor::current_archive() {
-  return _current_archive.get();
-}
+StreamArchive *ArchiveStackCursor::current_archive() { return _current_archive.get(); }
 
 PathHierarchy ArchiveStackCursor::current_entry_hierarchy() {
-  if (depth() == 0 || (!_current_stream && !_current_archive)) {
+  if (!_current_stream && !_current_archive) {
     return {};
   }
 
@@ -306,7 +282,7 @@ PathHierarchy ArchiveStackCursor::current_entry_hierarchy() {
     return path;
   }
 
-  return _current_stream->source_hierarchy();
+  return _current_stream ? _current_stream->source_hierarchy() : PathHierarchy{};
 }
 
 std::shared_ptr<IDataStream> ArchiveStackCursor::create_stream(const PathHierarchy &hierarchy) {

data/ext/archive_r/vendor/archive_r/src/archive_stack_cursor.h

@@ -4,10 +4,10 @@
 #pragma once
 
 #include "archive_r/data_stream.h"
+#include "archive_r/multi_volume_stream_base.h"
 #include "archive_r/path_hierarchy.h"
 #include "archive_type.h"
 #include "entry_fault_error.h"
-#include "archive_r/multi_volume_stream_base.h"
 #include <array>
 #include <cstddef>
 #include <exception>
@@ -64,8 +64,6 @@ private:
   void open_single_part(const PathHierarchy &single_part) override;
   void close_single_part() override;
   ssize_t read_from_single_part(void *buffer, size_t size) override;
-  int64_t seek_within_single_part(int64_t offset, int whence) override;
-  int64_t size_of_single_part(const PathHierarchy &single_part) override;
 };
 
 // ============================================================================

data/ext/archive_r/vendor/archive_r/src/archive_stack_orchestrator.cc

@@ -2,8 +2,8 @@
 // Copyright (c) 2025 archive_r Team
 
 #include "archive_stack_orchestrator.h"
-#include "archive_r/path_hierarchy_utils.h"
 #include "archive_r/entry_fault.h"
+#include "archive_r/path_hierarchy_utils.h"
 #include "system_file_stream.h"
 
 #include <algorithm>
@@ -19,8 +19,7 @@
 namespace archive_r {
 
 ArchiveStackOrchestrator::ArchiveStackOrchestrator(const ArchiveOption &options)
-    : _archive_options(options)
-{
+    : _archive_options(options) {
   _head.configure(_archive_options);
 }
 
@@ -135,12 +134,12 @@ void ArchiveStackOrchestrator::mark_entry_as_multi_volume(const PathHierarchy &e
 }
 
 bool ArchiveStackOrchestrator::descend_pending_multi_volumes() {
-  const PathHierarchy current_hierarchy = _head.current_entry_hierarchy();
+  const PathHierarchy current_hierarchy = (depth() == 0) ? PathHierarchy{} : _head.current_entry_hierarchy();
   PathHierarchy multi_volume_target;
   if (!_multi_volume_manager.pop_multi_volume_group(current_hierarchy, multi_volume_target)) {
     return false;
   }
-  
+
   _head.synchronize_to_hierarchy(multi_volume_target);
   _head.descend();
   return true;

data/ext/archive_r/vendor/archive_r/src/archive_stack_orchestrator.h

@@ -5,8 +5,8 @@
 
 #include "archive_r/path_hierarchy.h"
 #include "archive_r/platform_compat.h"
-#include "archive_type.h"
 #include "archive_stack_cursor.h"
+#include "archive_type.h"
 #include "entry_fault_error.h"
 #include "multi_volume_manager.h"
 #include <limits>

data/ext/archive_r/vendor/archive_r/src/archive_type.cc

@@ -232,9 +232,7 @@ bool Archive::search_forward_until_eof(const std::string &entryname) {
     if (current_entryname == entryname) {
       return true;
     }
-    if (!skip_data()) {
-      return false;
-    }
+    skip_data();
   }
   return false;
 }
@@ -247,9 +245,7 @@ bool Archive::search_until_position(const std::string &entryname, const std::str
     if (current_entryname == stop_position) {
       break;
     }
-    if (!skip_data()) {
-      return false;
-    }
+    skip_data();
   }
   return false;
 }
@@ -453,14 +449,9 @@ EntryMetadataMap Archive::current_entry_metadata(const std::unordered_set<std::s
     }
   }
 
-  ssize_t acl_length = 0;
-  char *acl_text = wants("acl_text") ? archive_entry_acl_to_text(current_entry, &acl_length, ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA) : nullptr;
+  char *acl_text = wants("acl_text") ? archive_entry_acl_to_text(current_entry, nullptr, ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA) : nullptr;
   if (acl_text) {
-    if (acl_length >= 0) {
-      metadata["acl_text"] = std::string(acl_text, static_cast<size_t>(acl_length));
-    } else {
-      metadata["acl_text"] = std::string(acl_text);
-    }
+    metadata["acl_text"] = std::string(acl_text);
     std::free(acl_text);
   }
 

data/ext/archive_r/vendor/archive_r/src/archive_type.h

@@ -26,8 +26,8 @@ using archive_ptr = std::unique_ptr<struct archive, archive_deleter>;
 using open_delegate = std::function<int(struct archive *ar)>;
 
 struct ArchiveOption {
-  std::vector<std::string> passphrases;   ///< Passphrases for encrypted archives
-  std::vector<std::string> formats;       ///< Specific format names to enable (empty = all)
+  std::vector<std::string> passphrases;          ///< Passphrases for encrypted archives
+  std::vector<std::string> formats;              ///< Specific format names to enable (empty = all)
   std::unordered_set<std::string> metadata_keys; ///< Metadata keys to capture (empty = none)
 };
 

data/ext/archive_r/vendor/archive_r/src/entry.cc

@@ -32,24 +32,9 @@ Entry::Impl::Impl(const Impl &other)
     , _descend_enabled(other._descend_enabled)
     , _orchestrator(nullptr)
     , _shares_traverser_orchestrator(false)
-    , _archive_options(other._archive_options) {
-}
+    , _archive_options(other._archive_options) {}
 
 // Copy assignment operator
-Entry::Impl &Entry::Impl::operator=(const Impl &other) {
-  if (this != &other) {
-    _path_hierarchy = other._path_hierarchy;
-    _size = other._size;
-    _filetype = other._filetype;
-    _metadata = other._metadata;
-    _descend_enabled = other._descend_enabled;
-    _orchestrator.reset();
-    _shares_traverser_orchestrator = false;
-    _archive_options = other._archive_options;
-  }
-  return *this;
-}
-
 Entry::Impl::Impl(const PathHierarchy &hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent)
     : _path_hierarchy(hierarchy)
     , _size(0)
@@ -199,7 +184,7 @@ ssize_t Entry::Impl::read(void *buffer, size_t length) {
 // ============================================================================
 
 Entry::Entry(const PathHierarchy &hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent)
-  : _impl(std::make_unique<Impl>(hierarchy, std::move(data_source_orchestrator), default_descent)) {}
+    : _impl(std::make_unique<Impl>(hierarchy, std::move(data_source_orchestrator), default_descent)) {}
 
 Entry::Entry(Impl *impl)
     : _impl(impl) {}

data/ext/archive_r/vendor/archive_r/src/entry_fault_error.cc

@@ -18,35 +18,35 @@ EntryFaultError::EntryFaultError(EntryFault fault, const std::string &internal_m
     , _fault(std::move(fault)) {}
 
 EntryFaultError make_entry_fault_error(const std::string &message, PathHierarchy hierarchy, int errno_value) {
-    EntryFault fault;
-    fault.hierarchy = std::move(hierarchy);
-    fault.message = message;
-    fault.errno_value = errno_value;
-    return EntryFaultError(std::move(fault));
+  EntryFault fault;
+  fault.hierarchy = std::move(hierarchy);
+  fault.message = message;
+  fault.errno_value = errno_value;
+  return EntryFaultError(std::move(fault));
 }
 
 std::string format_errno_error(const std::string &prefix, int err) {
-    if (err == 0) {
-        return prefix;
-    }
-
-    std::string message = prefix;
-    message.append(": ");
-    message.append(std::strerror(err));
-    message.append(" (posix errno=");
-    message.append(std::to_string(err));
-    message.push_back(')');
-    return message;
+  if (err == 0) {
+    return prefix;
+  }
+
+  std::string message = prefix;
+  message.append(": ");
+  message.append(std::strerror(err));
+  message.append(" (posix errno=");
+  message.append(std::to_string(err));
+  message.push_back(')');
+  return message;
 }
 
 std::string format_path_errno_error(const std::string &action, const std::string &path, int err) {
-    std::string prefix = action;
-    if (!path.empty()) {
-        prefix.append(" '");
-        prefix.append(path);
-        prefix.push_back('\'');
-    }
-    return format_errno_error(prefix, err);
+  std::string prefix = action;
+  if (!path.empty()) {
+    prefix.append(" '");
+    prefix.append(path);
+    prefix.push_back('\'');
+  }
+  return format_errno_error(prefix, err);
 }
 
 std::string prefer_error_detail(const std::string &detail, const std::string &fallback) { return detail.empty() ? fallback : detail; }

data/ext/archive_r/vendor/archive_r/src/entry_impl.h

@@ -19,7 +19,6 @@ public:
   // No libarchive dependency
   // Copy constructor and assignment (orchestrator is not copied)
   Impl(const Impl &other);
-  Impl &operator=(const Impl &other);
 
   Impl(const PathHierarchy &hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent);
 
@@ -45,7 +44,7 @@ private:
   EntryMetadataMap _metadata;
   bool _descend_enabled = true; // Flag to control automatic descent
 
-  std::shared_ptr<ArchiveStackOrchestrator> _orchestrator;               ///< Active orchestrator (shared with traverser or detached copy)
+  std::shared_ptr<ArchiveStackOrchestrator> _orchestrator; ///< Active orchestrator (shared with traverser or detached copy)
   bool _shares_traverser_orchestrator = false;
 
   mutable std::optional<ArchiveOption> _archive_options;

data/ext/archive_r/vendor/archive_r/src/multi_volume_manager.cc

@@ -10,9 +10,7 @@
 
 namespace archive_r {
 
-MultiVolumeManager::MultiVolumeGroup &MultiVolumeManager::get_or_create_multi_volume_group(const PathHierarchy &parent_hierarchy,
-                                                                                           const std::string &base_name,
-                                                                                           PathEntry::Parts::Ordering ordering) {
+MultiVolumeManager::MultiVolumeGroup &MultiVolumeManager::get_or_create_multi_volume_group(const PathHierarchy &parent_hierarchy, const std::string &base_name, PathEntry::Parts::Ordering ordering) {
   GroupList &groups = _multi_volume_groups[parent_hierarchy];
   auto it = std::find_if(groups.begin(), groups.end(), [&](const MultiVolumeGroup &group) { return group.base_name == base_name; });
 
@@ -47,17 +45,14 @@ bool MultiVolumeManager::pop_group_for_parent(const PathHierarchy &parent_hierar
   return true;
 }
 
-void MultiVolumeManager::mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name,
-                                                    PathEntry::Parts::Ordering ordering) {
+void MultiVolumeManager::mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name, PathEntry::Parts::Ordering ordering) {
   if (entry_path.empty() || pathhierarchy_is_multivolume(entry_path)) {
     return;
   }
 
   MultiVolumeGroup &target = get_or_create_multi_volume_group(parent_hierarchy(entry_path), base_name, ordering);
   auto &parts = target.parts;
-  const bool exists = std::any_of(parts.begin(), parts.end(), [&](const PathHierarchy &existing) {
-    return hierarchies_equal(existing, entry_path);
-  });
+  const bool exists = std::any_of(parts.begin(), parts.end(), [&](const PathHierarchy &existing) { return hierarchies_equal(existing, entry_path); });
   if (!exists) {
     parts.push_back(entry_path);
   }

data/ext/archive_r/vendor/archive_r/src/multi_volume_manager.h

@@ -24,14 +24,12 @@ public:
   using GroupList = std::vector<MultiVolumeGroup>;
   using ParentGroupMap = std::map<PathHierarchy, GroupList, PathHierarchyLess>;
 
-  void mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name,
-                                  PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural);
+  void mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name, PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural);
 
   bool pop_multi_volume_group(const PathHierarchy &current_hierarchy, PathHierarchy &multi_volume_hierarchy);
 
 private:
-  MultiVolumeGroup &get_or_create_multi_volume_group(const PathHierarchy &parent_hierarchy, const std::string &base_name,
-                                                     PathEntry::Parts::Ordering ordering);
+  MultiVolumeGroup &get_or_create_multi_volume_group(const PathHierarchy &parent_hierarchy, const std::string &base_name, PathEntry::Parts::Ordering ordering);
 
   bool pop_group_for_parent(const PathHierarchy &parent_hierarchy, MultiVolumeGroup &out_group);
 

data/ext/archive_r/vendor/archive_r/src/multi_volume_stream_base.cc

@@ -33,9 +33,9 @@ struct MultiVolumeStreamBase::Impl {
 };
 
 MultiVolumeStreamBase::MultiVolumeStreamBase(PathHierarchy logical_path, bool supports_seek)
-  : _logical_path(std::move(logical_path))
-  , _supports_seek(supports_seek)
-  , _impl(std::make_unique<Impl>(*this)) {
+    : _logical_path(std::move(logical_path))
+    , _supports_seek(supports_seek)
+    , _impl(std::make_unique<Impl>(*this)) {
   _impl->total_parts = pathhierarchy_volume_size(_logical_path);
   if (_impl->total_parts == 0) {
     throw std::invalid_argument("MultiVolumeStreamBase requires at least one volume component");
@@ -84,9 +84,7 @@ void MultiVolumeStreamBase::rewind() {
   _impl->logical_offset = 0;
 }
 
-bool MultiVolumeStreamBase::at_end() const {
-  return _impl->active_part_index >= _impl->total_parts;
-}
+bool MultiVolumeStreamBase::at_end() const { return _impl->active_part_index >= _impl->total_parts; }
 
 int64_t MultiVolumeStreamBase::seek(int64_t offset, int whence) {
   if (!_supports_seek) {
@@ -122,6 +120,17 @@ int64_t MultiVolumeStreamBase::seek(int64_t offset, int whence) {
 
 int64_t MultiVolumeStreamBase::tell() const { return _impl->logical_offset; }
 
+int64_t MultiVolumeStreamBase::seek_within_single_part(int64_t offset, int whence) {
+  (void)offset;
+  (void)whence;
+  return -1;
+}
+
+int64_t MultiVolumeStreamBase::size_of_single_part(const PathHierarchy &single_part) {
+  (void)single_part;
+  return -1;
+}
+
 void MultiVolumeStreamBase::Impl::ensure_part_active(std::size_t part_index) {
   if (part_open && open_part_index == part_index) {
     return;
@@ -173,14 +182,14 @@ bool MultiVolumeStreamBase::Impl::ensure_size_metadata() {
 
 int64_t MultiVolumeStreamBase::Impl::compute_target_offset(int64_t offset, int whence) const {
   switch (whence) {
-    case SEEK_SET:
-      return offset;
-    case SEEK_CUR:
-      return logical_offset + offset;
-    case SEEK_END:
-      return total_size + offset;
-    default:
-      return -1;
+  case SEEK_SET:
+    return offset;
+  case SEEK_CUR:
+    return logical_offset + offset;
+  case SEEK_END:
+    return total_size + offset;
+  default:
+    return -1;
   }
 }
 

data/ext/archive_r/vendor/archive_r/src/path_hierarchy.cc

@@ -107,9 +107,7 @@ PathHierarchy make_single_path(const std::string &root) {
 
 void append_single(PathHierarchy &hierarchy, std::string value) { hierarchy.emplace_back(PathEntry::single(std::move(value))); }
 
-void append_multi_volume(PathHierarchy &hierarchy, std::vector<std::string> parts, PathEntry::Parts::Ordering ordering) {
-  hierarchy.emplace_back(PathEntry::multi_volume(std::move(parts), ordering));
-}
+void append_multi_volume(PathHierarchy &hierarchy, std::vector<std::string> parts, PathEntry::Parts::Ordering ordering) { hierarchy.emplace_back(PathEntry::multi_volume(std::move(parts), ordering)); }
 
 PathHierarchy pathhierarchy_prefix_until(const PathHierarchy &hierarchy, size_t inclusive_index) {
   if (hierarchy.empty() || inclusive_index >= hierarchy.size()) {
@@ -126,5 +124,4 @@ PathHierarchy parent_hierarchy(const PathHierarchy &hierarchy) {
   return pathhierarchy_prefix_until(hierarchy, hierarchy.size() - 2);
 }
 
-
 } // namespace archive_r

data/ext/archive_r/vendor/archive_r/src/path_hierarchy_utils.cc

@@ -73,10 +73,6 @@ bool determine_multi_volume_segments(const std::vector<PathHierarchy> &sources,
 }
 
 bool collect_multi_volume_parts(const std::vector<PathHierarchy> &sources, const CollapseSegments &segments, std::vector<std::string> &parts) {
-  if (sources.empty()) {
-    return false;
-  }
-
   const std::size_t suffix_size = segments.suffix.size();
   const std::size_t required_size = segments.multi_volume_depth + 1 + suffix_size;
 
@@ -111,14 +107,6 @@ bool collect_multi_volume_parts(const std::vector<PathHierarchy> &sources, const
   return true;
 }
 
-bool flatten_single_entry(const PathEntry &entry, std::string &output) {
-  if (entry.is_single()) {
-    output = entry.single_value();
-    return true;
-  }
-  return flatten_entry_to_string(entry, output);
-}
-
 } // namespace
 
 const std::string *path_entry_component_at(const PathEntry &entry, std::size_t index) {
@@ -129,14 +117,10 @@ const std::string *path_entry_component_at(const PathEntry &entry, std::size_t i
     return nullptr;
   }
 
-  if (entry.is_multi_volume()) {
-    const auto &parts = entry.multi_volume_parts().values;
-    if (index < parts.size()) {
-      return &parts[index];
-    }
-    return nullptr;
+  const auto &parts = entry.multi_volume_parts().values;
+  if (index < parts.size()) {
+    return &parts[index];
   }
-
   return nullptr;
 }
 
@@ -162,11 +146,7 @@ std::string pathhierarchy_volume_entry_name(const PathHierarchy &logical, std::s
       return {};
     }
 
-    std::string entry_name;
-    if (!flatten_single_entry(tail, entry_name)) {
-      return {};
-    }
-    return entry_name;
+    return tail.single_value();
   }
 
   const auto &parts = tail.multi_volume_parts().values;
@@ -241,20 +221,18 @@ std::string path_entry_display(const PathEntry &entry) {
   if (entry.is_single()) {
     return entry.single_value();
   }
-  if (entry.is_multi_volume()) {
-    std::string value = "[";
-    bool first = true;
-    for (const auto &part : entry.multi_volume_parts().values) {
-      if (!first) {
-        value.push_back('|');
-      }
-      value += part;
-      first = false;
+
+  std::string value = "[";
+  bool first = true;
+  for (const auto &part : entry.multi_volume_parts().values) {
+    if (!first) {
+      value.push_back('|');
     }
-    value.push_back(']');
-    return value;
+    value += part;
+    first = false;
   }
-  return {};
+  value.push_back(']');
+  return value;
 }
 
 std::string hierarchy_display(const PathHierarchy &hierarchy) {

data/ext/archive_r/vendor/archive_r/src/simple_profiler.h

@@ -4,106 +4,95 @@
 #pragma once
 #include <string>
 
+#include <algorithm>
 #include <chrono>
+#include <iomanip>
 #include <iostream>
 #include <map>
-#include <vector>
-#include <algorithm>
-#include <iomanip>
 #include <mutex>
-
+#include <vector>
 
 namespace archive_r {
 namespace internal {
 
-
-
 class SimpleProfiler {
 public:
-    static SimpleProfiler& instance() {
-        static SimpleProfiler inst;
-        return inst;
+  static SimpleProfiler &instance() {
+    static SimpleProfiler inst;
+    return inst;
+  }
+
+  ~SimpleProfiler() { report(); }
+
+  void start(const std::string &name) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto now = std::chrono::high_resolution_clock::now();
+    start_times_[name] = now;
+  }
+
+  void stop(const std::string &name) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto now = std::chrono::high_resolution_clock::now();
+    auto it = start_times_.find(name);
+    if (it != start_times_.end()) {
+      auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(now - it->second).count();
+      durations_[name] += duration;
+      counts_[name]++;
     }
+  }
 
-    ~SimpleProfiler() {
-        report();
-    }
+  void report() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (durations_.empty())
+      return;
 
-    void start(const std::string& name) {
-        std::lock_guard<std::mutex> lock(mutex_);
-        auto now = std::chrono::high_resolution_clock::now();
-        start_times_[name] = now;
+    std::cout << "\n=== Profiling Report (archive_r::internal) ===" << std::endl;
+    std::vector<std::pair<std::string, long long>> sorted_durations;
+    for (const auto &pair : durations_) {
+      sorted_durations.push_back(pair);
     }
 
-    void stop(const std::string& name) {
-        std::lock_guard<std::mutex> lock(mutex_);
-        auto now = std::chrono::high_resolution_clock::now();
-        auto it = start_times_.find(name);
-        if (it != start_times_.end()) {
-            auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(now - it->second).count();
-            durations_[name] += duration;
-            counts_[name]++;
-        }
-    }
+    std::sort(sorted_durations.begin(), sorted_durations.end(), [](const auto &a, const auto &b) { return a.second > b.second; });
 
-    void report() {
-        std::lock_guard<std::mutex> lock(mutex_);
-        if (durations_.empty()) return;
-
-        std::cout << "\n=== Profiling Report (archive_r::internal) ===" << std::endl;
-        std::vector<std::pair<std::string, long long>> sorted_durations;
-        for (const auto& pair : durations_) {
-            sorted_durations.push_back(pair);
-        }
-        
-        std::sort(sorted_durations.begin(), sorted_durations.end(), 
-            [](const auto& a, const auto& b) { return a.second > b.second; });
-
-        std::cout << std::left << std::setw(40) << "Name" 
-                  << std::right << std::setw(15) << "Total (ms)" 
-                  << std::setw(10) << "Count" 
-                  << std::setw(15) << "Avg (us)" << std::endl;
-        std::cout << std::string(80, '-') << std::endl;
-
-        for (const auto& pair : sorted_durations) {
-            const auto& name = pair.first;
-            long long total_ns = pair.second;
-            long long count = counts_[name];
-            double avg_ns = count > 0 ? (double)total_ns / count : 0;
-            
-            std::cout << std::left << std::setw(40) << name 
-                      << std::right << std::setw(15) << std::fixed << std::setprecision(3) << total_ns / 1000000.0 
-                      << std::setw(10) << count 
-                      << std::setw(15) << std::fixed << std::setprecision(3) << avg_ns / 1000.0 
-                      << std::endl;
-        }
-        std::cout << "==============================================\n" << std::endl;
-    }
+    std::cout << std::left << std::setw(40) << "Name" << std::right << std::setw(15) << "Total (ms)" << std::setw(10) << "Count" << std::setw(15) << "Avg (us)" << std::endl;
+    std::cout << std::string(80, '-') << std::endl;
+
+    for (const auto &pair : sorted_durations) {
+      const auto &name = pair.first;
+      long long total_ns = pair.second;
+      long long count = counts_[name];
+      double avg_ns = count > 0 ? (double)total_ns / count : 0;
 
-    void reset() {
-        std::lock_guard<std::mutex> lock(mutex_);
-        start_times_.clear();
-        durations_.clear();
-        counts_.clear();
+      std::cout << std::left << std::setw(40) << name << std::right << std::setw(15) << std::fixed << std::setprecision(3) << total_ns / 1000000.0 << std::setw(10) << count << std::setw(15)
+                << std::fixed << std::setprecision(3) << avg_ns / 1000.0 << std::endl;
     }
+    std::cout << "==============================================\n" << std::endl;
+  }
+
+  void reset() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    start_times_.clear();
+    durations_.clear();
+    counts_.clear();
+  }
 
 private:
-    std::map<std::string, std::chrono::high_resolution_clock::time_point> start_times_;
-    std::map<std::string, long long> durations_;
-    std::map<std::string, long long> counts_;
-    std::mutex mutex_;
+  std::map<std::string, std::chrono::high_resolution_clock::time_point> start_times_;
+  std::map<std::string, long long> durations_;
+  std::map<std::string, long long> counts_;
+  std::mutex mutex_;
 };
 
 class ScopedTimer {
 public:
-    ScopedTimer(const std::string& name) : name_(name) {
-        SimpleProfiler::instance().start(name_);
-    }
-    ~ScopedTimer() {
-        SimpleProfiler::instance().stop(name_);
-    }
+  ScopedTimer(const std::string &name)
+      : name_(name) {
+    SimpleProfiler::instance().start(name_);
+  }
+  ~ScopedTimer() { SimpleProfiler::instance().stop(name_); }
+
 private:
-    std::string name_;
+  std::string name_;
 };
 
 } // namespace internal

data/ext/archive_r/vendor/archive_r/src/system_file_stream.cc

@@ -11,16 +11,16 @@
 #include <cstdio>
 #include <filesystem>
 #include <stdexcept>
+#include <string_view>
 #include <sys/stat.h>
 #include <system_error>
-#include <string_view>
 #include <utility>
 #include <vector>
 
 #if !defined(_WIN32)
-#  include <grp.h>
-#  include <pwd.h>
-#  include <unistd.h>
+#include <grp.h>
+#include <pwd.h>
+#include <unistd.h>
 #endif
 
 namespace archive_r {
@@ -66,21 +66,10 @@ static bool lookup_groupname(gid_t gid, std::string &name_out) {
 } // namespace
 
 SystemFileStream::SystemFileStream(PathHierarchy logical_path)
-  : MultiVolumeStreamBase(std::move(logical_path), true)
-  , _handle(nullptr) {
-  if (_logical_path.empty()) {
-    throw std::invalid_argument("Root file hierarchy cannot be empty");
-  }
+    : MultiVolumeStreamBase(std::move(logical_path), true)
+    , _handle(nullptr) {}
 
-  const PathEntry &root_entry = _logical_path.front();
-  if (!root_entry.is_single() && !root_entry.is_multi_volume()) {
-    throw std::invalid_argument("Root file hierarchy must be a single file or multi-volume source");
-  }
-}
-
-SystemFileStream::~SystemFileStream() {
-  deactivate_active_part();
-}
+SystemFileStream::~SystemFileStream() { deactivate_active_part(); }
 
 void SystemFileStream::open_single_part(const PathHierarchy &single_part) {
   const PathEntry &entry = single_part.back();
@@ -100,7 +89,7 @@ void SystemFileStream::open_single_part(const PathHierarchy &single_part) {
   // Enable larger buffering on Windows to improve performance
   // Use 64KB buffer to match StreamArchive's buffer size
   if (_handle) {
-      std::setvbuf(_handle, nullptr, _IOFBF, 65536);
+    std::setvbuf(_handle, nullptr, _IOFBF, 65536);
   }
 #endif
 }
@@ -227,9 +216,7 @@ FilesystemMetadataInfo collect_root_path_metadata(const PathHierarchy &hierarchy
   info.filetype = filetype;
   EntryMetadataMap metadata;
   if (!allowed_keys.empty()) {
-    const auto wants = [&allowed_keys](std::string_view key) {
-      return allowed_keys.find(std::string(key)) != allowed_keys.end();
-    };
+    const auto wants = [&allowed_keys](std::string_view key) { return allowed_keys.find(std::string(key)) != allowed_keys.end(); };
 
     // Path hierarchy / directory entry derived metadata
     if (wants("pathname")) {
@@ -254,10 +241,10 @@ FilesystemMetadataInfo collect_root_path_metadata(const PathHierarchy &hierarchy
     }
 
     const bool needs_stat = (wants("size") && size == 0)
-  #if !defined(_WIN32)
-      || wants("uid") || wants("gid") || wants("uname") || wants("gname")
-  #endif
-      ;
+#if !defined(_WIN32)
+                            || wants("uid") || wants("gid") || wants("uname") || wants("gname")
+#endif
+        ;
 
     struct stat stat_buffer;
     bool have_stat = false;

data/ext/archive_r/vendor/archive_r/src/system_file_stream.h

@@ -10,10 +10,10 @@
 #include <unordered_set>
 #include <vector>
 
-#include "archive_r/multi_volume_stream_base.h"
-#include "archive_r/platform_compat.h"
 #include "archive_r/entry_metadata.h"
+#include "archive_r/multi_volume_stream_base.h"
 #include "archive_r/path_hierarchy.h"
+#include "archive_r/platform_compat.h"
 
 namespace archive_r {
 

data/ext/archive_r/vendor/archive_r/src/traverser.cc

@@ -3,9 +3,9 @@
 
 #include "archive_r/traverser.h"
 #include "archive_r/entry.h"
+#include "archive_r/entry_fault.h"
 #include "archive_r/path_hierarchy.h"
 #include "archive_r/path_hierarchy_utils.h"
-#include "archive_r/entry_fault.h"
 #include "archive_stack_orchestrator.h"
 #include "archive_type.h"
 #include "entry_fault_error.h"
@@ -48,14 +48,13 @@ Traverser::Traverser(std::vector<PathHierarchy> paths, TraverserOptions options)
       throw std::invalid_argument("path hierarchy cannot be empty");
     }
   }
-
 }
 
 Traverser::Traverser(PathHierarchy path, TraverserOptions options)
-    : Traverser(std::vector<PathHierarchy>{std::move(path)}, std::move(options)) {}
+    : Traverser(std::vector<PathHierarchy>{ std::move(path) }, std::move(options)) {}
 
 Traverser::Traverser(const std::string &path, TraverserOptions options)
-    : Traverser(std::vector<PathHierarchy>{make_single_path(path)}, std::move(options)) {}
+    : Traverser(std::vector<PathHierarchy>{ make_single_path(path) }, std::move(options)) {}
 
 Traverser::~Traverser() = default;
 
@@ -65,7 +64,7 @@ Traverser::~Traverser() = default;
 
 class Traverser::Iterator::Impl {
 public:
-    Impl(std::vector<PathHierarchy> paths, bool at_end, const TraverserOptions &traverser_options)
+  Impl(std::vector<PathHierarchy> paths, bool at_end, const TraverserOptions &traverser_options)
       : _paths(std::move(paths))
       , _at_end(at_end)
       , _archive_options(to_archive_option(traverser_options))
@@ -73,14 +72,9 @@ public:
     if (_at_end) {
       return;
     }
-    if (_paths.empty()) {
-      throw std::invalid_argument("paths cannot be empty");
-    }
     ensure_shared_orchestrator();
-    
-    if (!advance_to_next_root()) {
-      _at_end = true;
-    }
+
+    _at_end = !advance_to_next_root();
   }
 
   Entry &get_entry() {
@@ -100,7 +94,7 @@ public:
     if (_current_entry->depth() == 0 && request_descend_into_archive && !_current_entry->is_directory()) {
       request_descend_into_archive = false;
       attempt_descend_into_root(_current_entry->path_hierarchy());
-    } 
+    }
     _current_entry.reset();
 
     if (fetch_from_archive(request_descend_into_archive)) {
@@ -114,13 +108,13 @@ public:
     if (advance_to_next_root()) {
       return;
     }
-    
+
     descend_pending_multi_volumes();
-    
+
     if (fetch_from_archive(false)) {
       return;
     }
-    
+
     _at_end = true;
   }
 
@@ -128,10 +122,7 @@ public:
     if (this == other) {
       return true;
     }
-    if (!other) {
-      return false;
-    }
-    return _at_end && other->_at_end;
+    return other && _at_end && other->_at_end;
   }
 
 private:
@@ -143,9 +134,6 @@ private:
   }
 
   std::string normalize_path_string(const std::string &value) {
-    if (value.empty()) {
-      return value;
-    }
     std::filesystem::path path_value(value);
     return path_value.lexically_normal().string();
   }
@@ -169,14 +157,9 @@ private:
     }
     ArchiveStackOrchestrator &orchestrator = *ensure_shared_orchestrator();
 
-    try {
-      if (orchestrator.advance(request_descend_into_archive)) {
-        set_current_entry(orchestrator.current_entry_hierarchy());
-        return true;
-      }
-    } catch (const EntryFaultError &error) {
-      EntryFault fault = enrich_orchestrator_error(error, orchestrator);
-      handle_orchestrator_error(fault);
+    if (orchestrator.advance(request_descend_into_archive)) {
+      set_current_entry(orchestrator.current_entry_hierarchy());
+      return true;
     }
     return false;
   }
@@ -224,13 +207,9 @@ private:
     }
   }
 
-  void set_current_entry(PathHierarchy hierarchy) {
-    _current_entry = Entry::create(std::move(hierarchy), ensure_shared_orchestrator(), _default_descent);
-  }
+  void set_current_entry(PathHierarchy hierarchy) { _current_entry = Entry::create(std::move(hierarchy), ensure_shared_orchestrator(), _default_descent); }
 
-  void handle_orchestrator_error(const EntryFault &fault) {
-    dispatch_registered_fault(fault);
-  }
+  void handle_orchestrator_error(const EntryFault &fault) { dispatch_registered_fault(fault); }
 
   void reset_source_state() {
     reset_directory_traversal();
@@ -251,9 +230,6 @@ private:
     if (fault.hierarchy.empty()) {
       fault.hierarchy = orchestrator.current_entry_hierarchy();
     }
-    if (fault.message.empty() && error.what()) {
-      fault.message = error.what();
-    }
     return fault;
   }
 
@@ -273,7 +249,7 @@ private:
 // ============================================================================
 
 Traverser::Iterator::Iterator(std::unique_ptr<Impl> impl)
-  : _impl(std::move(impl)) {}
+    : _impl(std::move(impl)) {}
 
 Traverser::Iterator::~Iterator() = default;
 

data/lib/archive_r.rb

@@ -35,7 +35,11 @@ rescue LoadError
 end
 
 module Archive_r
-  VERSION = "0.1.8"
+  version_path = File.expand_path('../VERSION', __dir__)
+  unless File.exist?(version_path)
+    version_path = File.expand_path('../../../VERSION', __dir__)
+  end
+  VERSION = File.read(version_path).strip
   # Common archive formats excluding libarchive's mtree/raw pseudo formats
   STANDARD_FORMATS = %w[
     7zip ar cab cpio empty iso9660 lha rar tar warc xar zip

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: archive_r_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - raizo.tcs
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -51,6 +52,7 @@ files:
 - LICENSE
 - NOTICE
 - README.md
+- VERSION
 - ext/archive_r/archive_r_ext.cc
 - ext/archive_r/extconf.rb
 - ext/archive_r/vendor/archive_r/LICENSE
@@ -94,6 +96,7 @@ metadata:
   source_code_uri: https://github.com/raizo-tcs/archive_r
   bug_tracker_uri: https://github.com/raizo-tcs/archive_r/issues
   changelog_uri: https://github.com/raizo-tcs/archive_r/releases
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -108,7 +111,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.1
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: 'Ruby bindings for archive_r: libarchive-based streaming traversal for recursive
   nested archives (no temp files, no large in-memory buffers)'