archive_r_ruby 0.1.3 → 0.1.4

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

@@ -1,32 +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
+// 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

@@ -1,57 +1,57 @@
-// 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 <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
+// 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 <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

@@ -1,81 +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
+// 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

@@ -1,41 +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
+// 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