archive_r_ruby 0.1.21 → 0.1.22

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

@@ -1,92 +1,92 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include <cstddef>
-#include <stdexcept>
-#include <string>
-#include <utility>
-#include <variant>
-#include <vector>
-
-namespace archive_r {
-
-/**
- * @brief Represents a single component within a logical path hierarchy.
- *
- * A component can be one of three shapes:
- * - single string value (most common)
- * - multi-volume part list (split archives that share a common base name)
- */
-class PathEntry {
-public:
-  struct Parts {
-    std::vector<std::string> values;
-    enum class Ordering { Natural, Given } ordering = Ordering::Natural;
-  };
-
-  PathEntry() = default;
-
-  explicit PathEntry(std::string value)
-      : _value(std::move(value)) {}
-
-  explicit PathEntry(Parts parts)
-      : _value(std::move(parts)) {}
-
-  static PathEntry single(std::string entry) { return PathEntry(std::move(entry)); }
-
-  static PathEntry multi_volume(std::vector<std::string> entries, Parts::Ordering ordering = Parts::Ordering::Natural) {
-    Parts parts{ std::move(entries), ordering };
-    if (parts.values.empty()) {
-      throw std::invalid_argument("multi-volume parts cannot be empty");
-    }
-    return PathEntry(std::move(parts));
-  }
-
-  bool is_single() const { return std::holds_alternative<std::string>(_value); }
-  bool is_multi_volume() const { return std::holds_alternative<Parts>(_value); }
-  const std::string &single_value() const { return std::get<std::string>(_value); }
-  const Parts &multi_volume_parts() const { return std::get<Parts>(_value); }
-  Parts &multi_volume_parts_mut() { return std::get<Parts>(_value); }
-
-private:
-  std::variant<std::string, Parts> _value;
-};
-
-using PathHierarchy = std::vector<PathEntry>;
-
-/**
- * Compare two entries using the ordering enforced throughout archive_r.
- *
- * Ordering rules:
- * 1. Entry categories are ordered single < multi-volume.
- * 2. Single entries compare by string value.
- * 3. Multi-volume entries first compare their ordering flag (Natural < Given),
- *    then compare corresponding part names lexicographically, finally by list length.
- */
-int compare_entries(const PathEntry &lhs, const PathEntry &rhs);
-
-/** Compare complete hierarchies lexicographically using compare_entries on each level. */
-int compare_hierarchies(const PathHierarchy &lhs, const PathHierarchy &rhs);
-
-/** Shorthand equality helpers for entries and hierarchies. */
-bool entries_equal(const PathEntry &lhs, const PathEntry &rhs);
-bool hierarchies_equal(const PathHierarchy &lhs, const PathHierarchy &rhs);
-
-/** Strict-weak-order functor suitable for associative containers. */
-struct PathHierarchyLess {
-  bool operator()(const PathHierarchy &lhs, const PathHierarchy &rhs) const;
-};
-
-/** Build a hierarchy containing a single leaf component. */
-PathHierarchy make_single_path(const std::string &root);
-
-/** Append helpers for single and multi-volume components. */
-void append_single(PathHierarchy &hierarchy, std::string value);
-void append_multi_volume(PathHierarchy &hierarchy, std::vector<std::string> parts, PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural);
-
-/** Extract prefix/slice helpers. */
-PathHierarchy pathhierarchy_prefix_until(const PathHierarchy &hierarchy, size_t inclusive_index);
-PathHierarchy parent_hierarchy(const PathHierarchy &hierarchy);
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include <cstddef>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace archive_r {
+
+/**
+ * @brief Represents a single component within a logical path hierarchy.
+ *
+ * A component can be one of three shapes:
+ * - single string value (most common)
+ * - multi-volume part list (split archives that share a common base name)
+ */
+class PathEntry {
+public:
+  struct Parts {
+    std::vector<std::string> values;
+    enum class Ordering { Natural, Given } ordering = Ordering::Natural;
+  };
+
+  PathEntry() = default;
+
+  explicit PathEntry(std::string value)
+      : _value(std::move(value)) {}
+
+  explicit PathEntry(Parts parts)
+      : _value(std::move(parts)) {}
+
+  static PathEntry single(std::string entry) { return PathEntry(std::move(entry)); }
+
+  static PathEntry multi_volume(std::vector<std::string> entries, Parts::Ordering ordering = Parts::Ordering::Natural) {
+    Parts parts{ std::move(entries), ordering };
+    if (parts.values.empty()) {
+      throw std::invalid_argument("multi-volume parts cannot be empty");
+    }
+    return PathEntry(std::move(parts));
+  }
+
+  bool is_single() const { return std::holds_alternative<std::string>(_value); }
+  bool is_multi_volume() const { return std::holds_alternative<Parts>(_value); }
+  const std::string &single_value() const { return std::get<std::string>(_value); }
+  const Parts &multi_volume_parts() const { return std::get<Parts>(_value); }
+  Parts &multi_volume_parts_mut() { return std::get<Parts>(_value); }
+
+private:
+  std::variant<std::string, Parts> _value;
+};
+
+using PathHierarchy = std::vector<PathEntry>;
+
+/**
+ * Compare two entries using the ordering enforced throughout archive_r.
+ *
+ * Ordering rules:
+ * 1. Entry categories are ordered single < multi-volume.
+ * 2. Single entries compare by string value.
+ * 3. Multi-volume entries first compare their ordering flag (Natural < Given),
+ *    then compare corresponding part names lexicographically, finally by list length.
+ */
+int compare_entries(const PathEntry &lhs, const PathEntry &rhs);
+
+/** Compare complete hierarchies lexicographically using compare_entries on each level. */
+int compare_hierarchies(const PathHierarchy &lhs, const PathHierarchy &rhs);
+
+/** Shorthand equality helpers for entries and hierarchies. */
+bool entries_equal(const PathEntry &lhs, const PathEntry &rhs);
+bool hierarchies_equal(const PathHierarchy &lhs, const PathHierarchy &rhs);
+
+/** Strict-weak-order functor suitable for associative containers. */
+struct PathHierarchyLess {
+  bool operator()(const PathHierarchy &lhs, const PathHierarchy &rhs) const;
+};
+
+/** Build a hierarchy containing a single leaf component. */
+PathHierarchy make_single_path(const std::string &root);
+
+/** Append helpers for single and multi-volume components. */
+void append_single(PathHierarchy &hierarchy, std::string value);
+void append_multi_volume(PathHierarchy &hierarchy, std::vector<std::string> parts, PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural);
+
+/** Extract prefix/slice helpers. */
+PathHierarchy pathhierarchy_prefix_until(const PathHierarchy &hierarchy, size_t inclusive_index);
+PathHierarchy parent_hierarchy(const PathHierarchy &hierarchy);
+} // namespace archive_r

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

@@ -1,36 +1,36 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include "archive_r/path_hierarchy.h"
-#include <cstddef>
-#include <string>
-#include <vector>
-
-namespace archive_r {
-
-/** Return pointer to the Nth single value of an entry (nullptr if absent). */
-const std::string *path_entry_component_at(const PathEntry &entry, std::size_t index);
-
-/** Convenience helpers for multi-volume PathHierarchy nodes. */
-std::size_t pathhierarchy_volume_size(const PathHierarchy &logical);
-std::string pathhierarchy_volume_entry_name(const PathHierarchy &logical, std::size_t index);
-bool pathhierarchy_is_multivolume(const PathHierarchy &hierarchy);
-PathHierarchy pathhierarchy_select_single_part(const PathHierarchy &logical, std::size_t index);
-
-/** Combine sibling hierarchies that differ only by their terminal part list. */
-PathHierarchy merge_multi_volume_sources(const std::vector<PathHierarchy> &sources);
-
-/** Sort hierarchies using PathHierarchyLess semantics. */
-void sort_hierarchies(std::vector<PathHierarchy> &hierarchies);
-
-/** Render helpers converting entries to flattened strings for diagnostics. */
-bool flatten_entry_to_string(const PathEntry &entry, std::string &output);
-bool entry_name_from_component(const PathEntry &entry, std::string &output);
-
-/** Human readable pretty-printers used in logging and debug output. */
-std::string path_entry_display(const PathEntry &entry);
-std::string hierarchy_display(const PathHierarchy &hierarchy);
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/path_hierarchy.h"
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace archive_r {
+
+/** Return pointer to the Nth single value of an entry (nullptr if absent). */
+const std::string *path_entry_component_at(const PathEntry &entry, std::size_t index);
+
+/** Convenience helpers for multi-volume PathHierarchy nodes. */
+std::size_t pathhierarchy_volume_size(const PathHierarchy &logical);
+std::string pathhierarchy_volume_entry_name(const PathHierarchy &logical, std::size_t index);
+bool pathhierarchy_is_multivolume(const PathHierarchy &hierarchy);
+PathHierarchy pathhierarchy_select_single_part(const PathHierarchy &logical, std::size_t index);
+
+/** Combine sibling hierarchies that differ only by their terminal part list. */
+PathHierarchy merge_multi_volume_sources(const std::vector<PathHierarchy> &sources);
+
+/** Sort hierarchies using PathHierarchyLess semantics. */
+void sort_hierarchies(std::vector<PathHierarchy> &hierarchies);
+
+/** Render helpers converting entries to flattened strings for diagnostics. */
+bool flatten_entry_to_string(const PathEntry &entry, std::string &output);
+bool entry_name_from_component(const PathEntry &entry, std::string &output);
+
+/** Human readable pretty-printers used in logging and debug 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

@@ -1,34 +1,34 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include <sys/types.h>
-
-#if defined(_WIN32)
-#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)
-using mode_t = unsigned short; // MSVC does not expose POSIX mode_t by default
-#define _MODE_T_DEFINED
-#endif
-#endif
-
-namespace archive_r {
-
-// Expose POSIX-like types within the archive_r namespace.
-// - On POSIX platforms, ssize_t/mode_t come from <sys/types.h>.
-// - On Windows, platform_compat provides fallback definitions above.
-#if defined(_WIN32)
-using ssize_t = SSIZE_T;
-using mode_t = unsigned short;
-#else
-using ssize_t = ::ssize_t;
-using mode_t = ::mode_t;
-#endif
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include <sys/types.h>
+
+#if defined(_WIN32)
+#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)
+using mode_t = unsigned short; // MSVC does not expose POSIX mode_t by default
+#define _MODE_T_DEFINED
+#endif
+#endif
+
+namespace archive_r {
+
+// Expose POSIX-like types within the archive_r namespace.
+// - On POSIX platforms, ssize_t/mode_t come from <sys/types.h>.
+// - On Windows, platform_compat provides fallback definitions above.
+#if defined(_WIN32)
+using ssize_t = SSIZE_T;
+using mode_t = unsigned short;
+#else
+using ssize_t = ::ssize_t;
+using mode_t = ::mode_t;
+#endif
+
+} // namespace archive_r

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

@@ -1,156 +1,156 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include "archive_r/entry_fault.h"
-#include "archive_r/path_hierarchy.h"
-#include "entry.h"
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace archive_r {
-
-struct TraverserOptions {
-  std::vector<std::string> passphrases;   ///< Passphrases for encrypted archives
-  std::vector<std::string> formats;       ///< Specific archive formats to enable (empty = all)
-  std::vector<std::string> metadata_keys; ///< Metadata keys to capture for entries
-  bool descend_archives = true;           ///< Whether to descend into archives by default
-};
-
-/**
- * @brief Iterator-based traversal for archives and directories
- *
- * Traverser provides a unified iterator-based interface for traversing
- * entries within archives and directories, including support for nested
- * archives and automatic descent.
- *
- * Supports multiple archive formats via libarchive (tar, zip, gzip, etc.)
- * and filesystem directories.
- *
- * Uses std::filesystem for directory traversal and ArchiveStackOrchestrator for archives.
- * @see Entry, ArchiveStackOrchestrator
- *
- * \par Inputs
- * - The input list must not be empty, and each PathHierarchy must not be empty.
- *   Violations throw std::invalid_argument.
- * - For the common single-root case, prefer make_single_path("...") or
- *   Traverser(const std::string&, ...).
- *
- * \par How Roots Are Interpreted
- * - If the root hierarchy is exactly one single path and it refers to a directory,
- *   Traverser enumerates it using std::filesystem::recursive_directory_iterator.
- * - Otherwise, Traverser attempts archive traversal using libarchive.
- *
- * \par Error Model (Exceptions vs Faults)
- * - Invalid arguments are reported via exceptions (std::invalid_argument).
- * - Recoverable data / I/O errors during archive traversal are reported via the
- *   global fault callback (EntryFault) and traversal continues.
- * - Directory traversal uses std::filesystem iterators; filesystem exceptions
- *   (e.g. std::filesystem::filesystem_error) may be thrown and are not converted
- *   to faults.
- *
- * \par Iterator Semantics
- * - Traverser::Iterator is an input iterator (single-pass).
- * - Dereferencing the end iterator throws std::logic_error.
- *
- * Usage:
- *   Traverser traverser({make_single_path("archive.tar.gz")});  // or directory path
- *   for (Entry& entry : traverser) {
- *       // Process entry
- *   }
- *
- * @note Thread Safety
- * Traverser instances are not thread-safe. To use the traverser in a
- * multi-threaded environment, create a separate Traverser instance for each
- * thread. Do not share a single instance across multiple threads.
- */
-class Traverser {
-public:
-  /**
-   * @brief Construct traverser for archives or directories
-   * @param paths Paths to archive files or directories
-   *
-   * 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
-   */
-  explicit Traverser(std::vector<PathHierarchy> paths, TraverserOptions options = {});
-
-  /**
-   * @brief Construct traverser for a single hierarchy
-   */
-  explicit Traverser(PathHierarchy path, TraverserOptions options = {});
-
-  /**
-   * @brief Construct traverser for a single archive or directory path
-   */
-  explicit Traverser(const std::string &path, TraverserOptions options = {});
-
-  ~Traverser();
-
-  // Non-copyable
-  Traverser(const Traverser &) = delete;
-  Traverser &operator=(const Traverser &) = delete;
-
-  // ========================================================================
-  // Iterator API
-  // ========================================================================
-
-  /**
-   * @brief Forward iterator for traversing entries
-   *
-   * Satisfies InputIterator requirements:
-   * - Move-only (non-copyable)
-   * - Equality comparable
-   * - Dereferenceable (returns Entry&)
-   * - Incrementable
-   */
-  class Iterator {
-  public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = Entry;
-    using difference_type = std::ptrdiff_t;
-    using pointer = Entry *;
-    using reference = Entry &;
-
-    reference operator*();
-    pointer operator->();
-    Iterator &operator++();
-    bool operator==(const Iterator &other) const;
-    bool operator!=(const Iterator &other) const;
-
-    ~Iterator();
-    Iterator(const Iterator &) = delete;
-    Iterator &operator=(const Iterator &) = delete;
-    Iterator(Iterator &&) noexcept;
-    Iterator &operator=(Iterator &&) noexcept;
-
-  private:
-    friend class Traverser;
-    class Impl;
-    std::unique_ptr<Impl> _impl;
-    explicit Iterator(std::unique_ptr<Impl> impl);
-  };
-
-  /**
-   * @brief Get iterator to first entry
-   * @return Iterator pointing to first entry
-   */
-  Iterator begin();
-
-  /**
-   * @brief Get end iterator
-   * @return End iterator (sentinel)
-   */
-  Iterator end();
-
-private:
-  std::vector<PathHierarchy> _initial_paths; ///< Initial paths provided to constructor
-  TraverserOptions _options;                 ///< Options controlling archive handling
-};
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/entry_fault.h"
+#include "archive_r/path_hierarchy.h"
+#include "entry.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace archive_r {
+
+struct TraverserOptions {
+  std::vector<std::string> passphrases;   ///< Passphrases for encrypted archives
+  std::vector<std::string> formats;       ///< Specific archive formats to enable (empty = all)
+  std::vector<std::string> metadata_keys; ///< Metadata keys to capture for entries
+  bool descend_archives = true;           ///< Whether to descend into archives by default
+};
+
+/**
+ * @brief Iterator-based traversal for archives and directories
+ *
+ * Traverser provides a unified iterator-based interface for traversing
+ * entries within archives and directories, including support for nested
+ * archives and automatic descent.
+ *
+ * Supports multiple archive formats via libarchive (tar, zip, gzip, etc.)
+ * and filesystem directories.
+ *
+ * Uses std::filesystem for directory traversal and ArchiveStackOrchestrator for archives.
+ * @see Entry, ArchiveStackOrchestrator
+ *
+ * \par Inputs
+ * - The input list must not be empty, and each PathHierarchy must not be empty.
+ *   Violations throw std::invalid_argument.
+ * - For the common single-root case, prefer make_single_path("...") or
+ *   Traverser(const std::string&, ...).
+ *
+ * \par How Roots Are Interpreted
+ * - If the root hierarchy is exactly one single path and it refers to a directory,
+ *   Traverser enumerates it using std::filesystem::recursive_directory_iterator.
+ * - Otherwise, Traverser attempts archive traversal using libarchive.
+ *
+ * \par Error Model (Exceptions vs Faults)
+ * - Invalid arguments are reported via exceptions (std::invalid_argument).
+ * - Recoverable data / I/O errors during archive traversal are reported via the
+ *   global fault callback (EntryFault) and traversal continues.
+ * - Directory traversal uses std::filesystem iterators; filesystem exceptions
+ *   (e.g. std::filesystem::filesystem_error) may be thrown and are not converted
+ *   to faults.
+ *
+ * \par Iterator Semantics
+ * - Traverser::Iterator is an input iterator (single-pass).
+ * - Dereferencing the end iterator throws std::logic_error.
+ *
+ * Usage:
+ *   Traverser traverser({make_single_path("archive.tar.gz")});  // or directory path
+ *   for (Entry& entry : traverser) {
+ *       // Process entry
+ *   }
+ *
+ * @note Thread Safety
+ * Traverser instances are not thread-safe. To use the traverser in a
+ * multi-threaded environment, create a separate Traverser instance for each
+ * thread. Do not share a single instance across multiple threads.
+ */
+class Traverser {
+public:
+  /**
+   * @brief Construct traverser for archives or directories
+   * @param paths Paths to archive files or directories
+   *
+   * 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
+   */
+  explicit Traverser(std::vector<PathHierarchy> paths, TraverserOptions options = {});
+
+  /**
+   * @brief Construct traverser for a single hierarchy
+   */
+  explicit Traverser(PathHierarchy path, TraverserOptions options = {});
+
+  /**
+   * @brief Construct traverser for a single archive or directory path
+   */
+  explicit Traverser(const std::string &path, TraverserOptions options = {});
+
+  ~Traverser();
+
+  // Non-copyable
+  Traverser(const Traverser &) = delete;
+  Traverser &operator=(const Traverser &) = delete;
+
+  // ========================================================================
+  // Iterator API
+  // ========================================================================
+
+  /**
+   * @brief Forward iterator for traversing entries
+   *
+   * Satisfies InputIterator requirements:
+   * - Move-only (non-copyable)
+   * - Equality comparable
+   * - Dereferenceable (returns Entry&)
+   * - Incrementable
+   */
+  class Iterator {
+  public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = Entry;
+    using difference_type = std::ptrdiff_t;
+    using pointer = Entry *;
+    using reference = Entry &;
+
+    reference operator*();
+    pointer operator->();
+    Iterator &operator++();
+    bool operator==(const Iterator &other) const;
+    bool operator!=(const Iterator &other) const;
+
+    ~Iterator();
+    Iterator(const Iterator &) = delete;
+    Iterator &operator=(const Iterator &) = delete;
+    Iterator(Iterator &&) noexcept;
+    Iterator &operator=(Iterator &&) noexcept;
+
+  private:
+    friend class Traverser;
+    class Impl;
+    std::unique_ptr<Impl> _impl;
+    explicit Iterator(std::unique_ptr<Impl> impl);
+  };
+
+  /**
+   * @brief Get iterator to first entry
+   * @return Iterator pointing to first entry
+   */
+  Iterator begin();
+
+  /**
+   * @brief Get end iterator
+   * @return End iterator (sentinel)
+   */
+  Iterator end();
+
+private:
+  std::vector<PathHierarchy> _initial_paths; ///< Initial paths provided to constructor
+  TraverserOptions _options;                 ///< Options controlling archive handling
+};
+
+} // namespace archive_r