ruzip 0.1.0

data/ext/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "ruzip"
+version = "0.1.0"
+edition = "2024"
+authors = ["Kitaiti Makoto <KitaitiMakoto@gmail.com>"]
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.7.1" }
+zip = "2.2.0"

data/ext/src/lib.rs

@@ -0,0 +1,202 @@
+use magnus::{
+    Error, Integer, RString, Ruby, Symbol, Value, class, exception, function, method, prelude::*,
+};
+use std::fs;
+use std::io::{self, Read};
+use std::os::fd::FromRawFd;
+use std::sync::{Arc, Mutex};
+use zip::ZipArchive;
+
+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)
+        }
+    }
+}
+
+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())
+    }
+}
+
+impl Archive {
+    fn new(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()?;
+            unsafe { fs::File::from_raw_fd(raw_fd) }
+        } else if r_io.respond_to("to_path", false)? {
+            fs::File::open(
+                r_io.funcall_public::<&str, (), RString>("to_path", ())?
+                    .to_string()?,
+            )
+            .unwrap()
+        } 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()
+        } else {
+            return Err(Error::new(
+                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)))?;
+        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 by_index(&self, index: usize) -> Result<File> {
+        match self
+            .0
+            .lock()
+            .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))?
+            .by_index(index)
+        {
+            Ok(_) => Ok(File(self.0.clone(), index)),
+            Err(e) => Err(Error::new(exception::runtime_error(), format!("{}", e))),
+        }
+    }
+
+    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)))?;
+        // 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)));
+            }
+        }
+        Ok(None)
+    }
+}
+
+#[magnus::wrap(class = "RuZip::File")]
+struct File(Arc<Mutex<ZipArchive<fs::File>>>, usize);
+
+impl File {
+    // FIXME: exception::runtime_error() -> ruby.exception_runtime_error()
+    fn name(&self) -> Result<String> {
+        String::from_utf8(
+            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)))?
+                .name_raw()
+                .into(),
+        )
+        .map_err(|e| Error::new(exception::runtime_error(), format!("{}", e)))
+    }
+
+    fn size(&self) -> Result<u64> {
+        let size = 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)))?
+            .size();
+        Ok(size)
+    }
+
+    // TODO: Use ExtendedTimestamp if available
+    fn last_modified(&self) -> Result<Option<Value>> {
+        let last_modified = 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)))?
+            .last_modified();
+        match last_modified {
+            Some(mtime) => Ok(Some(magnus::class::time().new_instance((
+                mtime.year(),
+                mtime.month(),
+                mtime.day(),
+                mtime.hour(),
+                mtime.minute(),
+                mtime.second(),
+            ))?)),
+            None => Ok(None),
+        }
+    }
+
+    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)
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<()> {
+    let module = ruby.define_module("RuZip")?;
+
+    let archive_class = module.define_class("Archive", ruby.class_object())?;
+    archive_class.define_singleton_method("new", function!(Archive::new, 1))?;
+    archive_class.define_method("length", method!(Archive::len, 0))?;
+
+    let file_class = module.define_class("File", ruby.class_object())?;
+    archive_class.define_method("by_index", method!(Archive::by_index, 1))?;
+    archive_class.define_method("by_name", method!(Archive::by_name, 1))?;
+    file_class.define_method("name", method!(File::name, 0))?;
+    file_class.define_method("size", method!(File::size, 0))?;
+    file_class.define_method("last_modified", method!(File::last_modified, 0))?;
+    file_class.define_method("read", method!(File::read, 0))?;
+
+    Ok(())
+}

data/ruzip.gemspec

@@ -0,0 +1,40 @@
+require "json"
+
+rust_metadata = JSON.load(`cargo metadata --manifest-path=ext/Cargo.toml --no-deps --format-version=1`)
+
+Gem::Specification.new do |spec|
+  spec.name = "ruzip"
+  spec.version = rust_metadata["packages"][0]["version"]
+  spec.authors = ["Kitaiti Makoto"]
+  spec.email = ["KitaitiMakoto@gmail.com"]
+
+  spec.summary = "Library to support the reading and writing of zip files."
+  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_rubygems_version = ">= 3.3.11"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://gitlab.com/KitaitiMakoto/ruzip"
+  spec.metadata["changelog_uri"] = "https://gitlab.com/KitaitiMakoto/ruzip/-/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0")
+  end
+  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 "test-unit-notify"
+  spec.add_development_dependency "terminal-notifier"
+  spec.add_development_dependency "rubygems-tasks"
+  spec.add_development_dependency "kar"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/ruzip.rbs

@@ -0,0 +1,4 @@
+module RuZip
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test/helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "ruzip"
+require "test-unit"
+require "test/unit/notify"
+
+class Test::Unit::TestCase
+  def fixture_path(component)
+    File.join(__dir__, "fixtures", component)
+  end
+end

data/test/test_archive.rb

@@ -0,0 +1,52 @@
+require_relative "helper"
+
+class TestArchive < Test::Unit::TestCase
+  def setup
+    @fixture = fixture_path("accessible_epub_3.epub")
+  end
+
+  test "new with path" do
+    archive = RuZip::Archive.new(@fixture)
+    assert_kind_of RuZip::Archive, archive
+  end
+
+  test "new with pathname" do
+    archive = RuZip::Archive.new(Pathname(@fixture))
+    assert_kind_of RuZip::Archive, archive
+  end
+
+  test "new with file" do
+    archive = RuZip::Archive.new(File.open(@fixture))
+    assert_kind_of RuZip::Archive, archive
+  end
+
+  test "new with closed file" do
+    io = nil
+    File.open @fixture do |file|
+      io = file
+    end
+    assert_raise_kind_of IOError do
+      RuZip::Archive.new(io)
+    end
+  end
+
+  test "new with string io" do
+    pend
+
+    require "stringio"
+    io = StringIO.new("EPUB file")
+    archive = RuZip::Archive.new(io)
+    assert_kind_of RuZip::Archive, archive
+  end
+
+  test "new with unsupported type" do
+    assert_raise_kind_of TypeError do
+      RuZip::Archive.new(:symbol_object)
+    end
+  end
+
+  test "len" do
+    archive = RuZip::Archive::new(@fixture)
+    assert_equal 38, archive.length
+  end
+end

data/test/test_file.rb

@@ -0,0 +1,16 @@
+require_relative "helper"
+
+class TestFile < Test::Unit::TestCase
+  setup do
+    @archive = RuZip::Archive.new(fixture_path("accessible_epub_3.epub"))
+  end
+
+  test "retrieve" do
+    file = @archive.by_name("META-INF/container.xml")
+    assert_instance_of RuZip::File, file
+  end
+
+  test "retrieve non-existent" do
+    assert_nil @archive.by_name("non-existent")
+  end
+end

data/test/test_ruzip.rb

@@ -0,0 +1,7 @@
+require_relative "helper"
+
+class TestRuZip < Test::Unit::TestCase
+  test "version" do
+    assert_equal "0.1.0", Gem.loaded_specs["ruzip"].version.to_s
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: ruzip
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kitaiti Makoto
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  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: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-notify
+  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: terminal-notifier
+  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: rubygems-tasks
+  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: kar
+  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'
+description: Library to support the reading and writing of zip files. A wrapper of
+  Rust's zip crate.
+email:
+- KitaitiMakoto@gmail.com
+executables: []
+extensions:
+- ext/Cargo.toml
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- ext/Cargo.lock
+- ext/Cargo.toml
+- ext/src/lib.rs
+- ruzip.gemspec
+- sig/ruzip.rbs
+- test/helper.rb
+- test/test_archive.rb
+- test/test_file.rb
+- test/test_ruzip.rb
+homepage: https://gitlab.com/KitaitiMakoto/ruzip
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://gitlab.com/KitaitiMakoto/ruzip
+  source_code_uri: https://gitlab.com/KitaitiMakoto/ruzip
+  changelog_uri: https://gitlab.com/KitaitiMakoto/ruzip/-/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Library to support the reading and writing of zip files.
+test_files: []