archive_r_ruby 0.1.20 → 0.1.22

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

@@ -1,110 +1,110 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#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 <array>
-#include <cstddef>
-#include <exception>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace archive_r {
-
-// ============================================================================
-// StreamArchive Interface
-// ============================================================================
-
-class StreamArchive : public Archive {
-public:
-  explicit StreamArchive(std::shared_ptr<IDataStream> stream, ArchiveOption options = {});
-
-  ~StreamArchive() override;
-
-  void open_archive() override;
-  void rewind() override;
-
-  PathHierarchy source_hierarchy() const;
-  std::shared_ptr<StreamArchive> parent_archive() const;
-
-  std::shared_ptr<IDataStream> get_stream() const { return _stream; }
-
-private:
-  static la_ssize_t read_callback_bridge(struct archive *a, void *client_data, const void **buff);
-  static la_int64_t seek_callback_bridge(struct archive *a, void *client_data, la_int64_t request, int whence);
-  static la_int64_t skip_callback_bridge(struct archive *a, void *client_data, la_int64_t request);
-
-  static constexpr size_t BUFFER_SIZE = 65536;
-  std::shared_ptr<IDataStream> _stream;
-  std::array<char, BUFFER_SIZE> _buffer;
-  ArchiveOption _options;
-};
-
-// ============================================================================
-// EntryPayloadStream Interface
-// ============================================================================
-
-class EntryPayloadStream : public MultiVolumeStreamBase {
-public:
-  EntryPayloadStream(std::shared_ptr<StreamArchive> parent_archive, PathHierarchy logical_path);
-  ~EntryPayloadStream() override;
-
-  std::shared_ptr<StreamArchive> parent_archive() const;
-  void rewind() override;
-
-private:
-  std::shared_ptr<StreamArchive> _parent_archive;
-
-  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;
-};
-
-// ============================================================================
-// ArchiveStackCursor Interface
-// ============================================================================
-
-struct ArchiveStackCursor {
-
-  ArchiveStackCursor();
-
-  void configure(const ArchiveOption &options);
-  void reset();
-  bool has_stream() const { return _current_stream != nullptr; }
-
-  bool descend();
-  bool ascend();
-  bool next();
-  bool synchronize_to_hierarchy(const PathHierarchy &hierarchy);
-  ssize_t read(void *buffer, size_t len);
-
-  size_t depth() const {
-    size_t d = 0;
-    auto a = _current_archive;
-    while (a) {
-      d++;
-      a = a->parent_archive();
-    }
-    return d;
-  }
-
-  StreamArchive *current_archive();
-
-  PathHierarchy current_entry_hierarchy();
-
-  std::shared_ptr<IDataStream> create_stream(const PathHierarchy &hierarchy);
-
-  ArchiveOption options_snapshot;
-
-private:
-  std::shared_ptr<IDataStream> _current_stream;
-  std::shared_ptr<StreamArchive> _current_archive;
-};
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#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 <array>
+#include <cstddef>
+#include <exception>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace archive_r {
+
+// ============================================================================
+// StreamArchive Interface
+// ============================================================================
+
+class StreamArchive : public Archive {
+public:
+  explicit StreamArchive(std::shared_ptr<IDataStream> stream, ArchiveOption options = {});
+
+  ~StreamArchive() override;
+
+  void open_archive() override;
+  void rewind() override;
+
+  PathHierarchy source_hierarchy() const;
+  std::shared_ptr<StreamArchive> parent_archive() const;
+
+  std::shared_ptr<IDataStream> get_stream() const { return _stream; }
+
+private:
+  static la_ssize_t read_callback_bridge(struct archive *a, void *client_data, const void **buff);
+  static la_int64_t seek_callback_bridge(struct archive *a, void *client_data, la_int64_t request, int whence);
+  static la_int64_t skip_callback_bridge(struct archive *a, void *client_data, la_int64_t request);
+
+  static constexpr size_t BUFFER_SIZE = 65536;
+  std::shared_ptr<IDataStream> _stream;
+  std::array<char, BUFFER_SIZE> _buffer;
+  ArchiveOption _options;
+};
+
+// ============================================================================
+// EntryPayloadStream Interface
+// ============================================================================
+
+class EntryPayloadStream : public MultiVolumeStreamBase {
+public:
+  EntryPayloadStream(std::shared_ptr<StreamArchive> parent_archive, PathHierarchy logical_path);
+  ~EntryPayloadStream() override;
+
+  std::shared_ptr<StreamArchive> parent_archive() const;
+  void rewind() override;
+
+private:
+  std::shared_ptr<StreamArchive> _parent_archive;
+
+  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;
+};
+
+// ============================================================================
+// ArchiveStackCursor Interface
+// ============================================================================
+
+struct ArchiveStackCursor {
+
+  ArchiveStackCursor();
+
+  void configure(const ArchiveOption &options);
+  void reset();
+  bool has_stream() const { return _current_stream != nullptr; }
+
+  bool descend();
+  bool ascend();
+  bool next();
+  bool synchronize_to_hierarchy(const PathHierarchy &hierarchy);
+  ssize_t read(void *buffer, size_t len);
+
+  size_t depth() const {
+    size_t d = 0;
+    auto a = _current_archive;
+    while (a) {
+      d++;
+      a = a->parent_archive();
+    }
+    return d;
+  }
+
+  StreamArchive *current_archive();
+
+  PathHierarchy current_entry_hierarchy();
+
+  std::shared_ptr<IDataStream> create_stream(const PathHierarchy &hierarchy);
+
+  ArchiveOption options_snapshot;
+
+private:
+  std::shared_ptr<IDataStream> _current_stream;
+  std::shared_ptr<StreamArchive> _current_archive;
+};
+
+} // namespace archive_r

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

@@ -1,161 +1,161 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#include "archive_stack_orchestrator.h"
-#include "archive_r/entry_fault.h"
-#include "archive_r/path_hierarchy_utils.h"
-#include "system_file_stream.h"
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdio>
-#include <exception>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-#include <typeinfo>
-#include <utility>
-
-namespace archive_r {
-
-ArchiveStackOrchestrator::ArchiveStackOrchestrator(const ArchiveOption &options)
-    : _archive_options(options) {
-  _head.configure(_archive_options);
-}
-
-ArchiveStackOrchestrator::~ArchiveStackOrchestrator() = default;
-
-size_t ArchiveStackOrchestrator::depth() const { return _head.depth(); }
-
-StreamArchive *ArchiveStackOrchestrator::current_archive() { return _head.current_archive(); }
-
-// Drives the traversal state machine:
-// 1. Optionally descend into the current entry when requested.
-// 2. Attempt to advance within the active archive; report faults but keep looping.
-// 3. Drain any pending multi-volume groups before bubbling up to the parent so multipart
-//    archives are consumed contiguously.
-// 4. When leaving a multi-volume context, rewind the parent archive by skipping to EOF to
-//    avoid re-reading already processed entries.
-bool ArchiveStackOrchestrator::advance(bool descend_request) {
-  bool request_descend = descend_request;
-
-  while (true) {
-    if (depth() == 0) {
-      return false;
-    }
-    try {
-      if (request_descend) {
-        request_descend = false;
-        _head.descend();
-      }
-    } catch (const EntryFaultError &error) {
-      dispatch_fault(error.fault());
-      continue;
-    }
-
-    try {
-      if (_head.next()) {
-        return true;
-      }
-    } catch (const EntryFaultError &error) {
-      dispatch_fault(error.fault());
-      continue;
-    }
-
-    try {
-      // Consume any pending multi-volume siblings so we do not return to the parent mid-series.
-      if (descend_pending_multi_volumes()) {
-        continue;
-      }
-    } catch (const EntryFaultError &error) {
-      dispatch_fault(error.fault());
-    }
-
-    PathHierarchy prev_ascend_hierarchy = _head.current_entry_hierarchy();
-    _head.ascend();
-
-    if (!pathhierarchy_is_multivolume(prev_ascend_hierarchy)) {
-      continue;
-    }
-
-    try {
-      // If same-level multi-volume siblings remain, keep draining them before touching the parent next().
-      if (descend_pending_multi_volumes()) {
-        continue;
-      }
-    } catch (const EntryFaultError &error) {
-      dispatch_fault(error.fault());
-    }
-    try {
-      StreamArchive *archive = _head.current_archive();
-      if (archive) {
-        // After all volumes are processed, push the parent back to EOF to avoid duplicate next().
-        archive->skip_to_eof();
-      }
-    } catch (const EntryFaultError &error) {
-      dispatch_fault(error.fault());
-    }
-  }
-}
-
-const std::string &ArchiveStackOrchestrator::current_entryname() {
-  StreamArchive *archive = current_archive();
-  if (!archive) {
-    static const std::string empty;
-    return empty;
-  }
-  return archive->current_entryname;
-}
-
-PathHierarchy ArchiveStackOrchestrator::current_entry_hierarchy() { return _head.current_entry_hierarchy(); }
-
-bool ArchiveStackOrchestrator::synchronize_to_hierarchy(const PathHierarchy &path_hierarchy) {
-  try {
-    _head.synchronize_to_hierarchy(path_hierarchy);
-    return true;
-  } catch (const EntryFaultError &error) {
-    dispatch_fault(error.fault());
-    return false;
-  }
-}
-
-ssize_t ArchiveStackOrchestrator::read_head(void *buff, size_t len) {
-  try {
-    return _head.read(buff, len);
-  } catch (const EntryFaultError &error) {
-    dispatch_fault(error.fault());
-  }
-
-  return -1;
-}
-
-void ArchiveStackOrchestrator::mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name, PathEntry::Parts::Ordering ordering) {
-  _multi_volume_manager.mark_entry_as_multi_volume(entry_path, base_name, ordering);
-}
-
-bool ArchiveStackOrchestrator::descend_pending_multi_volumes() {
-  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;
-}
-
-void ArchiveStackOrchestrator::open_root_hierarchy(const PathHierarchy &root_hierarchy) {
-  _head.synchronize_to_hierarchy(root_hierarchy);
-  _head.descend();
-}
-
-void ArchiveStackOrchestrator::dispatch_fault(EntryFault fault) {
-  if (fault.hierarchy.empty()) {
-    fault.hierarchy = _head.current_entry_hierarchy();
-  }
-
-  dispatch_registered_fault(fault);
-}
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_stack_orchestrator.h"
+#include "archive_r/entry_fault.h"
+#include "archive_r/path_hierarchy_utils.h"
+#include "system_file_stream.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdio>
+#include <exception>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <typeinfo>
+#include <utility>
+
+namespace archive_r {
+
+ArchiveStackOrchestrator::ArchiveStackOrchestrator(const ArchiveOption &options)
+    : _archive_options(options) {
+  _head.configure(_archive_options);
+}
+
+ArchiveStackOrchestrator::~ArchiveStackOrchestrator() = default;
+
+size_t ArchiveStackOrchestrator::depth() const { return _head.depth(); }
+
+StreamArchive *ArchiveStackOrchestrator::current_archive() { return _head.current_archive(); }
+
+// Drives the traversal state machine:
+// 1. Optionally descend into the current entry when requested.
+// 2. Attempt to advance within the active archive; report faults but keep looping.
+// 3. Drain any pending multi-volume groups before bubbling up to the parent so multipart
+//    archives are consumed contiguously.
+// 4. When leaving a multi-volume context, rewind the parent archive by skipping to EOF to
+//    avoid re-reading already processed entries.
+bool ArchiveStackOrchestrator::advance(bool descend_request) {
+  bool request_descend = descend_request;
+
+  while (true) {
+    if (depth() == 0) {
+      return false;
+    }
+    try {
+      if (request_descend) {
+        request_descend = false;
+        _head.descend();
+      }
+    } catch (const EntryFaultError &error) {
+      dispatch_fault(error.fault());
+      continue;
+    }
+
+    try {
+      if (_head.next()) {
+        return true;
+      }
+    } catch (const EntryFaultError &error) {
+      dispatch_fault(error.fault());
+      continue;
+    }
+
+    try {
+      // Consume any pending multi-volume siblings so we do not return to the parent mid-series.
+      if (descend_pending_multi_volumes()) {
+        continue;
+      }
+    } catch (const EntryFaultError &error) {
+      dispatch_fault(error.fault());
+    }
+
+    PathHierarchy prev_ascend_hierarchy = _head.current_entry_hierarchy();
+    _head.ascend();
+
+    if (!pathhierarchy_is_multivolume(prev_ascend_hierarchy)) {
+      continue;
+    }
+
+    try {
+      // If same-level multi-volume siblings remain, keep draining them before touching the parent next().
+      if (descend_pending_multi_volumes()) {
+        continue;
+      }
+    } catch (const EntryFaultError &error) {
+      dispatch_fault(error.fault());
+    }
+    try {
+      StreamArchive *archive = _head.current_archive();
+      if (archive) {
+        // After all volumes are processed, push the parent back to EOF to avoid duplicate next().
+        archive->skip_to_eof();
+      }
+    } catch (const EntryFaultError &error) {
+      dispatch_fault(error.fault());
+    }
+  }
+}
+
+const std::string &ArchiveStackOrchestrator::current_entryname() {
+  StreamArchive *archive = current_archive();
+  if (!archive) {
+    static const std::string empty;
+    return empty;
+  }
+  return archive->current_entryname;
+}
+
+PathHierarchy ArchiveStackOrchestrator::current_entry_hierarchy() { return _head.current_entry_hierarchy(); }
+
+bool ArchiveStackOrchestrator::synchronize_to_hierarchy(const PathHierarchy &path_hierarchy) {
+  try {
+    _head.synchronize_to_hierarchy(path_hierarchy);
+    return true;
+  } catch (const EntryFaultError &error) {
+    dispatch_fault(error.fault());
+    return false;
+  }
+}
+
+ssize_t ArchiveStackOrchestrator::read_head(void *buff, size_t len) {
+  try {
+    return _head.read(buff, len);
+  } catch (const EntryFaultError &error) {
+    dispatch_fault(error.fault());
+  }
+
+  return -1;
+}
+
+void ArchiveStackOrchestrator::mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name, PathEntry::Parts::Ordering ordering) {
+  _multi_volume_manager.mark_entry_as_multi_volume(entry_path, base_name, ordering);
+}
+
+bool ArchiveStackOrchestrator::descend_pending_multi_volumes() {
+  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;
+}
+
+void ArchiveStackOrchestrator::open_root_hierarchy(const PathHierarchy &root_hierarchy) {
+  _head.synchronize_to_hierarchy(root_hierarchy);
+  _head.descend();
+}
+
+void ArchiveStackOrchestrator::dispatch_fault(EntryFault fault) {
+  if (fault.hierarchy.empty()) {
+    fault.hierarchy = _head.current_entry_hierarchy();
+  }
+
+  dispatch_registered_fault(fault);
+}
+
+} // namespace archive_r

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

@@ -1,53 +1,53 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include "archive_r/path_hierarchy.h"
-#include "archive_r/platform_compat.h"
-#include "archive_stack_cursor.h"
-#include "archive_type.h"
-#include "entry_fault_error.h"
-#include "multi_volume_manager.h"
-#include <limits>
-#include <memory>
-#include <string>
-#include <unordered_set>
-
-namespace archive_r {
-
-class ArchiveStackOrchestrator {
-public:
-  explicit ArchiveStackOrchestrator(const ArchiveOption &options = {});
-  ArchiveStackOrchestrator(const ArchiveStackOrchestrator &) = delete;
-  ArchiveStackOrchestrator &operator=(const ArchiveStackOrchestrator &) = delete;
-
-  ~ArchiveStackOrchestrator();
-
-  void open_root_hierarchy(const PathHierarchy &root_hierarchy);
-
-  bool advance(bool descend_request = true);
-  const std::string &current_entryname();
-
-  size_t depth() const;
-  PathHierarchy current_entry_hierarchy();
-  bool synchronize_to_hierarchy(const PathHierarchy &path_hierarchy);
-
-  StreamArchive *current_archive();
-  ssize_t read_head(void *buff, size_t len);
-
-  const std::unordered_set<std::string> &metadata_keys() const { return _archive_options.metadata_keys; }
-  const ArchiveOption &options() const { return _archive_options; }
-
-  void mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name, PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural);
-  bool descend_pending_multi_volumes();
-
-private:
-  ArchiveOption _archive_options;
-  ArchiveStackCursor _head;
-  MultiVolumeManager _multi_volume_manager;
-
-  void dispatch_fault(EntryFault fault);
-};
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/path_hierarchy.h"
+#include "archive_r/platform_compat.h"
+#include "archive_stack_cursor.h"
+#include "archive_type.h"
+#include "entry_fault_error.h"
+#include "multi_volume_manager.h"
+#include <limits>
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+namespace archive_r {
+
+class ArchiveStackOrchestrator {
+public:
+  explicit ArchiveStackOrchestrator(const ArchiveOption &options = {});
+  ArchiveStackOrchestrator(const ArchiveStackOrchestrator &) = delete;
+  ArchiveStackOrchestrator &operator=(const ArchiveStackOrchestrator &) = delete;
+
+  ~ArchiveStackOrchestrator();
+
+  void open_root_hierarchy(const PathHierarchy &root_hierarchy);
+
+  bool advance(bool descend_request = true);
+  const std::string &current_entryname();
+
+  size_t depth() const;
+  PathHierarchy current_entry_hierarchy();
+  bool synchronize_to_hierarchy(const PathHierarchy &path_hierarchy);
+
+  StreamArchive *current_archive();
+  ssize_t read_head(void *buff, size_t len);
+
+  const std::unordered_set<std::string> &metadata_keys() const { return _archive_options.metadata_keys; }
+  const ArchiveOption &options() const { return _archive_options; }
+
+  void mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name, PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural);
+  bool descend_pending_multi_volumes();
+
+private:
+  ArchiveOption _archive_options;
+  ArchiveStackCursor _head;
+  MultiVolumeManager _multi_volume_manager;
+
+  void dispatch_fault(EntryFault fault);
+};
+
+} // namespace archive_r