archive_r_ruby 0.1.3 → 0.1.4

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

@@ -1,109 +1,109 @@
-// 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)
- * - nested list of child entries (used for synthetic grouping)
- */
-class PathEntry {
-public:
-  struct Parts {
-    std::vector<std::string> values;
-    enum class Ordering { Natural, Given } ordering = Ordering::Natural;
-  };
-
-  using NodeList = std::vector<PathEntry>;
-
-  PathEntry() = default;
-
-  explicit PathEntry(std::string value)
-      : _value(std::move(value)) {}
-
-  explicit PathEntry(Parts parts)
-      : _value(std::move(parts)) {}
-
-  explicit PathEntry(NodeList nodes)
-      : _value(std::move(nodes)) {}
-
-  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));
-  }
-
-  static PathEntry nested(NodeList hierarchies) {
-    if (hierarchies.empty()) {
-      throw std::invalid_argument("nested hierarchies cannot be empty");
-    }
-    return PathEntry(std::move(hierarchies));
-  }
-
-  bool is_single() const { return std::holds_alternative<std::string>(_value); }
-  bool is_multi_volume() const { return std::holds_alternative<Parts>(_value); }
-  bool is_nested() const { return std::holds_alternative<NodeList>(_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); }
-  const NodeList &nested_nodes() const { return std::get<NodeList>(_value); }
-  NodeList &nested_nodes_mut() { return std::get<NodeList>(_value); }
-
-private:
-  std::variant<std::string, Parts, NodeList> _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 < nested node-list.
- * 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.
- * 4. Nested node-lists compare child entries pairwise using the same rules.
- */
-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)
+ * - nested list of child entries (used for synthetic grouping)
+ */
+class PathEntry {
+public:
+  struct Parts {
+    std::vector<std::string> values;
+    enum class Ordering { Natural, Given } ordering = Ordering::Natural;
+  };
+
+  using NodeList = std::vector<PathEntry>;
+
+  PathEntry() = default;
+
+  explicit PathEntry(std::string value)
+      : _value(std::move(value)) {}
+
+  explicit PathEntry(Parts parts)
+      : _value(std::move(parts)) {}
+
+  explicit PathEntry(NodeList nodes)
+      : _value(std::move(nodes)) {}
+
+  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));
+  }
+
+  static PathEntry nested(NodeList hierarchies) {
+    if (hierarchies.empty()) {
+      throw std::invalid_argument("nested hierarchies cannot be empty");
+    }
+    return PathEntry(std::move(hierarchies));
+  }
+
+  bool is_single() const { return std::holds_alternative<std::string>(_value); }
+  bool is_multi_volume() const { return std::holds_alternative<Parts>(_value); }
+  bool is_nested() const { return std::holds_alternative<NodeList>(_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); }
+  const NodeList &nested_nodes() const { return std::get<NodeList>(_value); }
+  NodeList &nested_nodes_mut() { return std::get<NodeList>(_value); }
+
+private:
+  std::variant<std::string, Parts, NodeList> _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 < nested node-list.
+ * 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.
+ * 4. Nested node-lists compare child entries pairwise using the same rules.
+ */
+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,37 +1,37 @@
-// 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,19 +1,19 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include <sys/types.h>
-
-#if defined(_WIN32)
-#  include <sys/stat.h>
-#  if !defined(_SSIZE_T_DEFINED)
-#    include <BaseTsd.h>
-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
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include <sys/types.h>
+
+#if defined(_WIN32)
+#  include <sys/stat.h>
+#  if !defined(_SSIZE_T_DEFINED)
+#    include <BaseTsd.h>
+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

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

@@ -1,122 +1,122 @@
-// 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
- *
- * 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")});
-   */
-  explicit Traverser(std::vector<PathHierarchy> paths, 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
+ *
+ * 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")});
+   */
+  explicit Traverser(std::vector<PathHierarchy> paths, 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