ruzip 0.1.0 → 0.2.0

data/ext/src/lib.rs

@@ -1,56 +1,22 @@
-use magnus::{
-    Error, Integer, RString, Ruby, Symbol, Value, class, exception, function, method, prelude::*,
-};
+use magnus::{Error, Integer, RString, Ruby, Value, class, function, method, prelude::*};
+use std::cell::RefCell;
 use std::fs;
-use std::io::{self, Read};
+use std::io::{Read, Write};
 use std::os::fd::FromRawFd;
 use std::sync::{Arc, Mutex};
-use zip::ZipArchive;
+use zip::{ZipArchive, ZipWriter};
 
 type Result<T> = std::result::Result<T, Error>;
 
-#[magnus::wrap(class = "RuZip::Archive", free_immediately, size)]
-struct Archive(Arc<Mutex<ZipArchive<fs::File>>>);
-
-struct IO(Value);
-
-impl io::Read for IO {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let buf_len = buf.len();
-        let r_string: Value = self.0.funcall_public("read", (buf_len,)).unwrap(); // FIXME: unwrap(). Should use second arg?
-        if r_string.is_nil() {
-            Ok(0)
-        } else {
-            let data = r_string.to_string();
-            let len = data.len();
-            buf.clone_from_slice(data.as_bytes()); // FIXME: clone_from_slice panics when sizes of buf and data are not the same
-            Ok(len)
-        }
-    }
+fn map_err(err: impl std::error::Error, ruby: &Ruby) -> Error {
+    Error::new(ruby.exception_runtime_error(), format!("{}", err))
 }
 
-impl io::Seek for IO {
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        use io::SeekFrom::*;
-        let value = self.0;
-
-        match pos {
-            Start(i) => value
-                .funcall_public::<&str, (u64, Symbol), u64>("seek", (i, Symbol::new("SET")))
-                .unwrap(), // FIXME: unwrap()
-            End(i) => value
-                .funcall_public("seek", (i, Symbol::new("END")))
-                .unwrap(),
-            Current(i) => value
-                .funcall_public("seek", (i, Symbol::new("CUR")))
-                .unwrap(),
-        };
-        Ok(value.funcall_public("pos", ()).unwrap())
-    }
-}
+#[magnus::wrap(class = "RuZip::Archive", free_immediately, size)]
+struct Archive(Arc<Mutex<ZipArchive<fs::File>>>);
 
 impl Archive {
-    fn new(r_io: Value) -> Result<Self> {
+    fn new(ruby: &Ruby, r_io: Value) -> Result<Self> {
         let io = if r_io.is_kind_of(class::io()) {
             let fileno: Integer = r_io.funcall_public("fileno", ())?;
             let raw_fd = fileno.to_i32()?;
@@ -60,58 +26,46 @@ impl Archive {
                 r_io.funcall_public::<&str, (), RString>("to_path", ())?
                     .to_string()?,
             )
-            .unwrap()
+            .map_err(|e| map_err(e, ruby))?
         } else if r_io.respond_to("read", false)? {
             // IO(r_io);
             todo!("#read");
         } else if r_io.is_kind_of(class::string()) {
-            fs::File::open(r_io.to_r_string()?.to_string()?).unwrap() // FIXME: unwrap()
+            fs::File::open(r_io.to_r_string()?.to_string()?).map_err(|e| map_err(e, ruby))?
         } else {
             return Err(Error::new(
-                exception::type_error(),
+                ruby.exception_type_error(),
                 format!("Unsupported argument type: {}", r_io.inspect()),
             ));
         };
-        let zip: ZipArchive<fs::File> = ZipArchive::new(io)
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?;
+        let zip: ZipArchive<fs::File> = ZipArchive::new(io).map_err(|e| map_err(e, ruby))?;
         Ok(Self(Arc::new(Mutex::new(zip))))
     }
 
-    fn len(&self) -> Result<usize> {
-        Ok(self
-            .0
-            .lock()
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
-            .len())
+    fn len(ruby: &Ruby, rb_self: &Self) -> Result<usize> {
+        Ok(rb_self.0.lock().map_err(|e| map_err(e, ruby))?.len())
     }
 
-    fn by_index(&self, index: usize) -> Result<File> {
-        match self
+    fn by_index(ruby: &Ruby, rb_self: &Self, index: usize) -> Result<File> {
+        match rb_self
             .0
             .lock()
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
+            .map_err(|e| map_err(e, ruby))?
             .by_index(index)
         {
-            Ok(_) => Ok(File(self.0.clone(), index)),
-            Err(e) => Err(Error::new(exception::runtime_error(), format!("{}", e))),
+            Ok(_) => Ok(File(rb_self.0.clone(), index)),
+            Err(e) => Err(map_err(e, ruby)),
         }
     }
 
-    fn by_name(&self, name: RString) -> Result<Option<File>> {
-        let name_string = name
-            .to_string()
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?;
-        let mut archive = self
-            .0
-            .lock()
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?;
+    fn by_name(ruby: &Ruby, rb_self: &Self, name: String) -> Result<Option<File>> {
+        let name_bytes = name.as_bytes();
+        let mut archive = rb_self.0.lock().map_err(|e| map_err(e, ruby))?;
         // TODO: Cache entries
         for i in 0..archive.len() {
-            let file = archive
-                .by_index(i)
-                .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?;
-            if file.name_raw() == name_string.clone().into_bytes() {
-                return Ok(Some(File(self.0.clone(), i)));
+            let file = archive.by_index(i).map_err(|e| map_err(e, ruby))?;
+            if file.name_raw() == name_bytes {
+                return Ok(Some(File(rb_self.0.clone(), i)));
             }
         }
         Ok(None)
@@ -122,42 +76,42 @@ impl Archive {
 struct File(Arc<Mutex<ZipArchive<fs::File>>>, usize);
 
 impl File {
-    // FIXME: exception::runtime_error() -> ruby.exception_runtime_error()
-    fn name(&self) -> Result<String> {
+    fn name(ruby: &Ruby, rb_self: &Self) -> Result<String> {
         String::from_utf8(
-            self.0
+            rb_self
+                .0
                 .lock()
-                .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
-                .by_index(self.1)
-                .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
+                .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| Error::new(exception::runtime_error(), format!("{}", e)))
+        .map_err(|e| map_err(e, ruby))
     }
 
-    fn size(&self) -> Result<u64> {
-        let size = self
+    fn size(ruby: &Ruby, rb_self: &Self) -> Result<u64> {
+        let size = rb_self
             .0
             .lock()
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
-            .by_index(self.1)
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
+            .map_err(|e| map_err(e, ruby))?
+            .by_index(rb_self.1)
+            .map_err(|e| map_err(e, ruby))?
             .size();
         Ok(size)
     }
 
     // TODO: Use ExtendedTimestamp if available
-    fn last_modified(&self) -> Result<Option<Value>> {
-        let last_modified = self
+    fn last_modified(ruby: &Ruby, rb_self: &Self) -> Result<Option<Value>> {
+        let last_modified = rb_self
             .0
             .lock()
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
-            .by_index(self.1)
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
+            .map_err(|e| map_err(e, ruby))?
+            .by_index(rb_self.1)
+            .map_err(|e| map_err(e, ruby))?
             .last_modified();
         match last_modified {
-            Some(mtime) => Ok(Some(magnus::class::time().new_instance((
+            Some(mtime) => Ok(Some(ruby.class_time().new_instance((
                 mtime.year(),
                 mtime.month(),
                 mtime.day(),
@@ -169,16 +123,70 @@ impl File {
         }
     }
 
-    fn read(&self) -> Result<String> {
-        let mut buf = String::new();
-        self.0
-            .lock()
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
-            .by_index(self.1)
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
-            .read_to_string(&mut buf)
-            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?;
-        Ok(buf)
+    fn read(ruby: &Ruby, rb_self: &Self) -> Result<RString> {
+        let mut archive = rb_self.0.lock().map_err(|e| map_err(e, ruby))?;
+        let mut file = archive.by_index(rb_self.1).map_err(|e| map_err(e, ruby))?;
+        let mut buf = Vec::with_capacity(file.size() as usize);
+        file.read_to_end(&mut buf).map_err(|e| map_err(e, ruby))?;
+        Ok(RString::from_slice(&buf))
+    }
+}
+
+#[magnus::wrap(class = "RuZip::Writer", free_immediately, size)]
+struct Writer(RefCell<Option<ZipWriter<fs::File>>>);
+
+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);
+        Ok(Self(RefCell::new(Some(writer))))
+    }
+
+    fn finish(ruby: &Ruby, rb_self: &Self) -> Result<Archive> {
+        match rb_self.0.take() {
+            Some(writer) => {
+                let archive = writer
+                    .finish_into_readable()
+                    .map_err(|e| map_err(e, ruby))?;
+                Ok(Archive(Arc::new(Mutex::new(archive))))
+            }
+            None => Err(Error::new(
+                ruby.exception_runtime_error(),
+                "Already finished",
+            )),
+        }
+    }
+
+    fn start_file(ruby: &Ruby, rb_self: &Self, name: String) -> Result<()> {
+        match rb_self.0.take() {
+            Some(mut writer) => {
+                writer
+                    .start_file(name, zip::write::SimpleFileOptions::default())
+                    .map_err(|e| map_err(e, ruby))?;
+                rb_self.0.replace(Some(writer));
+                Ok(())
+            }
+            None => Err(Error::new(
+                ruby.exception_runtime_error(),
+                "Already finished",
+            )),
+        }
+    }
+
+    fn write(ruby: &Ruby, rb_self: &Self, buf: String) -> Result<()> {
+        match rb_self.0.take() {
+            Some(mut writer) => {
+                writer
+                    .write_all(buf.as_bytes())
+                    .map_err(|e| map_err(e, ruby))?;
+                rb_self.0.replace(Some(writer));
+                Ok(())
+            }
+            None => Err(Error::new(
+                ruby.exception_runtime_error(),
+                "Already finished",
+            )),
+        }
     }
 }
 
@@ -198,5 +206,11 @@ fn init(ruby: &Ruby) -> Result<()> {
     file_class.define_method("last_modified", method!(File::last_modified, 0))?;
     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_method("finish", method!(Writer::finish, 0))?;
+    writer_class.define_method("start_file", method!(Writer::start_file, 1))?;
+    writer_class.define_method("write", method!(Writer::write, 1))?;
+
     Ok(())
 }

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 = ">= 2.6.0"
+  spec.required_ruby_version = ">= 3.1.0"
   spec.required_rubygems_version = ">= 3.3.11"
 
   spec.metadata["homepage_uri"] = spec.homepage
@@ -24,16 +24,19 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0")
   end
+  spec.test_files = spec.files.select {|file| file.start_with?("test/")}
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/Cargo.toml"]
 
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rake-compiler"
-  spec.add_development_dependency "test-unit", "~> 3.0"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
   spec.add_development_dependency "test-unit-notify"
-  spec.add_development_dependency "terminal-notifier"
+  spec.add_development_dependency "terminal-notifier" if RUBY_PLATFORM.match?(/darwin/)
   spec.add_development_dependency "rubygems-tasks"
   spec.add_development_dependency "kar"
+  spec.add_development_dependency "rdoc"
+  spec.add_development_dependency "rbs"
+  spec.add_development_dependency "archive-zip"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/sig/ruzip.rbs

@@ -1,4 +1,26 @@
 module RuZip
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  class Archive
+    def self.new: (IO | path) -> instance
+    def len: -> Integer
+    def by_index: (Integer) -> File
+    def by_name: (String) -> File
+  end
+
+  class File
+    def name: -> String
+
+    # The size of decompressed file
+    def size: -> Integer
+    def last_modified: -> (Time | nil)
+
+    # Reads contents and returns it as BINARY string
+    def read: -> String
+  end
+
+  class Writer
+    def self.new: (String) -> instance
+    def finish: -> Archive
+    def start_file: (String) -> void
+    def write: (String) -> void
+  end
 end

data/test/test_file.rb

@@ -8,6 +8,14 @@ class TestFile < Test::Unit::TestCase
   test "retrieve" do
     file = @archive.by_name("META-INF/container.xml")
     assert_instance_of RuZip::File, file
+    assert_equal <<XML.gsub(/\r\n/, "\n"), file.read.force_encoding('UTF-8').gsub(/\r\n/, "\n")
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0">
+	<rootfiles>
+		<rootfile full-path="EPUB/package.opf" media-type="application/oebps-package+xml"/>
+	</rootfiles>
+</container>
+XML
   end
 
   test "retrieve non-existent" do

data/test/test_package.rb

@@ -0,0 +1,33 @@
+require "test/unit"
+require "test/unit/notify"
+require 'tempfile'
+require 'tmpdir'
+require 'shellwords'
+
+class TestPackage < Test::Unit::TestCase
+  def test_build
+    Tempfile.create do |file|
+      assert system("gem", "build", "ruzip.gemspec", "--output", file.to_path, exception: true)
+      assert file.size > 0
+      assert_path_exist file.to_path
+    end
+  end
+
+  def test_install
+    gemspec = Gem::Specification.load("ruzip.gemspec")
+    Dir.mktmpdir do |dir|
+      dir = File.realpath(dir)
+      gemfile = File.join(dir, gemspec.file_name)
+      system "gem", "build", "ruzip.gemspec", "--output", gemfile, exception: true
+      install_dir = File.join(dir, "install")
+      FileUtils.mkdir install_dir
+
+      env = {
+        "BUNDLE_GEMFILE" => nil,
+        "RUBYOPT" => nil
+      }
+      system env, "gem", "install", "--install-dir", install_dir, "--no-document", gemfile, exception: true
+      assert_path_exist File.join(install_dir, "gems", gemspec.full_name, "lib", "ruzip.#{RbConfig::CONFIG["DLEXT"]}")
+    end
+  end
+end

data/test/test_writer.rb

@@ -0,0 +1,44 @@
+require_relative "helper"
+require "tmpdir"
+require "archive/zip"
+
+class TestWriter < Test::Unit::TestCase
+  test "new with path" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "output.zip")
+      writer = RuZip::Writer.new(path)
+      assert_kind_of RuZip::Writer, writer
+      assert_path_exist path
+    end
+  end
+
+  test "finish" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "output.zip")
+      writer = RuZip::Writer.new(path)
+      archive = writer.finish
+      assert_instance_of RuZip::Archive, archive
+      assert_raise do
+        writer.finish
+      end
+    end
+  end
+
+  test "add file" 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)
+      content = "Hello, World!"
+      writer.write content
+      writer.finish
+
+      Archive::Zip.open path do |archive|
+        file = archive.each.first
+        assert_equal inner_path, file.zip_path
+        assert_equal content, file.file_data.read(content.length)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruzip
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kitaiti Makoto
@@ -13,18 +13,18 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,21 +38,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: test-unit-notify
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit-notify
+  name: terminal-notifier
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,7 +66,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: terminal-notifier
+  name: rubygems-tasks
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,7 +80,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubygems-tasks
+  name: kar
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,7 +94,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: kar
+  name: rdoc
+  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: rbs
+  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: archive-zip
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -118,8 +146,8 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".gitlab-ci.yml"
+- ".rdoc_options"
 - CHANGELOG.md
-- CODE_OF_CONDUCT.md
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -129,10 +157,12 @@ files:
 - ext/src/lib.rs
 - ruzip.gemspec
 - sig/ruzip.rbs
+- test/fixtures/.gitkeep
 - test/helper.rb
 - test/test_archive.rb
 - test/test_file.rb
-- test/test_ruzip.rb
+- test/test_package.rb
+- test/test_writer.rb
 homepage: https://gitlab.com/KitaitiMakoto/ruzip
 licenses:
 - MIT
@@ -147,14 +177,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Library to support the reading and writing of zip files.
-test_files: []
+test_files:
+- test/fixtures/.gitkeep
+- test/helper.rb
+- test/test_archive.rb
+- test/test_file.rb
+- test/test_package.rb
+- test/test_writer.rb