archive_r_ruby 0.1.0

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

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_r/data_stream.h"
+
+#include <mutex>
+#include <utility>
+
+namespace archive_r {
+
+namespace {
+
+RootStreamFactory &factory_storage() {
+  static RootStreamFactory factory;
+  return factory;
+}
+
+std::mutex &factory_mutex() {
+  static std::mutex mutex;
+  return mutex;
+}
+
+} // namespace
+
+void set_root_stream_factory(RootStreamFactory factory) {
+  std::lock_guard<std::mutex> lock(factory_mutex());
+  factory_storage() = std::move(factory);
+}
+
+RootStreamFactory get_root_stream_factory() {
+  std::lock_guard<std::mutex> lock(factory_mutex());
+  return factory_storage();
+}
+
+} // namespace archive_r

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

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_r/entry.h"
+#include "archive_r/path_hierarchy_utils.h"
+#include "archive_stack_orchestrator.h"
+#include "entry_fault_error.h"
+#include "entry_impl.h"
+#include "system_file_stream.h"
+#include <archive.h>
+#include <archive_entry.h>
+#include <filesystem>
+#include <sstream>
+#include <sys/stat.h>
+#include <system_error>
+#include <unordered_set>
+#include <utility>
+
+namespace archive_r {
+
+// ============================================================================
+// Entry::Impl Implementation
+// ============================================================================
+
+// Unified constructor - receives metadata directly
+// Copy constructor - cached orchestrator is NOT copied (will be recreated on first read)
+Entry::Impl::Impl(const Impl &other)
+    : _path_hierarchy(other._path_hierarchy)
+    , _size(other._size)
+    , _filetype(other._filetype)
+    , _metadata(other._metadata)
+    , _descend_enabled(other._descend_enabled)
+    , _orchestrator(nullptr)
+    , _shares_traverser_orchestrator(false)
+    , _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)
+    , _filetype(0)
+    , _descend_enabled(default_descent)
+    , _orchestrator(std::move(data_source_orchestrator))
+    , _shares_traverser_orchestrator(static_cast<bool>(_orchestrator)) {
+  if (!_orchestrator) {
+    return;
+  }
+
+  const auto &keys = _orchestrator->metadata_keys();
+
+  const StreamArchive *archive = _orchestrator->current_archive();
+  const bool use_archive_metadata = archive && _path_hierarchy.size() > 1;
+
+  if (use_archive_metadata) {
+    _size = archive->current_entry_size();
+    _filetype = archive->current_entry_filetype();
+    if (!keys.empty()) {
+      _metadata = archive->current_entry_metadata(keys);
+    }
+  } else if (!hierarchy.empty()) {
+    FilesystemMetadataInfo info = collect_root_path_metadata(hierarchy, keys);
+    _size = info.size;
+    _filetype = info.filetype;
+    _metadata = std::move(info.metadata);
+  }
+
+  if (use_archive_metadata) {
+    _archive_options = _orchestrator->options();
+  } else {
+    _archive_options.reset();
+  }
+
+  if (_filetype == 0 && archive && _orchestrator->depth() == _path_hierarchy.size()) {
+    _filetype = AE_IFREG;
+  }
+}
+
+std::string Entry::Impl::name() const {
+  if (_path_hierarchy.empty()) {
+    return "";
+  }
+  const PathEntry &tail = _path_hierarchy.back();
+  std::string display_name;
+  if (entry_name_from_component(tail, display_name) && !display_name.empty()) {
+    return display_name;
+  }
+  if (tail.is_single()) {
+    return tail.single_value();
+  }
+  return path_entry_display(tail);
+}
+
+const PathHierarchy &Entry::Impl::path_hierarchy() const { return _path_hierarchy; }
+
+bool Entry::Impl::is_directory() const { return _filetype == AE_IFDIR; }
+
+bool Entry::Impl::is_file() const { return _filetype == AE_IFREG; }
+
+uint64_t Entry::Impl::size() const { return _size; }
+
+size_t Entry::Impl::depth() const {
+  // Depth is based on path hierarchy length
+  return _path_hierarchy.size() > 0 ? _path_hierarchy.size() - 1 : 0;
+}
+
+void Entry::Impl::set_descent(bool enabled) {
+  if (!_shares_traverser_orchestrator) {
+    emit_fault("set_descent requires traverser-managed orchestrator");
+    return;
+  }
+  _descend_enabled = enabled;
+}
+
+bool Entry::Impl::descent_enabled() const { return _descend_enabled; }
+
+const EntryMetadataMap &Entry::Impl::metadata() const { return _metadata; }
+
+const EntryMetadataValue *Entry::Impl::metadata_value(const std::string &key) const {
+  const auto it = _metadata.find(key);
+  if (it == _metadata.end()) {
+    return nullptr;
+  }
+  return &it->second;
+}
+
+void Entry::Impl::set_multi_volume_group(const std::string &base_name, const MultiVolumeGroupOptions &options) {
+  if (!_shares_traverser_orchestrator) {
+    emit_fault("set_multi_volume_group requires traverser-managed orchestrator");
+    return;
+  }
+
+  // Notify traverser via ArchiveStackOrchestrator
+  _descend_enabled = false;
+  _orchestrator->mark_entry_as_multi_volume(_path_hierarchy, base_name, options.ordering);
+}
+
+void Entry::Impl::emit_fault(const std::string &message, int errno_value) const {
+  EntryFault fault;
+  fault.message = message;
+  fault.errno_value = errno_value;
+  fault.hierarchy = _path_hierarchy;
+  dispatch_registered_fault(fault);
+}
+
+std::shared_ptr<ArchiveStackOrchestrator> Entry::Impl::ensure_orchestrator() {
+  if (_orchestrator) {
+    if (_shares_traverser_orchestrator && _orchestrator->depth() == 0) {
+      // Traverser-managed orchestrator never synchronized to this entry (depth 0 filesystem read).
+      _orchestrator.reset();
+      _shares_traverser_orchestrator = false;
+    } else {
+      return _orchestrator;
+    }
+  }
+
+  ArchiveOption opts = _archive_options.value_or(ArchiveOption{});
+  _orchestrator = std::make_shared<ArchiveStackOrchestrator>(opts);
+  if (!_orchestrator->synchronize_to_hierarchy(_path_hierarchy)) {
+    _orchestrator.reset();
+    return nullptr;
+  }
+  _shares_traverser_orchestrator = false;
+  return _orchestrator;
+}
+
+ssize_t Entry::Impl::read(void *buffer, size_t length) {
+  if (!ensure_orchestrator()) {
+    emit_fault("Failed to initialize ArchiveStackOrchestrator");
+    return -1;
+  }
+  const ssize_t bytes_read = _orchestrator->read_head(buffer, length);
+  if (bytes_read < 0) {
+    emit_fault("Failed to read entry content");
+    return -1;
+  }
+
+  _descend_enabled = false; // Require explicit re-enable before descending again
+
+  return bytes_read;
+}
+
+// ============================================================================
+// Entry Public API Implementation
+// ============================================================================
+
+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)) {}
+
+Entry::Entry(Impl *impl)
+    : _impl(impl) {}
+
+Entry::~Entry() = default;
+
+std::unique_ptr<Entry> Entry::create(PathHierarchy hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent) {
+  return std::unique_ptr<Entry>(new Entry(hierarchy, std::move(data_source_orchestrator), default_descent));
+}
+
+// Copy operations - creates a new Impl copy
+Entry::Entry(const Entry &other)
+    : _impl(other._impl ? std::make_unique<Impl>(*other._impl) : nullptr) {}
+
+Entry &Entry::operator=(const Entry &other) {
+  if (this != &other) {
+    _impl = other._impl ? std::make_unique<Impl>(*other._impl) : nullptr;
+  }
+  return *this;
+}
+
+Entry::Entry(Entry &&) noexcept = default;
+Entry &Entry::operator=(Entry &&) noexcept = default;
+
+std::string Entry::name() const { return _impl->name(); }
+
+std::string Entry::path() const { return hierarchy_display(_impl->path_hierarchy()); }
+
+const PathHierarchy &Entry::path_hierarchy() const { return _impl->path_hierarchy(); }
+
+bool Entry::is_directory() const { return _impl->is_directory(); }
+
+bool Entry::is_file() const { return _impl->is_file(); }
+
+uint64_t Entry::size() const { return _impl->size(); }
+
+size_t Entry::depth() const { return _impl->depth(); }
+
+ssize_t Entry::read(void *buffer, size_t length) { return _impl->read(buffer, length); }
+
+void Entry::set_descent(bool enabled) { _impl->set_descent(enabled); }
+
+bool Entry::descent_enabled() const { return _impl->descent_enabled(); }
+
+void Entry::set_multi_volume_group(const std::string &base_name, const MultiVolumeGroupOptions &options) { _impl->set_multi_volume_group(base_name, options); }
+
+const EntryMetadataMap &Entry::metadata() const { return _impl->metadata(); }
+
+const EntryMetadataValue *Entry::find_metadata(const std::string &key) const { return _impl->metadata_value(key); }
+
+} // namespace archive_r

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

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_r/entry_fault.h"
+
+#include <atomic>
+#include <memory>
+
+namespace archive_r {
+namespace {
+std::shared_ptr<const FaultCallback> g_fault_callback = std::make_shared<const FaultCallback>();
+}
+
+void register_fault_callback(FaultCallback callback) {
+  auto new_callback = std::make_shared<const FaultCallback>(std::move(callback));
+  std::atomic_store_explicit(&g_fault_callback, std::move(new_callback), std::memory_order_release);
+}
+
+void dispatch_registered_fault(const EntryFault &fault) {
+  auto callback = std::atomic_load_explicit(&g_fault_callback, std::memory_order_acquire);
+  if (callback && *callback) {
+    (*callback)(fault);
+  }
+}
+
+} // namespace archive_r

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

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "entry_fault_error.h"
+
+#include <cstring>
+#include <string>
+#include <utility>
+
+namespace archive_r {
+
+EntryFaultError::EntryFaultError(EntryFault fault)
+    : std::runtime_error(fault.message)
+    , _fault(std::move(fault)) {}
+
+EntryFaultError::EntryFaultError(EntryFault fault, const std::string &internal_message)
+    : std::runtime_error(internal_message.empty() ? fault.message : internal_message)
+    , _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));
+}
+
+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;
+}
+
+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 prefer_error_detail(const std::string &detail, const std::string &fallback) { return detail.empty() ? fallback : detail; }
+
+} // namespace archive_r

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/entry_fault.h"
+
+#include <stdexcept>
+#include <string>
+
+namespace archive_r {
+
+class EntryFaultError : public std::runtime_error {
+public:
+  explicit EntryFaultError(EntryFault fault);
+  EntryFaultError(EntryFault fault, const std::string &internal_message);
+
+  const EntryFault &fault() const noexcept { return _fault; }
+  const PathHierarchy &hierarchy() const noexcept { return _fault.hierarchy; }
+  int errno_value() const noexcept { return _fault.errno_value; }
+
+private:
+  EntryFault _fault;
+};
+
+EntryFaultError make_entry_fault_error(const std::string &message, PathHierarchy hierarchy = {}, int errno_value = 0);
+
+std::string format_errno_error(const std::string &prefix, int err);
+std::string format_path_errno_error(const std::string &action, const std::string &path, int err);
+std::string prefer_error_detail(const std::string &detail, const std::string &fallback);
+
+} // namespace archive_r

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

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/entry.h"
+#include "archive_stack_orchestrator.h"
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <sys/types.h> // for mode_t
+#include <unordered_set>
+
+namespace archive_r {
+
+// Entry implementation class - internal to Traverser
+class Entry::Impl {
+public:
+  // Unified constructor - receives metadata directly
+  // 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);
+
+  std::string name() const;
+  const PathHierarchy &path_hierarchy() const;
+  bool is_directory() const;
+  bool is_file() const;
+  uint64_t size() const;
+  size_t depth() const;
+  void set_descent(bool enabled);
+  bool descent_enabled() const;
+  void set_multi_volume_group(const std::string &base_name, const MultiVolumeGroupOptions &options);
+  ssize_t read(void *buffer, size_t length);
+  const EntryMetadataMap &metadata() const;
+  const EntryMetadataValue *metadata_value(const std::string &key) const;
+
+private:
+  PathHierarchy _path_hierarchy;
+
+  // Metadata only (no libarchive types)
+  uint64_t _size;
+  mode_t _filetype;
+  EntryMetadataMap _metadata;
+  bool _descend_enabled = true; // Flag to control automatic descent
+
+  std::shared_ptr<ArchiveStackOrchestrator> _orchestrator;               ///< Active orchestrator (shared with traverser or detached copy)
+  bool _shares_traverser_orchestrator = false;
+
+  mutable std::optional<ArchiveOption> _archive_options;
+
+  void emit_fault(const std::string &message, int errno_value = 0) const;
+  std::shared_ptr<ArchiveStackOrchestrator> ensure_orchestrator();
+};
+
+} // namespace archive_r

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

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "multi_volume_manager.h"
+
+#include "archive_r/path_hierarchy_utils.h"
+
+#include <algorithm>
+#include <utility>
+
+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) {
+  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; });
+
+  if (it == groups.end()) {
+    MultiVolumeGroup group;
+    group.base_name = base_name;
+    group.parent_hierarchy = parent_hierarchy;
+    group.ordering = ordering;
+    groups.push_back(std::move(group));
+    return groups.back();
+  }
+
+  MultiVolumeGroup &target = *it;
+  if (ordering == PathEntry::Parts::Ordering::Given) {
+    target.ordering = PathEntry::Parts::Ordering::Given;
+  }
+  return target;
+}
+
+bool MultiVolumeManager::pop_group_for_parent(const PathHierarchy &parent_hierarchy, MultiVolumeGroup &out_group) {
+  ParentGroupMap::iterator it = _multi_volume_groups.find(parent_hierarchy);
+  if (it == _multi_volume_groups.end() || it->second.empty()) {
+    return false;
+  }
+
+  out_group = it->second.front();
+  it->second.erase(it->second.begin());
+  if (it->second.empty()) {
+    _multi_volume_groups.erase(it);
+  }
+
+  return true;
+}
+
+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);
+  });
+  if (!exists) {
+    parts.push_back(entry_path);
+  }
+}
+
+bool MultiVolumeManager::pop_multi_volume_group(const PathHierarchy &current_hierarchy, PathHierarchy &multi_volume_hierarchy) {
+  MultiVolumeGroup group;
+  if (!pop_group_for_parent(current_hierarchy, group)) {
+    return false;
+  }
+
+  if (group.ordering != PathEntry::Parts::Ordering::Given) {
+    sort_hierarchies(group.parts);
+  }
+
+  multi_volume_hierarchy = merge_multi_volume_sources(group.parts);
+  multi_volume_hierarchy.back().multi_volume_parts_mut().ordering = group.ordering;
+  return true;
+}
+
+} // namespace archive_r

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

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/path_hierarchy.h"
+#include "archive_type.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace archive_r {
+
+class MultiVolumeManager {
+public:
+  struct MultiVolumeGroup {
+    std::vector<PathHierarchy> parts;
+    std::string base_name;
+    PathHierarchy parent_hierarchy;
+    PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural;
+  };
+
+  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);
+
+  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);
+
+  bool pop_group_for_parent(const PathHierarchy &parent_hierarchy, MultiVolumeGroup &out_group);
+
+  ParentGroupMap _multi_volume_groups;
+};
+
+} // namespace archive_r