archive_r_ruby 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ef63ef41cb26313bcc87243183c84d78e9b8fbc14ae05dd76b3db70b8f0fa48
-  data.tar.gz: f4a2cb797ce90ee25cd95f033df55a71c52db54376931bdd6e531b2ba493baf1
+  metadata.gz: c84dab51e8d84438b6eca7d3d96baa9398ea8606307e423b2416b7f12f263ecf
+  data.tar.gz: 2b1df674056604436d193e8bfa871bfb823a41c2ba0edc6dd220d30c958f5ef0
 SHA512:
-  metadata.gz: 55ab5d4f7b2d7636bdf3fb46a0bc562dc1e445eed7c14a6b217888982d38cc59d68f0791b69911c47ba20ec482e2dac31504ee5a22189acb434c972868b81973
-  data.tar.gz: 32993a36c25247c88ff17d9b577fba22f5f75516964e2176f6dc6e25df4892eb5ea422df44d2b7da89b3c5095ee045805c67b137968838af70123b4d60364ece
+  metadata.gz: 15230cc63edf0704c6d7fd129b0fd5460eb42c474c34eeb5cd6ce834095819ea5202541fdada77a00f4aa63c0379fb152c8c10047b4386a02522858c6579ab71
+  data.tar.gz: 8ec342c7bb690af3daeeb4774db7e2ab838273bc36bbb964fbe3cb825cddb0963d1700948e03c5cb1dc7b4ece6f513d711a42e7e4cbee5e4cc061586657d9306

data/{LICENSE → LICENSE.txt}

@@ -1,5 +1,5 @@
 archive_r License
-Version: 0.1.0 (2025-10-25)
+Version: 0.1.2 (2025-12-02)
 
 ----------------------------------------
 Primary License
@@ -44,13 +44,34 @@ License shown above.
    - Purpose: header-only binding generator for the Python extension module.
    - License: BSD-style License (https://github.com/pybind/pybind11)
 
-3. rake (development dependency for Ruby bindings)
-   - Purpose: build and release tasks for the Ruby gem.
-   - License: MIT License (https://github.com/ruby/rake)
+The following components are redistributed only because libarchive (bundled with archive_r) depends on them at runtime:
 
-4. minitest (development dependency for Ruby bindings)
-   - Purpose: unit testing framework for the Ruby gem.
-   - License: MIT License (https://github.com/minitest/minitest)
+3. zlib
+   - Purpose: libarchive dependency providing DEFLATE compression; bundled inside archive_r binaries and wheels because libarchive requires it.
+   - License: zlib License (https://zlib.net/zlib_license.html)
 
+4. bzip2
+   - Purpose: libarchive dependency providing bzip2 compression support; distributed with archive_r artifacts.
+   - License: BSD-style license (https://sourceware.org/bzip2/)
+
+5. liblzma (XZ Utils)
+   - Purpose: libarchive dependency providing LZMA/XZ compression; included with archive_r packages.
+   - License: Public Domain + GNU LGPLv2.1+ (https://tukaani.org/xz/)
+
+6. libxml2
+   - Purpose: libarchive dependency used for archive formats such as xar; distributed alongside archive_r.
+   - License: MIT-style License (http://xmlsoft.org/)
+
+7. zstd
+   - Purpose: libarchive dependency providing Zstandard compression; shipped within archive_r binaries.
+   - License: BSD License (https://github.com/facebook/zstd)
+
+8. OpenSSL 3
+   - Purpose: libarchive dependency providing cryptographic support for encrypted archives; included with archive_r packages.
+   - License: Apache License 2.0 with OpenSSL exception (https://www.openssl.org/source/license.html)
+
+9. libiconv / libcharset
+   - Purpose: libxml2/libarchive dependency for character set conversion; redistributed with archive_r artifacts.
+   - License: GNU LGPLv2.1+ (https://www.gnu.org/software/libiconv/)
 Users of archive_r should review the linked third-party licenses to ensure
 compliance with their terms when redistributing this software.

data/ext/archive_r/archive_r_ext.cc

@@ -4,9 +4,11 @@
 #include "archive_r/data_stream.h"
 #include "archive_r/entry.h"
 #include "archive_r/entry_fault.h"
+#include "archive_r/multi_volume_stream_base.h"
 #include "archive_r/path_hierarchy_utils.h"
 #include "archive_r/traverser.h"
 #include <cctype>
+#include <cstdio>
 #include <cstring>
 #include <memory>
 #include <ruby.h>
@@ -16,6 +18,7 @@
 #include <variant>
 #include <vector>
 #include <limits>
+#include <optional>
 
 using namespace archive_r;
 
@@ -24,15 +27,25 @@ static VALUE mArchive_r;
 static VALUE cTraverser;
 static VALUE cEntry;
 static ID rb_id_read_method;
-static ID rb_id_rewind_method;
 static ID rb_id_seek_method;
 static ID rb_id_tell_method;
 static ID rb_id_eof_method;
+static ID rb_id_close_method;
+static ID rb_id_size_method;
 static ID rb_id_call_method;
+static ID rb_id_open_part_method;
+static ID rb_id_close_part_method;
+static ID rb_id_read_part_method;
+static ID rb_id_seek_part_method;
+static ID rb_id_part_size_method;
+static ID rb_id_open_part_io_method;
+static ID rb_id_close_part_io_method;
 struct RubyCallbackHolder;
 static std::shared_ptr<RubyCallbackHolder> g_stream_factory_callback;
 
 // Helper: Convert Ruby string to C++ string
+static VALUE cStream;
+static PathHierarchy rb_value_to_path_hierarchy(VALUE value);
 static std::string rb_string_to_cpp(VALUE rb_str) {
   Check_Type(rb_str, T_STRING);
   return std::string(RSTRING_PTR(rb_str), RSTRING_LEN(rb_str));
@@ -85,96 +98,257 @@ struct RubyCallbackHolder {
   VALUE proc_value;
 };
 
-class RubyIOStream : public IDataStream {
+class RubyUserStream : public MultiVolumeStreamBase {
 public:
-  RubyIOStream(VALUE io, PathHierarchy hierarchy)
-      : _io(io)
-      , _hierarchy(std::move(hierarchy))
-      , _at_end(false)
-      , _seekable(rb_respond_to(io, rb_id_seek_method))
-      , _tellable(rb_respond_to(io, rb_id_tell_method))
-      , _rewindable(rb_respond_to(io, rb_id_rewind_method))
-      , _has_eof(rb_respond_to(io, rb_id_eof_method)) {
-    // Validate before GC registration to avoid resource leak on validation failure
-    if (!_rewindable) {
-      rb_raise(rb_eTypeError, "stream factory IO must respond to #read and #rewind");
+  RubyUserStream(VALUE ruby_stream, PathHierarchy hierarchy, std::optional<bool> seekable_override)
+      : MultiVolumeStreamBase(std::move(hierarchy), determine_seek_support(ruby_stream, seekable_override))
+      , _ruby_stream(ruby_stream)
+      , _has_close(rb_respond_to(ruby_stream, rb_id_close_part_method))
+      , _has_seek(rb_respond_to(ruby_stream, rb_id_seek_part_method))
+      , _has_size(rb_respond_to(ruby_stream, rb_id_part_size_method))
+      , _has_open_part_io(rb_respond_to(ruby_stream, rb_id_open_part_io_method))
+      , _has_close_part_io(rb_respond_to(ruby_stream, rb_id_close_part_io_method))
+      , _active_io(Qnil)
+      , _active_io_seekable(false)
+      , _active_io_tellable(false)
+      , _active_io_has_close(false)
+      , _active_io_has_size(false) {
+    ensure_required_methods(ruby_stream);
+    rb_gc_register_address(&_ruby_stream);
+  }
+
+  ~RubyUserStream() override {
+    release_active_io();
+    rb_gc_unregister_address(&_ruby_stream);
+  }
+
+protected:
+  void open_single_part(const PathHierarchy &single_part) override {
+    if (_has_open_part_io) {
+      VALUE arg = path_hierarchy_to_rb(single_part);
+      VALUE io = rb_funcall(_ruby_stream, rb_id_open_part_io_method, 1, arg);
+      if (NIL_P(io)) {
+        rb_raise(rb_eRuntimeError, "open_part_io must return an IO-like object");
+      }
+      activate_io(io);
+      return;
     }
-    rb_gc_register_address(&_io);
+
+    VALUE arg = path_hierarchy_to_rb(single_part);
+    rb_funcall(_ruby_stream, rb_id_open_part_method, 1, arg);
   }
 
-  ~RubyIOStream() override { rb_gc_unregister_address(&_io); }
+  void close_single_part() override {
+    if (_has_open_part_io) {
+      release_active_io();
+      if (_has_close_part_io) {
+        rb_funcall(_ruby_stream, rb_id_close_part_io_method, 0);
+      }
+      return;
+    }
+
+    if (_has_close) {
+      rb_funcall(_ruby_stream, rb_id_close_part_method, 0);
+    }
+  }
 
-  ssize_t read(void *buffer, size_t size) override {
+  ssize_t read_from_single_part(void *buffer, size_t size) override {
     if (size == 0) {
       return 0;
     }
 
-    VALUE result = rb_funcall(_io, rb_id_read_method, 1, SIZET2NUM(size));
+    if (_has_open_part_io) {
+      if (_active_io == Qnil) {
+        rb_raise(rb_eRuntimeError, "open_part_io must return an IO before reading");
+      }
+      VALUE result = rb_funcall(_active_io, rb_id_read_method, 1, SIZET2NUM(size));
+      if (NIL_P(result)) {
+        return 0;
+      }
+      Check_Type(result, T_STRING);
+      const ssize_t length = static_cast<ssize_t>(RSTRING_LEN(result));
+      if (length <= 0) {
+        return 0;
+      }
+      std::memcpy(buffer, RSTRING_PTR(result), static_cast<size_t>(length));
+      return length;
+    }
+
+    VALUE result = rb_funcall(_ruby_stream, rb_id_read_part_method, 1, SIZET2NUM(size));
     if (NIL_P(result)) {
-      _at_end = true;
       return 0;
     }
     Check_Type(result, T_STRING);
-    const ssize_t bytes_read = static_cast<ssize_t>(RSTRING_LEN(result));
-    if (bytes_read > 0) {
-      std::memcpy(buffer, RSTRING_PTR(result), static_cast<size_t>(bytes_read));
-      return bytes_read;
+    const ssize_t length = static_cast<ssize_t>(RSTRING_LEN(result));
+    if (length <= 0) {
+      return 0;
     }
+    std::memcpy(buffer, RSTRING_PTR(result), static_cast<size_t>(length));
+    return length;
+  }
 
-    if (_has_eof) {
-      VALUE eof_val = rb_funcall(_io, rb_id_eof_method, 0);
-      _at_end = RTEST(eof_val);
+  int64_t seek_within_single_part(int64_t offset, int whence) override {
+    if (_has_open_part_io && _active_io != Qnil && _active_io_seekable) {
+      VALUE result = rb_funcall(_active_io, rb_id_seek_method, 2, LL2NUM(offset), INT2NUM(whence));
+      return NUM2LL(result);
     }
-    return 0;
-  }
 
-  void rewind() override {
-    if (!_rewindable) {
-      rb_raise(rb_eRuntimeError, "IO object does not respond to #rewind");
+    if (!_has_seek) {
+      return -1;
     }
-    rb_funcall(_io, rb_id_rewind_method, 0);
-    _at_end = false;
+    VALUE result = rb_funcall(_ruby_stream, rb_id_seek_part_method, 2, LL2NUM(offset), INT2NUM(whence));
+    return NUM2LL(result);
   }
 
-  bool at_end() const override {
-    if (_has_eof) {
-      VALUE eof_val = rb_funcall(_io, rb_id_eof_method, 0);
-      return RTEST(eof_val);
+  int64_t size_of_single_part(const PathHierarchy &single_part) override {
+    if (_has_open_part_io && _active_io != Qnil) {
+      if (_active_io_has_size) {
+        VALUE result = rb_funcall(_active_io, rb_id_size_method, 0);
+        return NUM2LL(result);
+      }
+      if (_active_io_seekable && _active_io_tellable) {
+        VALUE current = rb_funcall(_active_io, rb_id_tell_method, 0);
+        rb_funcall(_active_io, rb_id_seek_method, 2, LL2NUM(0), INT2NUM(SEEK_END));
+        VALUE end_pos = rb_funcall(_active_io, rb_id_tell_method, 0);
+        rb_funcall(_active_io, rb_id_seek_method, 2, current, INT2NUM(SEEK_SET));
+        return NUM2LL(end_pos);
+      }
     }
-    return _at_end;
-  }
 
-  int64_t seek(int64_t offset, int whence) override {
-    if (!_seekable) {
+    if (!_has_size) {
       return -1;
     }
-    VALUE result = rb_funcall(_io, rb_id_seek_method, 2, LL2NUM(offset), INT2NUM(whence));
-    _at_end = false;
+    VALUE arg = path_hierarchy_to_rb(single_part);
+    VALUE result = rb_funcall(_ruby_stream, rb_id_part_size_method, 1, arg);
     return NUM2LL(result);
   }
 
-  int64_t tell() const override {
-    if (!_tellable) {
-      return -1;
+private:
+  static bool determine_seek_support(VALUE ruby_stream, const std::optional<bool> &override_flag) {
+    if (override_flag.has_value()) {
+      return *override_flag;
+    }
+    if (rb_respond_to(ruby_stream, rb_id_seek_part_method)) {
+      return true;
+    }
+    if (rb_respond_to(ruby_stream, rb_id_open_part_io_method)) {
+      return true;
+    }
+    return false;
+  }
+
+  static void ensure_required_methods(VALUE ruby_stream) {
+    if (!rb_respond_to(ruby_stream, rb_id_open_part_method) && !rb_respond_to(ruby_stream, rb_id_open_part_io_method)) {
+      rb_raise(rb_eNotImpError, "Stream subclasses must implement #open_part_io or #open_part");
+    }
+    if (!rb_respond_to(ruby_stream, rb_id_read_part_method) && !rb_respond_to(ruby_stream, rb_id_open_part_io_method)) {
+      rb_raise(rb_eNotImpError, "Stream subclasses must implement #open_part_io or #read_part");
     }
-    VALUE result = rb_funcall(_io, rb_id_tell_method, 0);
-    return NUM2LL(result);
   }
 
-  bool can_seek() const override { return _seekable; }
+  void activate_io(VALUE io) {
+    if (!rb_respond_to(io, rb_id_read_method)) {
+      rb_raise(rb_eTypeError, "open_part_io must return an object responding to #read");
+    }
+    release_active_io();
+    _active_io = io;
+    rb_gc_register_address(&_active_io);
+    _active_io_seekable = rb_respond_to(io, rb_id_seek_method);
+    _active_io_tellable = rb_respond_to(io, rb_id_tell_method);
+    _active_io_has_close = rb_respond_to(io, rb_id_close_method);
+    _active_io_has_size = rb_respond_to(io, rb_id_size_method);
+  }
 
-  PathHierarchy source_hierarchy() const override { return _hierarchy; }
+  void release_active_io() {
+    if (_active_io == Qnil) {
+      return;
+    }
+    if (_active_io_has_close) {
+      rb_funcall(_active_io, rb_id_close_method, 0);
+    }
+    rb_gc_unregister_address(&_active_io);
+    _active_io = Qnil;
+    _active_io_seekable = false;
+    _active_io_tellable = false;
+    _active_io_has_close = false;
+    _active_io_has_size = false;
+  }
 
-private:
-  VALUE _io;
-  PathHierarchy _hierarchy;
-  mutable bool _at_end;
-  bool _seekable;
-  bool _tellable;
-  bool _rewindable;
-  bool _has_eof;
+  VALUE _ruby_stream;
+  bool _has_close;
+  bool _has_seek;
+  bool _has_size;
+  bool _has_open_part_io;
+  bool _has_close_part_io;
+  VALUE _active_io;
+  bool _active_io_seekable;
+  bool _active_io_tellable;
+  bool _active_io_has_close;
+  bool _active_io_has_size;
+};
+
+struct RubyStreamWrapper {
+  std::shared_ptr<RubyUserStream> stream;
+};
+
+static void stream_wrapper_free(void *ptr) {
+  auto *wrapper = static_cast<RubyStreamWrapper *>(ptr);
+  delete wrapper;
+}
+
+static size_t stream_wrapper_memsize(const void *ptr) {
+  return sizeof(RubyStreamWrapper);
+}
+
+static const rb_data_type_t stream_wrapper_type = {
+  "ArchiveR::Stream",
+  {
+    nullptr,
+    stream_wrapper_free,
+    stream_wrapper_memsize,
+  },
+  nullptr,
+  nullptr,
+  RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
+static RubyStreamWrapper *get_stream_wrapper(VALUE self) {
+  RubyStreamWrapper *wrapper = nullptr;
+  TypedData_Get_Struct(self, RubyStreamWrapper, &stream_wrapper_type, wrapper);
+  if (!wrapper) {
+    rb_raise(rb_eRuntimeError, "invalid Stream wrapper");
+  }
+  return wrapper;
+}
+
+static VALUE stream_allocate(VALUE klass) {
+  auto *wrapper = new RubyStreamWrapper();
+  wrapper->stream.reset();
+  return TypedData_Wrap_Struct(klass, &stream_wrapper_type, wrapper);
+}
+
+static VALUE stream_initialize(int argc, VALUE *argv, VALUE self) {
+  RubyStreamWrapper *wrapper = get_stream_wrapper(self);
+  if (wrapper->stream) {
+    rb_raise(rb_eRuntimeError, "Stream already initialized");
+  }
+  VALUE hierarchy_value = Qnil;
+  VALUE opts = Qnil;
+  rb_scan_args(argc, argv, "11", &hierarchy_value, &opts);
+  PathHierarchy hierarchy = rb_value_to_path_hierarchy(hierarchy_value);
+  std::optional<bool> seekable_override;
+  if (!NIL_P(opts)) {
+    Check_Type(opts, T_HASH);
+    static ID id_seekable = rb_intern("seekable");
+    VALUE seekable_value = rb_hash_aref(opts, ID2SYM(id_seekable));
+    if (!NIL_P(seekable_value)) {
+      seekable_override = RTEST(seekable_value);
+    }
+  }
+  wrapper->stream = std::make_shared<RubyUserStream>(self, std::move(hierarchy), seekable_override);
+  return self;
+}
+
 static VALUE entry_fault_to_rb(const EntryFault &fault) {
   VALUE hash = rb_hash_new();
   static ID id_message = rb_intern("message");
@@ -371,16 +545,42 @@ static std::vector<PathHierarchy> rb_paths_to_hierarchies(VALUE paths) {
   return result;
 }
 
+static VALUE invoke_ruby_stream_factory(const std::shared_ptr<RubyCallbackHolder> &holder, const PathHierarchy &hierarchy) {
+  struct FactoryPayload {
+    std::shared_ptr<RubyCallbackHolder> holder;
+    VALUE arg;
+  } payload{ holder, path_hierarchy_to_rb(hierarchy) };
+
+  auto invoke = [](VALUE data) -> VALUE {
+    auto *info = reinterpret_cast<FactoryPayload *>(data);
+    return rb_funcall(info->holder->proc_value, rb_id_call_method, 1, info->arg);
+  };
+
+  int state = 0;
+  VALUE result = rb_protect(invoke, reinterpret_cast<VALUE>(&payload), &state);
+  if (state != 0) {
+    rb_jump_tag(state);
+  }
+  return result;
+}
+
 static std::shared_ptr<IDataStream> stream_from_ruby_value(VALUE value, const PathHierarchy &requested) {
   if (NIL_P(value)) {
     return nullptr;
   }
 
-  if (!rb_respond_to(value, rb_id_read_method)) {
-    rb_raise(rb_eTypeError, "stream factory result must respond to #read");
+  if (rb_obj_is_kind_of(value, cStream)) {
+    RubyStreamWrapper *wrapper = get_stream_wrapper(value);
+    if (!wrapper->stream) {
+      rb_raise(rb_eRuntimeError, "Stream instance is not initialized");
+    }
+    if (!hierarchies_equal(wrapper->stream->source_hierarchy(), requested)) {
+      rb_raise(rb_eArgError, "Stream instance must be created with the same hierarchy passed to the factory");
+    }
+    return wrapper->stream;
   }
 
-  return std::make_shared<RubyIOStream>(value, requested);
+  rb_raise(rb_eTypeError, "stream factory must return nil or an Archive_r::Stream instance");
 }
 
 // Helper: Convert EntryMetadataValue to Ruby object
@@ -495,22 +695,7 @@ static VALUE archive_r_register_stream_factory(int argc, VALUE *argv, VALUE self
   auto holder = std::make_shared<RubyCallbackHolder>(callable);
 
   RootStreamFactory factory = [holder](const PathHierarchy &hierarchy) -> std::shared_ptr<IDataStream> {
-    struct FactoryPayload {
-      std::shared_ptr<RubyCallbackHolder> holder;
-      VALUE arg;
-    } payload{ holder, path_hierarchy_to_rb(hierarchy) };
-
-    auto invoke = [](VALUE data) -> VALUE {
-      auto *info = reinterpret_cast<FactoryPayload *>(data);
-      return rb_funcall(info->holder->proc_value, rb_id_call_method, 1, info->arg);
-    };
-
-    int state = 0;
-    VALUE result = rb_protect(invoke, reinterpret_cast<VALUE>(&payload), &state);
-    if (state != 0) {
-      rb_jump_tag(state);
-    }
-
+    VALUE result = invoke_ruby_stream_factory(holder, hierarchy);
     return stream_from_ruby_value(result, hierarchy);
   };
 
@@ -867,13 +1052,24 @@ static VALUE traverser_s_open(int argc, VALUE *argv, VALUE klass) {
 extern "C" void Init_archive_r() {
   // Define module Archive_r
   mArchive_r = rb_define_module("Archive_r");
+  cStream = rb_define_class_under(mArchive_r, "Stream", rb_cObject);
+  rb_define_alloc_func(cStream, stream_allocate);
+  rb_define_method(cStream, "initialize", RUBY_METHOD_FUNC(stream_initialize), -1);
 
   rb_id_read_method = rb_intern("read");
-  rb_id_rewind_method = rb_intern("rewind");
   rb_id_seek_method = rb_intern("seek");
   rb_id_tell_method = rb_intern("tell");
   rb_id_eof_method = rb_intern("eof?");
+  rb_id_close_method = rb_intern("close");
+  rb_id_size_method = rb_intern("size");
   rb_id_call_method = rb_intern("call");
+  rb_id_open_part_method = rb_intern("open_part");
+  rb_id_close_part_method = rb_intern("close_part");
+  rb_id_read_part_method = rb_intern("read_part");
+  rb_id_seek_part_method = rb_intern("seek_part");
+  rb_id_part_size_method = rb_intern("part_size");
+  rb_id_open_part_io_method = rb_intern("open_part_io");
+  rb_id_close_part_io_method = rb_intern("close_part_io");
 
   // Define Entry class
   cEntry = rb_define_class_under(mArchive_r, "Entry", rb_cObject);

data/ext/archive_r/vendor/archive_r/LICENSE.txt

@@ -1,5 +1,5 @@
 archive_r License
-Version: 0.1.0 (2025-10-25)
+Version: 0.1.2 (2025-12-02)
 
 ----------------------------------------
 Primary License
@@ -44,13 +44,34 @@ License shown above.
    - Purpose: header-only binding generator for the Python extension module.
    - License: BSD-style License (https://github.com/pybind/pybind11)
 
-3. rake (development dependency for Ruby bindings)
-   - Purpose: build and release tasks for the Ruby gem.
-   - License: MIT License (https://github.com/ruby/rake)
+The following components are redistributed only because libarchive (bundled with archive_r) depends on them at runtime:
 
-4. minitest (development dependency for Ruby bindings)
-   - Purpose: unit testing framework for the Ruby gem.
-   - License: MIT License (https://github.com/minitest/minitest)
+3. zlib
+   - Purpose: libarchive dependency providing DEFLATE compression; bundled inside archive_r binaries and wheels because libarchive requires it.
+   - License: zlib License (https://zlib.net/zlib_license.html)
 
+4. bzip2
+   - Purpose: libarchive dependency providing bzip2 compression support; distributed with archive_r artifacts.
+   - License: BSD-style license (https://sourceware.org/bzip2/)
+
+5. liblzma (XZ Utils)
+   - Purpose: libarchive dependency providing LZMA/XZ compression; included with archive_r packages.
+   - License: Public Domain + GNU LGPLv2.1+ (https://tukaani.org/xz/)
+
+6. libxml2
+   - Purpose: libarchive dependency used for archive formats such as xar; distributed alongside archive_r.
+   - License: MIT-style License (http://xmlsoft.org/)
+
+7. zstd
+   - Purpose: libarchive dependency providing Zstandard compression; shipped within archive_r binaries.
+   - License: BSD License (https://github.com/facebook/zstd)
+
+8. OpenSSL 3
+   - Purpose: libarchive dependency providing cryptographic support for encrypted archives; included with archive_r packages.
+   - License: Apache License 2.0 with OpenSSL exception (https://www.openssl.org/source/license.html)
+
+9. libiconv / libcharset
+   - Purpose: libxml2/libarchive dependency for character set conversion; redistributed with archive_r artifacts.
+   - License: GNU LGPLv2.1+ (https://www.gnu.org/software/libiconv/)
 Users of archive_r should review the linked third-party licenses to ensure
 compliance with their terms when redistributing this software.

data/lib/archive_r.rb

@@ -10,7 +10,7 @@ rescue LoadError
 end
 
 module Archive_r
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
   # Common archive formats excluding libarchive's mtree/raw pseudo formats
   STANDARD_FORMATS = %w[
     7zip ar cab cpio empty iso9660 lha rar tar warc xar zip

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: archive_r_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
-- raiso.tcs
+- raizo.tcs
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-29 00:00:00.000000000 Z
+date: 2025-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,16 +38,16 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: Fast archive traversal library with support for nested archives and multipart
-  files
+description: Ruby bindings for archive_r that recursively walk nested and multipart
+  archives directly from the source stream without creating temporary files
 email:
-- raiso.tcs@users.noreply.github.com
+- raizo.tcs@users.noreply.github.com
 executables: []
 extensions:
 - ext/archive_r/extconf.rb
 extra_rdoc_files: []
 files:
-- LICENSE
+- LICENSE.txt
 - README.md
 - ext/archive_r/archive_r_ext.cc
 - ext/archive_r/extconf.rb
@@ -108,5 +108,5 @@ requirements: []
 rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: Ruby bindings for archive_r library
+summary: Ruby bindings for archive_r that traverse nested archives without temp extraction
 test_files: []