ruzip 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 758585b6a1cde1090fc03b6745059dd7558c7816ec9e297ffe8e671ea531e364
-  data.tar.gz: 6d4f5b3aa6c10be28bce83bb18452180a3450da050b71a99f28a5871e28b580e
+  metadata.gz: a1c9e169da26aa71bb1aee7beb83cc3bd294280c915eb9fe326cce1de07cf4b4
+  data.tar.gz: 155882217b16ff068dcc669c3a1f0eb6b30a6d9ec6dcd70ce81f85b8c5de73d1
 SHA512:
-  metadata.gz: 60ba2d2dd7c91b7ec5d17d4da55b02bf420e933f0adc5fd25954011313566a4a1bf70cdcb815404f67e806710e526b769c1eae4ed696ae38ce46a413726f46df
-  data.tar.gz: 6a5b2bccfee9c2a467ad7c065287a6ae34761dc5e2e0fe6ee0bfbf2e421c17933f5d9c6a1adc51895cd83c6c445278288a02530b6e1755ec80658000289a0cbe
+  metadata.gz: e2f24eccfb60df789063186779cb9f785024e6dd42bbb05f38f85e33c9b0447a2afcac17fec92f842d93acc0fa7903663bd492fc0e78da6c0a12cbbf7e7b72f0
+  data.tar.gz: a1c5603e029df78f7b88683d6b3139c8755cb874a0ad5b8a6deff3642754946a15014800afdb8167c3ad9d66c166985845a9fb119bf3f17caa7562a360f38316

data/.gitignore

@@ -16,3 +16,5 @@ Gemfile.lock
 /test/fixtures/accessible_epub_3.epub
 html/
 ext/release/
+.gem_rbs_collection/
+rbs_collection.lock.yaml

data/.gitlab-ci.yml

@@ -1,15 +1,15 @@
-default:
-  image: ruby:4.0
-
+test:
+  image: ruby:$RUBY_VERSION
+  variables:
+    RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN: 'true'
   before_script:
     - apt-get update && apt-get install -y clang
     - curl https://sh.rustup.rs -sSf | sh -s -- -y
     - . "$HOME/.cargo/env"
     - gem update --system
     - bundle install
-
-test:
-  variables:
-    RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN: 'true'
   script:
     - bundle exec rake test
+  parallel:
+    matrix:
+      - RUBY_VERSION: ["3.2", "3.3", "3.4", "4.0"]

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.3.0] - 2026-10-01
+
+* `RuZip::File#name` returns UTF-8 or ASCII-8BIT string
+* `Ruzip::Writer.new` accepts mode argument
+* `RuZip::Writer#start_file` accepts keyword arguments: `compression_method`, `compression_level`, `last_modified_time`
+* `RuZip::Writer#raw_copy_file` is added
+* `RuZip::Writer#append_file` is added
+
 ## [0.2.1] - 2026-09-18
 
 * Update crates

data/README.md

@@ -30,6 +30,13 @@ If bundler is not being used to manage dependencies, install the gem by executin
     
     archive.by_name("path/in/zip/archive") # => RuZip::File
 
+    writer = RuZip::Writer.new("path/to/output.zip")
+    ["content1", "content2", "content3"].each_with_index do |content, i|
+      writer.start_file "inner/path/to/#{i}.txt"
+      writer.write content
+    end
+    writer.finish
+
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rake test` to run the tests. You can also run `bundle exec rake console` for an interactive prompt that will allow you to experiment.

data/Steepfile

@@ -0,0 +1,37 @@
+D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+  ignore_signature "sig/test"
+
+  check "lib"                       # Directory name
+  # check "path/to/source.rb"         # File name
+  # check "app/models/**/*.rb"        # Glob
+  # ignore "lib/templates/*.rb"
+
+  # library "pathname"              # Standard libraries
+  # library "strong_json"           # Gems
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+target :test do
+  unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
+  signature "sig/test"              # Put RBS files for tests under `sig/test`
+  check "test"                      # Type check Ruby scripts under `test`
+
+  # configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+  configure_code_diagnostics do |hash|
+    hash[D::Ruby::MethodDefinitionMissing] = :warning
+    hash[D::Ruby::UnknownConstant] = :information
+  end
+
+  library "tmpdir", "tempfile", "fileutils" # Standard libraries
+  library "rubyzip"
+end

data/ext/Cargo.lock

@@ -73,9 +73,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.4.6"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3eb0f42d6c360dc3f8a821f6bf2fdea7f72bfd36b3076eb0e6d1e9e0752fff4"
+checksum = "f360145194ee8e21db5ee7f3fcd4fe52210864c75c985dae33218202c8bbe040"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -218,9 +218,9 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.12"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d"
+checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
 
 [[package]]
 name = "flate2"
@@ -338,9 +338,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.105"
+version = "0.3.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e"
+checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -578,7 +578,7 @@ checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 
 [[package]]
 name = "ruzip"
-version = "0.2.1"
+version = "0.3.0"
 dependencies = [
  "magnus",
  "rb-sys",
@@ -725,9 +725,9 @@ checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf"
+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -738,9 +738,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed"
+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -748,9 +748,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a"
+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -761,9 +761,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e"
+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
 dependencies = [
  "unicode-ident",
 ]

data/ext/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruzip"
-version = "0.2.1"
+version = "0.3.0"
 edition = "2024"
 authors = ["Kitaiti Makoto <KitaitiMakoto@gmail.com>"]
 publish = false

data/ext/src/lib.rs

@@ -1,8 +1,13 @@
-use magnus::{Error, Integer, RString, Ruby, Value, function, method, prelude::*};
-use std::cell::RefCell;
+use magnus::{
+    Error, Integer, RHash, RString, Ruby, Symbol, Time, Value, function, method,
+    prelude::*,
+    scan_args::{KwArgs, get_kwargs, scan_args},
+    typed_data::Obj,
+};
+use std::cell::{RefCell, RefMut};
 use std::fs;
 use std::io::{Read, Write};
-use std::os::fd::FromRawFd;
+use std::str;
 use std::sync::{Arc, Mutex};
 use zip::{ZipArchive, ZipWriter};
 
@@ -15,12 +20,27 @@ fn map_err(err: impl std::error::Error, ruby: &Ruby) -> Error {
 #[magnus::wrap(class = "RuZip::Archive", free_immediately, size)]
 struct Archive(Arc<Mutex<ZipArchive<fs::File>>>);
 
+#[cfg(windows)]
+fn file_from_io(io: Value, ruby: &Ruby) -> Result<fs::File> {
+    todo!();
+}
+
+#[cfg(not(windows))]
+fn file_from_io(io: Value, ruby: &Ruby) -> Result<fs::File> {
+    use std::os::fd::BorrowedFd;
+
+    let fileno: Integer = io.funcall_public("fileno", ())?;
+    let raw_fd = fileno.to_i32()?;
+    let fd = unsafe { BorrowedFd::borrow_raw(raw_fd) }
+        .try_clone_to_owned()
+        .map_err(|e| map_err(e, ruby))?;
+    Ok(fs::File::from(fd))
+}
+
 impl Archive {
     fn new(ruby: &Ruby, r_io: Value) -> Result<Self> {
         let io = if r_io.is_kind_of(ruby.class_io()) {
-            let fileno: Integer = r_io.funcall_public("fileno", ())?;
-            let raw_fd = fileno.to_i32()?;
-            unsafe { fs::File::from_raw_fd(raw_fd) }
+            file_from_io(r_io, ruby)?
         } else if r_io.respond_to("to_path", false)? {
             fs::File::open(
                 r_io.funcall_public::<&str, (), RString>("to_path", ())?
@@ -58,8 +78,8 @@ impl Archive {
         }
     }
 
-    fn by_name(ruby: &Ruby, rb_self: &Self, name: String) -> Result<Option<File>> {
-        let name_bytes = name.as_bytes();
+    fn by_name(ruby: &Ruby, rb_self: &Self, name: RString) -> Result<Option<File>> {
+        let name_bytes = unsafe { name.as_slice() };
         let mut archive = rb_self.0.lock().map_err(|e| map_err(e, ruby))?;
         // TODO: Cache entries
         for i in 0..archive.len() {
@@ -76,18 +96,14 @@ impl Archive {
 struct File(Arc<Mutex<ZipArchive<fs::File>>>, usize);
 
 impl File {
-    fn name(ruby: &Ruby, rb_self: &Self) -> Result<String> {
-        String::from_utf8(
-            rb_self
-                .0
-                .lock()
-                .map_err(|e| map_err(e, ruby))?
-                .by_index(rb_self.1)
-                .map_err(|e| map_err(e, ruby))?
-                .name_raw()
-                .into(),
-        )
-        .map_err(|e| map_err(e, ruby))
+    fn name(ruby: &Ruby, rb_self: &Self) -> Result<RString> {
+        let mut archive = rb_self.0.lock().map_err(|e| map_err(e, ruby))?;
+        let file = archive.by_index(rb_self.1).map_err(|e| map_err(e, ruby))?;
+        let bytes = file.name_raw();
+        Ok(match str::from_utf8(bytes) {
+            Ok(s) => ruby.str_new(s),
+            Err(_) => ruby.str_from_slice(bytes),
+        })
     }
 
     fn size(ruby: &Ruby, rb_self: &Self) -> Result<u64> {
@@ -135,10 +151,122 @@ impl File {
 #[magnus::wrap(class = "RuZip::Writer", free_immediately, size)]
 struct Writer(RefCell<Option<ZipWriter<fs::File>>>);
 
+enum WriterMode {
+    Write,
+    Append,
+}
+
+impl TryFrom<(&str, &Ruby)> for WriterMode {
+    type Error = Error;
+
+    fn try_from(value: (&str, &Ruby)) -> Result<Self> {
+        let (mode, ruby) = value;
+        Ok(match mode {
+            "w" => WriterMode::Write,
+            "a" => WriterMode::Append,
+            _ => {
+                return Err(Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Unsupported mode: {mode}"),
+                ));
+            }
+        })
+    }
+}
+
+fn compression_method_from_symbol(sym: Symbol, ruby: &Ruby) -> Result<zip::CompressionMethod> {
+    use zip::CompressionMethod::*;
+    Ok(match sym.name()?.as_ref() {
+        "stored" => Stored,
+        "deflated" => Deflated,
+        "deflated64" => Deflate64,
+        "bzip2" => Bzip2,
+        "aes" => Aes,
+        "zstd" => Zstd,
+        "lzma" => Lzma,
+        "xz" => Xz,
+        "ppmd" => Ppmd,
+        _ => {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("Unsupported compression method: {}", sym),
+            ));
+        }
+    })
+}
+
+fn date_time_from_time(time: Time, ruby: &Ruby) -> Result<zip::DateTime> {
+    zip::DateTime::from_date_and_time(
+        time.funcall("year", ())?,
+        time.funcall("month", ())?,
+        time.funcall("day", ())?,
+        time.funcall("hour", ())?,
+        time.funcall("min", ())?,
+        time.funcall("sec", ())?,
+    )
+    .map_err(|e| map_err(e, ruby))
+}
+
+// TODO: Move to Grey Knights
+macro_rules! opop_t {
+    ($($type:ty),+) => { ($(Option<Option<$type>>),+) }
+}
+macro_rules! opt_t {
+    ($($type:ty),+) => { ($(Option<$type>),+) };
+}
+
+type StartFileKwArgsOptionalInput = opop_t!(Symbol, i64, Time);
+type StartFileKwArgsOptionalOutput = opt_t!(Symbol, i64, Time);
+type StartFileKwArgs = KwArgs<(), StartFileKwArgsOptionalOutput, ()>;
+static START_FILE_KW_ARGS_NAME_OPTIONAL: &[&str] = &[
+    "compression_method",
+    "compression_level",
+    "last_modified_time",
+];
+
+fn flatten_optional_keywords(
+    optional: StartFileKwArgsOptionalInput,
+) -> StartFileKwArgsOptionalOutput {
+    (
+        optional.0.flatten(),
+        optional.1.flatten(),
+        optional.2.flatten(),
+    )
+}
+
+fn get_start_file_kwargs(kw: RHash) -> Result<StartFileKwArgs> {
+    let kwargs = get_kwargs::<_, (), StartFileKwArgsOptionalInput, ()>(
+        kw,
+        &[],
+        START_FILE_KW_ARGS_NAME_OPTIONAL,
+    )?;
+    Ok(KwArgs {
+        required: kwargs.required,
+        optional: flatten_optional_keywords(kwargs.optional),
+        splat: kwargs.splat,
+    })
+}
+
 impl Writer {
-    fn new(ruby: &Ruby, path: String) -> Result<Self> {
-        let file = fs::File::create(path).map_err(|e| map_err(e, ruby))?;
-        let writer = ZipWriter::new(file);
+    // TODO: Accept arg the same to Archive.new
+    // TODO: Accept block
+    fn new(ruby: &Ruby, args: &[Value]) -> Result<Self> {
+        let args = scan_args::<(String,), (Option<String>,), (), (), (), ()>(args)?;
+        let path = args.required.0;
+        let mode = args.optional.0;
+        let mut options = fs::OpenOptions::new();
+        let writer_mode = (mode.as_deref().unwrap_or("w"), ruby).try_into()?;
+        let file = match writer_mode {
+            WriterMode::Write => options.create(true),
+            WriterMode::Append => options.read(true),
+        }
+        .write(true)
+        .open(path)
+        .map_err(|e| map_err(e, ruby))?;
+        let writer = match writer_mode {
+            WriterMode::Write => ZipWriter::new(file),
+            WriterMode::Append => ZipWriter::new_append(file).map_err(|e| map_err(e, ruby))?,
+        };
         Ok(Self(RefCell::new(Some(writer))))
     }
 
@@ -157,25 +285,115 @@ impl Writer {
         }
     }
 
-    fn start_file(ruby: &Ruby, rb_self: &Self, name: String) -> Result<()> {
-        let mut writer = rb_self.0.borrow_mut();
-        let writer = writer
-            .as_mut()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Already finished"))?;
-        writer
-            .start_file(name, zip::write::SimpleFileOptions::default())
+    fn start_file(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<()> {
+        let args = scan_args::<(String,), (), (), (), _, ()>(args)?;
+        let name = args.required.0;
+        let (compression_method, compression_level, last_modified_time) =
+            get_start_file_kwargs(args.keywords)?.optional;
+
+        let mut option =
+            zip::write::SimpleFileOptions::default().compression_level(compression_level);
+        if let Some(method) = compression_method {
+            option = option.compression_method(compression_method_from_symbol(method, ruby)?);
+        }
+        if let Some(mod_time) = last_modified_time {
+            option = option.last_modified_time(date_time_from_time(mod_time, ruby)?);
+        }
+
+        Self::writer(ruby, rb_self)?
+            .start_file(name, option)
             .map_err(|e| map_err(e, ruby))?;
         Ok(())
     }
 
-    fn write(ruby: &Ruby, rb_self: &Self, buf: String) -> Result<()> {
-        let mut writer = rb_self.0.borrow_mut();
-        let writer = writer.as_mut()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Already finished"))?;
-        writer.write_all(buf.as_bytes())
+    fn write(ruby: &Ruby, rb_self: &Self, buf: RString) -> Result<()> {
+        Self::writer(ruby, rb_self)?
+            .write_all(unsafe { buf.as_slice() })
             .map_err(|e| map_err(e, ruby))?;
         Ok(())
     }
+
+    fn raw_copy_file(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<()> {
+        let args = scan_args::<(Obj<File>,), (), (), (), _, ()>(args)?;
+        let file = &*args.required.0;
+        let kwargs = get_kwargs::<
+            _,
+            (),
+            (
+                Option<Option<String>>,
+                Option<Option<Time>>,
+                Option<Option<u32>>,
+            ),
+            (),
+        >(
+            args.keywords,
+            &[],
+            &["name", "last_modified_time", "unix_mode"],
+        )?;
+        let name = kwargs.optional.0.flatten();
+        let last_modified_time = kwargs.optional.1.flatten();
+        let unix_mode = kwargs.optional.2.flatten();
+        if last_modified_time.is_none() && unix_mode.is_some() {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "last_modified_time is nil but unix_mode is passed",
+            ));
+        }
+
+        let mut writer = Self::writer(ruby, rb_self)?;
+        let mut archive = file.0.lock().map_err(|e| map_err(e, ruby))?;
+        let zip_file = archive.by_index(file.1).map_err(|e| map_err(e, ruby))?;
+        match (name, last_modified_time) {
+            (Some(_), Some(_)) => {
+                return Err(Error::new(
+                    ruby.exception_arg_error(),
+                    "name and last_modified_time cannot be passed at the same time",
+                ));
+            }
+            (Some(n), None) => writer.raw_copy_file_rename(zip_file, n),
+            (None, Some(t)) => {
+                let mtime = date_time_from_time(t, ruby)?;
+                writer.raw_copy_file_touch(zip_file, mtime, unix_mode)
+            }
+            (None, None) => writer.raw_copy_file(zip_file),
+        }
+        .map_err(|e| map_err(e, ruby))?;
+        Ok(())
+    }
+
+    fn append_file(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<()> {
+        let args = scan_args::<(String, RString), (), (), (), _, ()>(args)?;
+        let (name, buf) = args.required;
+        let (compression_method, compression_level, last_modified_time) =
+            get_start_file_kwargs(args.keywords)?.optional;
+
+        let mut option =
+            zip::write::SimpleFileOptions::default().compression_level(compression_level);
+        if let Some(method) = compression_method {
+            option = option.compression_method(compression_method_from_symbol(method, ruby)?);
+        }
+        if let Some(mod_time) = last_modified_time {
+            option = option.last_modified_time(date_time_from_time(mod_time, ruby)?);
+        }
+
+        let mut writer = Self::writer(ruby, rb_self)?;
+        writer
+            .start_file(name, option)
+            .map_err(|e| map_err(e, ruby))?;
+        writer
+            .write_all(unsafe { buf.as_slice() })
+            .map_err(|e| map_err(e, ruby))?;
+        Ok(())
+    }
+
+    fn writer<'a>(ruby: &Ruby, rb_self: &'a Self) -> Result<RefMut<'a, ZipWriter<fs::File>>> {
+        let writer = rb_self
+            .0
+            .try_borrow_mut()
+            .map_err(|_| Error::new(ruby.exception_runtime_error(), "Already finished"))?;
+        RefMut::filter_map(writer, Option::as_mut)
+            .map_err(|_| Error::new(ruby.exception_runtime_error(), "Already finished"))
+    }
 }
 
 #[magnus::init]
@@ -195,10 +413,12 @@ fn init(ruby: &Ruby) -> Result<()> {
     file_class.define_method("read", method!(File::read, 0))?;
 
     let writer_class = module.define_class("Writer", ruby.class_object())?;
-    writer_class.define_singleton_method("new", function!(Writer::new, 1))?;
+    writer_class.define_singleton_method("new", function!(Writer::new, -1))?;
     writer_class.define_method("finish", method!(Writer::finish, 0))?;
-    writer_class.define_method("start_file", method!(Writer::start_file, 1))?;
+    writer_class.define_method("start_file", method!(Writer::start_file, -1))?;
     writer_class.define_method("write", method!(Writer::write, 1))?;
+    writer_class.define_method("raw_copy_file", method!(Writer::raw_copy_file, -1))?;
+    writer_class.define_method("append_file", method!(Writer::append_file, -1))?;
 
     Ok(())
 }

data/rbs_collection.yaml

@@ -0,0 +1,20 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  # If you want to avoid installing rbs files for gems, you can specify them here.
+  # - name: GEM_NAME
+  #   ignore: true
+  - name: rubyzip

data/ruzip.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "Library to support the reading and writing of zip files. A wrapper of Rust's zip crate."
   spec.homepage = "https://gitlab.com/KitaitiMakoto/ruzip"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 3.2.0"
   spec.required_rubygems_version = ">= 3.3.11"
 
   spec.metadata["homepage_uri"] = spec.homepage
@@ -37,6 +37,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rdoc"
   spec.add_development_dependency "rbs"
   spec.add_development_dependency "archive-zip"
+  spec.add_development_dependency "rubyzip"
   spec.add_development_dependency "ruby-lsp"
   spec.add_development_dependency "steep"
 

data/sig/ruzip.rbs

@@ -1,12 +1,13 @@
 module RuZip
   class Archive
     def self.new: (IO | path) -> instance
-    def len: -> Integer
+    def length: -> Integer
     def by_index: (Integer) -> File
     def by_name: (String) -> File
   end
 
   class File
+    # UTF-8 when valid, ASCII-8BIT otherwise
     def name: -> String
 
     # The size of decompressed file
@@ -18,9 +19,22 @@ module RuZip
   end
 
   class Writer
-    def self.new: (String) -> instance
+    def self.new: (String path, ?String mode) -> instance
     def finish: -> Archive
-    def start_file: (String) -> void
-    def write: (String) -> void
+    def start_file: (
+      String name,
+      ?compression_method: Symbol?,
+      ?compression_level: Integer?,
+      ?last_modified_date: Time?
+    ) -> void
+    def write: (String buf) -> void
+    def raw_copy_file: (File file, ?name: String?, ?last_modified_time: Time?, ?unix_mode: Integer?) -> void
+    def append_file: (
+      String name,
+      String buf,
+      ?compression_method: Symbol?,
+      ?compression_level: Integer?,
+      ?last_modified_date: Time?
+    ) -> void
   end
 end

data/sig/test/archive-zip.rbs

@@ -0,0 +1,24 @@
+module Archive
+  class Zip
+    include Enumerable[Entry]
+
+    def self.open: (path, ?(String | Symbol) mode) { (instance) -> untyped } -> untyped
+    def each: { (Entry) -> untyped } -> untyped
+            | -> Enumerator[Entry]
+    def add_entry: (Entry) -> self
+    alias << add_entry
+
+    module Entry
+      def zip_path: -> String
+      def mtime: -> Time
+
+      class File
+        include Entry
+
+        def initialize: (String) -> void
+        def file_data: -> IO::Like
+        def file_data=: (IO::LikeHelpers::AbstractIO) -> void
+      end
+    end
+  end
+end

data/sig/test/gem.rbs

@@ -0,0 +1,12 @@
+module Gem
+  class Specification
+    def self.load: (String) -> instance
+    def file_name: -> String
+    def full_name: -> String
+  end
+
+  class Platform
+    def self.local: -> instance
+    def to_s: -> String
+  end
+end

data/sig/test/io-like.rbs

@@ -0,0 +1,18 @@
+class IO
+  class Like
+    def read: (?Integer? length, ?string buffer) -> String?
+  end
+
+  module LikeHelpers
+    class AbstractIO
+    end
+
+    class DelegatedIO < AbstractIO
+      def initialize: (_Reader) -> void
+    end
+
+    class IOWrapper < DelegatedIO
+      
+    end
+  end
+end

data/sig/test/test-unit.rbs

@@ -0,0 +1,28 @@
+module Test
+  module Unit
+    class TestCase
+      include Assertions
+      include TestCasePendingSupport
+
+      def self.test: (String) { (instance) -> void } -> void
+      def setup: { () -> void } -> void
+      def self.setup: { () -> void } -> void
+    end
+
+    module Assertions
+      def assert: (boolish) -> void
+                | { () -> void } -> void
+      def assert_equal: (untyped expected, untyped actual) -> void
+      def assert_nil: (untyped) -> void
+      def assert_kind_of: (Module, untyped) -> void
+      def assert_instance_of: (Class, untyped) -> void
+      def assert_path_exist: (path) -> void
+      def assert_raise: (?Class) { () -> void } -> void
+      def assert_raise_kind_of: (Class) { () -> void } -> void
+    end
+
+    module TestCasePendingSupport
+      def pend: -> void
+    end
+  end
+end

data/sig/test/test.rbs

@@ -0,0 +1,26 @@
+module Test::Unit
+  class TestCase
+    extend Assertions
+
+    def self.fixture_path: (path) -> String
+    def self.pend: -> void
+    def fixture_path: (path) -> String
+  end
+end
+
+class TestArchive < Test::Unit::TestCase
+  self.@fixture: String
+  @fixture: String
+end
+
+class TestFile < Test::Unit::TestCase
+  self.@archive: RuZip::Archive
+end
+
+class TestWriter < Test::Unit::TestCase
+end
+
+class TestPackage < Test::Unit::TestCase
+  def test_build: -> void
+  def test_install: -> void
+end

data/test/helper.rb

@@ -3,6 +3,9 @@ $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "ruzip"
 require "test-unit"
 require "test/unit/notify"
+require "tmpdir"
+require "archive/zip"
+require "rubyzip"
 
 class Test::Unit::TestCase
   def fixture_path(component)

data/test/test_archive.rb

@@ -21,6 +21,7 @@ class TestArchive < Test::Unit::TestCase
   end
 
   test "new with closed file" do
+    # @type var io: File?
     io = nil
     File.open @fixture do |file|
       io = file

data/test/test_file.rb

@@ -21,4 +21,43 @@ XML
   test "retrieve non-existent" do
     assert_nil @archive.by_name("non-existent")
   end
+
+  test "retrieve multi byte name" do
+    Dir.mktmpdir do |dir|
+      path = "test.zip"
+      inner_path = "日本語.txt"
+      content = "今日は"
+      Archive::Zip.open path, :w do |archive|
+        entry = Archive::Zip::Entry::File.new(inner_path)
+        entry.file_data = IO::LikeHelpers::IOWrapper.new(StringIO.new(content))
+        archive << entry
+      end
+
+      file = RuZip::Archive.new(path).by_name(inner_path)
+      assert_kind_of RuZip::File, file
+      assert_equal "日本語.txt", file.name
+    end
+  end
+
+  test "retrieve file with non-UTF-8 name" do
+    Dir.mktmpdir do |dir|
+      path = "test.zip"
+      inner_path = "日本語.txt"
+      inner_path_sjis = inner_path.encode("Shift_JIS")
+      content = "今日は"
+      Archive::Zip.open path, :w do |archive|
+        entry = Archive::Zip::Entry::File.new(inner_path_sjis)
+        entry.file_data = IO::LikeHelpers::IOWrapper.new(StringIO.new(content))
+        archive << entry
+      end
+
+      archive = RuZip::Archive.new(path)
+
+      assert_nil archive.by_name("日本語.txt")
+
+      file = archive.by_name(inner_path_sjis)
+      assert_kind_of RuZip::File, file
+      assert_equal inner_path_sjis, file.name.force_encoding("Shift_JIS")
+    end
+  end
 end

data/test/test_writer.rb

@@ -1,6 +1,4 @@
 require_relative "helper"
-require "tmpdir"
-require "archive/zip"
 
 class TestWriter < Test::Unit::TestCase
   test "new with path" do
@@ -35,10 +33,194 @@ class TestWriter < Test::Unit::TestCase
       writer.finish
 
       Archive::Zip.open path do |archive|
-        file = archive.each.first
+        file = archive.each.first #: Archive::Zip::Entry::File
         assert_equal inner_path, file.zip_path
         assert_equal content, file.file_data.read(content.length)
       end
     end
   end
+
+  test "add content multi times" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "output.zip")
+      writer = RuZip::Writer.new(path)
+      inner_path = "hello.txt"
+      writer.start_file(inner_path)
+      n = 3
+      n.times do |i|
+        writer.write i.to_s
+      end
+      writer.finish
+
+      Archive::Zip.open path do |archive|
+        file = archive.each.first #: Archive::Zip::Entry::File
+        assert_equal inner_path, file.zip_path
+        assert_equal "012", file.file_data.read(n)
+      end
+    end
+  end
+
+  test "add content with compression option" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "output.zip")
+      writer = RuZip::Writer.new(path)
+      content = "Hello, World!" * 100
+      inner_path = "hello.txt"
+      inner_path_stored = "hello-xz.txt"
+      writer.start_file(inner_path)
+      writer.write content
+      writer.start_file(inner_path_stored, compression_method: :stored)
+      writer.write content
+      writer.finish
+
+      Zip::File.open path do |archive|
+        entries = archive.each.to_a
+        hello = entries[0]
+        hello_stored= entries[1]
+        assert do
+          hello.compressed_size < hello_stored.compressed_size
+        end
+      end
+    end
+  end
+
+  test "new with append mode add file" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "accessible_epub_3.epub")
+      FileUtils.copy fixture_path("accessible_epub_3.epub"), path
+
+      writer = RuZip::Writer.new(path, "a")
+      inner_path = "hello.txt"
+      writer.start_file(inner_path)
+      content = "Hello, World!"
+      writer.write content
+      writer.finish
+
+      Zip::File.open path do |archive|
+        entries = archive.each.to_a #: [Zip::Entry]
+        assert_equal 39, entries.length
+
+        file = entries.last
+        assert_equal inner_path, file.name
+        assert_equal content, file.get_input_stream.read
+      end
+    end
+  end
+
+  test "append_file" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "output.zip")
+      writer = RuZip::Writer.new(path)
+      inner_path = "hello.txt"
+      content = "Hello, World!"
+      writer.append_file(inner_path, content)
+      writer.finish
+
+      Archive::Zip.open path do |archive|
+        file = archive.each.first #: Archive::Zip::Entry::File
+        assert_equal inner_path, file.zip_path
+        assert_equal content, file.file_data.read(content.length)
+      end
+    end
+  end
+
+  test "raw_copy_file" do
+    Dir.mktmpdir do |dir|
+      input = File.join(dir, "input.zip")
+      output = File.join(dir, "output.zip")
+      inner_path = "hello.txt"
+      content = "Hello, World!"
+      Archive::Zip.open input, :w do |archive|
+        entry = Archive::Zip::Entry::File.new(inner_path)
+        entry.file_data = IO::LikeHelpers::IOWrapper.new(StringIO.new(content))
+        archive << entry
+      end
+
+      file = RuZip::Archive.new(input).by_index(0)
+      writer = RuZip::Writer.new(output)
+      writer.raw_copy_file file
+      writer.finish
+
+      Archive::Zip.open output do |archive|
+        copy = archive.each.first #: Archive::Zip::Entry::File
+        assert_equal inner_path, copy.zip_path
+        assert_equal content, copy.file_data.read(content.length)
+      end
+    end
+  end
+
+  test "raw_copy_file with name" do
+    Dir.mktmpdir do |dir|
+      input = File.join(dir, "input.zip")
+      output = File.join(dir, "output.zip")
+      inner_path = "hello.txt"
+      content = "Hello, World!"
+      Archive::Zip.open input, :w do |archive|
+        entry = Archive::Zip::Entry::File.new(inner_path)
+        entry.file_data = IO::LikeHelpers::IOWrapper.new(StringIO.new(content))
+        archive << entry
+      end
+
+      renamed_path = "renamed.txt"
+      file = RuZip::Archive.new(input).by_index(0)
+      writer = RuZip::Writer.new(output)
+      writer.raw_copy_file file, name: renamed_path
+      writer.finish
+
+      Archive::Zip.open output do |archive|
+        copy = archive.each.first #: Archive::Zip::Entry::File
+        assert_equal renamed_path, copy.zip_path
+        assert_equal content, copy.file_data.read(content.length)
+      end
+    end
+  end
+
+  test "raw_copy_file with timestamp" do
+    Dir.mktmpdir do |dir|
+      input = File.join(dir, "input.zip")
+      output = File.join(dir, "output.zip")
+      inner_path = "hello.txt"
+      content = "Hello, World!"
+      Archive::Zip.open input, :w do |archive|
+        entry = Archive::Zip::Entry::File.new(inner_path)
+        entry.file_data = IO::LikeHelpers::IOWrapper.new(StringIO.new(content))
+        archive << entry
+      end
+
+      file = RuZip::Archive.new(input).by_index(0)
+      writer = RuZip::Writer.new(output)
+      writer.raw_copy_file file, last_modified_time: Time.new(2026, 1, 1)
+      writer.finish
+
+      Archive::Zip.open output do |archive|
+        copy = archive.each.first #: Archive::Zip::Entry::File
+        assert_equal Time.new(2026, 1, 1), copy.mtime
+      end
+    end
+  end
+
+  test "raw_copy_file with nil timestamp" do
+    Dir.mktmpdir do |dir|
+      input = File.join(dir, "input.zip")
+      output = File.join(dir, "output.zip")
+      inner_path = "hello.txt"
+      content = "Hello, World!"
+      Archive::Zip.open input, :w do |archive|
+        entry = Archive::Zip::Entry::File.new(inner_path)
+        entry.file_data = IO::LikeHelpers::IOWrapper.new(StringIO.new(content))
+        archive << entry
+      end
+      orig = Archive::Zip.open(input) {|archive| archive.each.first} #: Archive::Zip::Entry::File
+
+      file = RuZip::Archive.new(input).by_index(0)
+      writer = RuZip::Writer.new(output)
+      writer.raw_copy_file file, last_modified_time: nil
+      writer.finish
+
+      Archive::Zip.open output do |archive|
+        copy = archive.each.first #: Archive::Zip::Entry::File
+        assert_equal orig.mtime, copy.mtime
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruzip
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kitaiti Makoto
@@ -135,6 +135,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
   requirement: !ruby/object:Gem::Requirement
@@ -180,11 +194,18 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- Steepfile
 - ext/Cargo.lock
 - ext/Cargo.toml
 - ext/src/lib.rs
+- rbs_collection.yaml
 - ruzip.gemspec
 - sig/ruzip.rbs
+- sig/test/archive-zip.rbs
+- sig/test/gem.rbs
+- sig/test/io-like.rbs
+- sig/test/test-unit.rbs
+- sig/test/test.rbs
 - test/fixtures/.gitkeep
 - test/helper.rb
 - test/test_archive.rb
@@ -205,7 +226,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="