archive_r_ruby 0.1.3 → 0.1.4

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

@@ -1,166 +1,166 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include <cstdint>
-#include <filesystem>
-#include <memory>
-#include <string>
-#include <sys/types.h>
-#include <vector>
-
-#ifdef _MSC_VER
-#include <BaseTsd.h>
-typedef SSIZE_T ssize_t;
-#endif
-
-#include "archive_r/entry_fault.h"
-#include "archive_r/entry_metadata.h"
-#include "archive_r/path_hierarchy.h"
-
-namespace archive_r {
-
-class ArchiveStackOrchestrator;
-
-struct MultiVolumeGroupOptions {
-  PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural;
-};
-
-/**
- * @brief Represents a single entry in an archive traversal
- *
- * Entry objects encapsulate all information about an archive entry including:
- * - Path information (path, path hierarchy)
- * - Metadata (size, type, timestamps)
- * - Content access (read operations)
- * - Multi-volume archive grouping support
- *
- * Entry objects are typically obtained from ArchiveTraverser::Iterator and
- * remain valid until the iterator advances.
- */
-class Entry {
-public:
-  /**
-   * @brief Get the entry name (last element of the path hierarchy)
-   * @return Entry name relative to its containing archive (e.g., "dir/subdir/file.txt" when the
-   *         hierarchy is {"outer/archive.zip", "dir/subdir/file.txt"})
-   */
-  std::string name() const;
-
-  /**
-   * @brief Get the entry path as a string
-   * @return Joined path including outer archives (e.g., "outer/archive.zip/dir/subdir/file.txt"
-   * when the hierarchy is {"outer/archive.zip", "dir/subdir/file.txt"})
-   */
-  std::string path() const;
-
-  /**
-   * @brief Get the entry path as a hierarchy of components
-   * @return Vector describing each descent step (e.g., {"outer/archive.zip",
-   * "dir/subdir/file.txt"})
-   */
-  const PathHierarchy &path_hierarchy() const;
-
-  /**
-   * @brief Check if entry is a directory
-   * @return true if entry represents a directory
-   */
-  bool is_directory() const;
-
-  /**
-   * @brief Check if entry is a regular file
-   * @return true if entry represents a regular file
-   */
-  bool is_file() const;
-
-  /**
-   * @brief Get the uncompressed size of the entry
-   * @return Size in bytes, or 0 if unknown
-   */
-  uint64_t size() const;
-
-  /**
-   * @brief Get the archive nesting depth
-   * @return 0 for top-level archive, 1 for nested archive, etc.
-   */
-  size_t depth() const;
-
-  /**
-   * @brief Read data from the entry
-   *
-  * Each call uses an internal ArchiveStackOrchestrator so reads remain valid even
-  * if the owning iterator advances or other traversal work continues in parallel.
-   *
-   * @param buffer Buffer to read data into
-   * @param length Maximum number of bytes to read
-   * @return Number of bytes read, 0 on EOF, -1 on error
-   */
-  ssize_t read(void *buffer, size_t length);
-
-  /**
-   * @brief Enable or disable automatic descent into this entry
-   * @param enabled true to descend (default), false to keep traversal at current level
-   */
-  void set_descent(bool enabled);
-
-  /**
-   * @brief Check if automatic descent is currently enabled
-   */
-  bool descent_enabled() const;
-
-  /**
-   * @brief Register this entry as part of a multi-volume (split) archive
-   * @param base_name Base name without the volume suffix (e.g., "archive.tar.gz")
-   * @param options Optional configuration (e.g., preserve Given ordering)
-   *
-   * Register each entry that belongs to the same multi-volume group so that
-   * once traversal of the parent archive finishes, the parts are combined
-   * automatically. The traverser will then descend into the combined archive
-   * and continue processing its contents.
-   *
-   * Example:
-   * @code
-   * for (Entry& entry : traverser) {
-   *     if (entry.path().find(".part") != std::string::npos) {
-   *         std::string base = extract_base_name(entry.path());
-   *         entry.set_multi_volume_group(base);
-   *     }
-   * }
-   * @endcode
-   */
-  void set_multi_volume_group(const std::string &base_name, const MultiVolumeGroupOptions &options = {});
-
-  /**
-   * @brief Get metadata captured for this entry
-   * @return Immutable metadata map keyed by libarchive field names
-   */
-  const EntryMetadataMap &metadata() const;
-
-  /**
-   * @brief Look up a metadata value by key
-   * @param key Metadata key (e.g., "uid", "mtime")
-   * @return Pointer to the stored value, or nullptr if not present
-   */
-  const EntryMetadataValue *find_metadata(const std::string &key) const;
-
-  static std::unique_ptr<Entry> create(PathHierarchy hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent);
-
-  // Copy/move operations
-  Entry(const Entry &);
-  Entry &operator=(const Entry &);
-  Entry(Entry &&) noexcept;
-  Entry &operator=(Entry &&) noexcept;
-
-  ~Entry();
-
-private:
-  class Impl;
-  std::unique_ptr<Impl> _impl;
-
-  // Private constructor - only friends can create Entry objects
-  explicit Entry(Impl *impl);
-  Entry(const PathHierarchy &hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent);
-};
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <sys/types.h>
+#include <vector>
+
+#ifdef _MSC_VER
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+#include "archive_r/entry_fault.h"
+#include "archive_r/entry_metadata.h"
+#include "archive_r/path_hierarchy.h"
+
+namespace archive_r {
+
+class ArchiveStackOrchestrator;
+
+struct MultiVolumeGroupOptions {
+  PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural;
+};
+
+/**
+ * @brief Represents a single entry in an archive traversal
+ *
+ * Entry objects encapsulate all information about an archive entry including:
+ * - Path information (path, path hierarchy)
+ * - Metadata (size, type, timestamps)
+ * - Content access (read operations)
+ * - Multi-volume archive grouping support
+ *
+ * Entry objects are typically obtained from ArchiveTraverser::Iterator and
+ * remain valid until the iterator advances.
+ */
+class Entry {
+public:
+  /**
+   * @brief Get the entry name (last element of the path hierarchy)
+   * @return Entry name relative to its containing archive (e.g., "dir/subdir/file.txt" when the
+   *         hierarchy is {"outer/archive.zip", "dir/subdir/file.txt"})
+   */
+  std::string name() const;
+
+  /**
+   * @brief Get the entry path as a string
+   * @return Joined path including outer archives (e.g., "outer/archive.zip/dir/subdir/file.txt"
+   * when the hierarchy is {"outer/archive.zip", "dir/subdir/file.txt"})
+   */
+  std::string path() const;
+
+  /**
+   * @brief Get the entry path as a hierarchy of components
+   * @return Vector describing each descent step (e.g., {"outer/archive.zip",
+   * "dir/subdir/file.txt"})
+   */
+  const PathHierarchy &path_hierarchy() const;
+
+  /**
+   * @brief Check if entry is a directory
+   * @return true if entry represents a directory
+   */
+  bool is_directory() const;
+
+  /**
+   * @brief Check if entry is a regular file
+   * @return true if entry represents a regular file
+   */
+  bool is_file() const;
+
+  /**
+   * @brief Get the uncompressed size of the entry
+   * @return Size in bytes, or 0 if unknown
+   */
+  uint64_t size() const;
+
+  /**
+   * @brief Get the archive nesting depth
+   * @return 0 for top-level archive, 1 for nested archive, etc.
+   */
+  size_t depth() const;
+
+  /**
+   * @brief Read data from the entry
+   *
+  * Each call uses an internal ArchiveStackOrchestrator so reads remain valid even
+  * if the owning iterator advances or other traversal work continues in parallel.
+   *
+   * @param buffer Buffer to read data into
+   * @param length Maximum number of bytes to read
+   * @return Number of bytes read, 0 on EOF, -1 on error
+   */
+  ssize_t read(void *buffer, size_t length);
+
+  /**
+   * @brief Enable or disable automatic descent into this entry
+   * @param enabled true to descend (default), false to keep traversal at current level
+   */
+  void set_descent(bool enabled);
+
+  /**
+   * @brief Check if automatic descent is currently enabled
+   */
+  bool descent_enabled() const;
+
+  /**
+   * @brief Register this entry as part of a multi-volume (split) archive
+   * @param base_name Base name without the volume suffix (e.g., "archive.tar.gz")
+   * @param options Optional configuration (e.g., preserve Given ordering)
+   *
+   * Register each entry that belongs to the same multi-volume group so that
+   * once traversal of the parent archive finishes, the parts are combined
+   * automatically. The traverser will then descend into the combined archive
+   * and continue processing its contents.
+   *
+   * Example:
+   * @code
+   * for (Entry& entry : traverser) {
+   *     if (entry.path().find(".part") != std::string::npos) {
+   *         std::string base = extract_base_name(entry.path());
+   *         entry.set_multi_volume_group(base);
+   *     }
+   * }
+   * @endcode
+   */
+  void set_multi_volume_group(const std::string &base_name, const MultiVolumeGroupOptions &options = {});
+
+  /**
+   * @brief Get metadata captured for this entry
+   * @return Immutable metadata map keyed by libarchive field names
+   */
+  const EntryMetadataMap &metadata() const;
+
+  /**
+   * @brief Look up a metadata value by key
+   * @param key Metadata key (e.g., "uid", "mtime")
+   * @return Pointer to the stored value, or nullptr if not present
+   */
+  const EntryMetadataValue *find_metadata(const std::string &key) const;
+
+  static std::unique_ptr<Entry> create(PathHierarchy hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent);
+
+  // Copy/move operations
+  Entry(const Entry &);
+  Entry &operator=(const Entry &);
+  Entry(Entry &&) noexcept;
+  Entry &operator=(Entry &&) noexcept;
+
+  ~Entry();
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> _impl;
+
+  // Private constructor - only friends can create Entry objects
+  explicit Entry(Impl *impl);
+  Entry(const PathHierarchy &hierarchy, std::shared_ptr<ArchiveStackOrchestrator> data_source_orchestrator, bool default_descent);
+};
+
+} // namespace archive_r

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

@@ -1,34 +1,34 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include "archive_r/path_hierarchy.h"
-
-#include <functional>
-#include <string>
-
-namespace archive_r {
-
-/** Describes a recoverable failure encountered while visiting an entry. */
-struct EntryFault {
-  PathHierarchy hierarchy; ///< Path hierarchy where the fault occurred
-  std::string message;     ///< Human readable description
-  int errno_value = 0;     ///< Optional errno captured from the failing API
-};
-
-/** Callback signature used to surface EntryFault notifications. */
-using FaultCallback = std::function<void(const EntryFault &)>;
-
-/**
- * @brief Register a global callback to receive EntryFault notifications.
- * Pass an empty std::function to clear the callback.
- */
-void register_fault_callback(FaultCallback callback);
-
-/**
- * @brief Dispatch a fault through the globally registered callback, if any.
- */
-void dispatch_registered_fault(const EntryFault &fault);
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/path_hierarchy.h"
+
+#include <functional>
+#include <string>
+
+namespace archive_r {
+
+/** Describes a recoverable failure encountered while visiting an entry. */
+struct EntryFault {
+  PathHierarchy hierarchy; ///< Path hierarchy where the fault occurred
+  std::string message;     ///< Human readable description
+  int errno_value = 0;     ///< Optional errno captured from the failing API
+};
+
+/** Callback signature used to surface EntryFault notifications. */
+using FaultCallback = std::function<void(const EntryFault &)>;
+
+/**
+ * @brief Register a global callback to receive EntryFault notifications.
+ * Pass an empty std::function to clear the callback.
+ */
+void register_fault_callback(FaultCallback callback);
+
+/**
+ * @brief Dispatch a fault through the globally registered callback, if any.
+ */
+void dispatch_registered_fault(const EntryFault &fault);
+
+} // namespace archive_r

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

@@ -1,56 +1,56 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <unordered_map>
-#include <variant>
-#include <vector>
-
-namespace archive_r {
-
-/** POSIX-style timestamp with sub-second precision. */
-struct EntryMetadataTime {
-  int64_t seconds;
-  int32_t nanoseconds;
-};
-
-/** Sparse file chunk (offset + stored length). */
-struct EntryMetadataSparseChunk {
-  int64_t offset;
-  int64_t length;
-};
-
-/** Extended attribute key/value pair. */
-struct EntryMetadataXattr {
-  std::string name;
-  std::vector<uint8_t> value;
-};
-
-/** Generic digest (algorithm + raw bytes). */
-struct EntryMetadataDigest {
-  std::string algorithm;
-  std::vector<uint8_t> value;
-};
-
-/** Device identifiers for special files. */
-struct EntryMetadataDeviceNumbers {
-  uint64_t major;
-  uint64_t minor;
-};
-
-/** BSD-style file flags (bits to set/clear). */
-struct EntryMetadataFileFlags {
-  uint64_t set;
-  uint64_t clear;
-};
-
-using EntryMetadataValue = std::variant<std::monostate, bool, int64_t, uint64_t, std::string, std::vector<uint8_t>, EntryMetadataTime, EntryMetadataDeviceNumbers, EntryMetadataFileFlags,
-                                        std::vector<EntryMetadataXattr>, std::vector<EntryMetadataSparseChunk>, std::vector<EntryMetadataDigest>>;
-
-/** Unordered map storing metadata captured during traversal. */
-using EntryMetadataMap = std::unordered_map<std::string, EntryMetadataValue>;
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace archive_r {
+
+/** POSIX-style timestamp with sub-second precision. */
+struct EntryMetadataTime {
+  int64_t seconds;
+  int32_t nanoseconds;
+};
+
+/** Sparse file chunk (offset + stored length). */
+struct EntryMetadataSparseChunk {
+  int64_t offset;
+  int64_t length;
+};
+
+/** Extended attribute key/value pair. */
+struct EntryMetadataXattr {
+  std::string name;
+  std::vector<uint8_t> value;
+};
+
+/** Generic digest (algorithm + raw bytes). */
+struct EntryMetadataDigest {
+  std::string algorithm;
+  std::vector<uint8_t> value;
+};
+
+/** Device identifiers for special files. */
+struct EntryMetadataDeviceNumbers {
+  uint64_t major;
+  uint64_t minor;
+};
+
+/** BSD-style file flags (bits to set/clear). */
+struct EntryMetadataFileFlags {
+  uint64_t set;
+  uint64_t clear;
+};
+
+using EntryMetadataValue = std::variant<std::monostate, bool, int64_t, uint64_t, std::string, std::vector<uint8_t>, EntryMetadataTime, EntryMetadataDeviceNumbers, EntryMetadataFileFlags,
+                                        std::vector<EntryMetadataXattr>, std::vector<EntryMetadataSparseChunk>, std::vector<EntryMetadataDigest>>;
+
+/** Unordered map storing metadata captured during traversal. */
+using EntryMetadataMap = std::unordered_map<std::string, EntryMetadataValue>;
+
+} // namespace archive_r

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

@@ -1,46 +1,46 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2025 archive_r Team
-
-#pragma once
-
-#include "archive_r/data_stream.h"
-#include "archive_r/path_hierarchy.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-
-namespace archive_r {
-
-class MultiVolumeStreamBase : public IDataStream {
-public:
-  ~MultiVolumeStreamBase() override;
-
-  ssize_t read(void *buffer, size_t size) override;
-  void rewind() override;
-  bool at_end() const override;
-  int64_t seek(int64_t offset, int whence) override;
-  int64_t tell() const override;
-  bool can_seek() const override { return _supports_seek; }
-  PathHierarchy source_hierarchy() const override { return _logical_path; }
-
-protected:
-  MultiVolumeStreamBase(PathHierarchy logical_path, bool supports_seek);
-
-  virtual void open_single_part(const PathHierarchy &single_part) = 0;
-  virtual void close_single_part() = 0;
-  virtual ssize_t read_from_single_part(void *buffer, size_t size) = 0;
-  virtual int64_t seek_within_single_part(int64_t offset, int whence) = 0;
-  virtual int64_t size_of_single_part(const PathHierarchy &single_part) = 0;
-
-  PathHierarchy _logical_path;
-  void deactivate_active_part();
-
-private:
-  friend struct Impl;
-  struct Impl;
-  std::unique_ptr<Impl> _impl;
-  const bool _supports_seek;
-};
-
-} // namespace archive_r
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/data_stream.h"
+#include "archive_r/path_hierarchy.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+namespace archive_r {
+
+class MultiVolumeStreamBase : public IDataStream {
+public:
+  ~MultiVolumeStreamBase() override;
+
+  ssize_t read(void *buffer, size_t size) override;
+  void rewind() override;
+  bool at_end() const override;
+  int64_t seek(int64_t offset, int whence) override;
+  int64_t tell() const override;
+  bool can_seek() const override { return _supports_seek; }
+  PathHierarchy source_hierarchy() const override { return _logical_path; }
+
+protected:
+  MultiVolumeStreamBase(PathHierarchy logical_path, bool supports_seek);
+
+  virtual void open_single_part(const PathHierarchy &single_part) = 0;
+  virtual void close_single_part() = 0;
+  virtual ssize_t read_from_single_part(void *buffer, size_t size) = 0;
+  virtual int64_t seek_within_single_part(int64_t offset, int whence) = 0;
+  virtual int64_t size_of_single_part(const PathHierarchy &single_part) = 0;
+
+  PathHierarchy _logical_path;
+  void deactivate_active_part();
+
+private:
+  friend struct Impl;
+  struct Impl;
+  std::unique_ptr<Impl> _impl;
+  const bool _supports_seek;
+};
+
+} // namespace archive_r