archive_r_ruby 0.1.7 → 0.1.9

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
 }
@@ -168,6 +157,8 @@ void SystemFileStream::report_read_failure(int err) {
   throw make_entry_fault_error(detailed, _logical_path, err);
 }
 
+// Collect filesystem metadata for the root path in the hierarchy.
+// Returns an empty info struct when metadata is unavailable or disallowed.
 FilesystemMetadataInfo collect_root_path_metadata(const PathHierarchy &hierarchy, const std::unordered_set<std::string> &allowed_keys) {
   FilesystemMetadataInfo info;
 
@@ -187,6 +178,12 @@ FilesystemMetadataInfo collect_root_path_metadata(const PathHierarchy &hierarchy
     return info;
   }
 
+  ec.clear();
+  const bool exists = entry.exists(ec);
+  if (ec || !exists) {
+    return info;
+  }
+
   mode_t filetype = 0;
   uint64_t size = 0;
 
@@ -219,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")) {
@@ -246,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 {