ziperu 0.1.1-aarch64-linux

data/lib/ziperu/null_input_stream.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Ziperu
+  # What `get_input_stream` hands out for a directory entry: an IO-like
+  # object that is already at EOF. A module, as in rubyzip, so it is passed
+  # around by reference rather than instantiated.
+  module NullInputStream # :nodoc:all
+    extend ::Ziperu::IOExtras::FakeIO
+
+    class << self
+      def read(maxlen = nil, _out_string = nil)
+        maxlen.nil? || maxlen.zero? ? '' : nil
+      end
+      alias sysread read
+
+      def gets(*_args, **_opts)
+        nil
+      end
+
+      def readline(*_args, **_opts)
+        raise EOFError
+      end
+
+      def readlines(*_args, **_opts)
+        []
+      end
+
+      def each(*_args, **_opts)
+        return to_enum(:each) unless block_given?
+      end
+      alias each_line each
+
+      def eof?
+        true
+      end
+      alias eof eof?
+
+      def pos
+        0
+      end
+
+      def lineno
+        0
+      end
+
+      def rewind; end
+
+      def close; end
+
+      def size
+        nil
+      end
+    end
+  end
+end

data/lib/ziperu/output_stream.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Ziperu
+  # Writes zip archives entry by entry, with rubyzip's `Ziperu::OutputStream`
+  # API: `put_next_entry` opens an entry, then the IO-like methods (`<<`,
+  # `write`, `puts`, `print`) fill it.
+  #
+  #   Ziperu::OutputStream.open("my.zip") do |io|
+  #     io.put_next_entry("first_entry.txt")
+  #     io.write "Hello world!"
+  #   end
+  #
+  # `write_buffer` writes to an IO (a StringIO by default) instead of a file.
+  class OutputStream
+    include ::Ziperu::IOExtras::AbstractOutputStream
+
+    attr_accessor :comment
+
+    # Opens the indicated zip file. If a file with that name already exists
+    # it will be overwritten. With `stream: true`, `file_name` is an IO
+    # object that receives the archive from its start, entry by entry if it
+    # is seekable (a StringIO, File or Tempfile) and all at once on
+    # `close_buffer` if it is not (a pipe).
+    def initialize(file_name, stream: false, encrypter: nil, suppress_extra_fields: false, **opts)
+      super(**opts)
+      @file_name = file_name
+      @io = nil
+      if stream
+        @io = file_name
+        @io.binmode if @io.respond_to?(:binmode)
+        @writer =
+          if IOExtras.seekable?(@io)
+            @io.rewind if @io.respond_to?(:rewind)
+            Native::Writer.open_io(@io)
+          else
+            Native::Writer.open_memory
+          end
+      else
+        @writer = Native::Writer.open_path(file_name.to_s)
+      end
+      @encrypter = encrypter || ::Ziperu::NullEncrypter.new
+      @suppress_extra_fields = suppress_extra_fields
+      @comment = ''
+      @closed = false
+      @current_entry = nil
+      @written = []
+    end
+
+    class << self
+      # Same as #initialize but if a block is passed the opened stream is
+      # passed to the block and closed when the block returns.
+      def open(file_name, encrypter: nil, suppress_extra_fields: false, **opts)
+        unless block_given?
+          return new(file_name, encrypter: encrypter,
+                                suppress_extra_fields: suppress_extra_fields, **opts)
+        end
+
+        zos = new(file_name, stream: false, encrypter: encrypter,
+                             suppress_extra_fields: suppress_extra_fields, **opts)
+        yield zos
+      ensure
+        zos.close if zos
+      end
+
+      # Same as #open but writes to an IO instead; returns the IO.
+      def write_buffer(io = ::StringIO.new, encrypter: nil, suppress_extra_fields: false, **opts)
+        zos = new(io, stream: true, encrypter: encrypter,
+                      suppress_extra_fields: suppress_extra_fields, **opts)
+        yield zos
+        zos.close_buffer
+      end
+    end
+
+    # Closes the stream and writes the central directory. A stream over an
+    # IO (`stream: true`) closes it too, as rubyzip does; `close_buffer` is
+    # the variant that leaves it open.
+    def close
+      return if @closed
+
+      finish_archive
+      @io.close if @io && @io.respond_to?(:close)
+      @closed = true
+      nil
+    end
+
+    # Closes the stream and completes the archive in the IO given to
+    # `write_buffer`; returns that IO.
+    def close_buffer
+      return @io if @closed
+
+      finish_archive
+      @closed = true
+      @io
+    end
+
+    # Closes the current entry and opens a new one for writing. `entry_name`
+    # can be a Ziperu::Entry or a string.
+    def put_next_entry(
+      entry_name, comment = '', extra = ExtraField.new,
+      compression_method = Entry::DEFLATED, level = Ziperu.default_compression
+    )
+      raise Error, 'zip stream is closed' if @closed
+
+      new_entry =
+        if entry_name.kind_of?(Entry) || entry_name.kind_of?(StreamableStream)
+          entry_name
+        else
+          Entry.new(
+            @file_name, entry_name.to_s, comment: comment, extra: extra,
+            compression_method: compression_method, compression_level: level
+          )
+        end
+
+      init_next_entry(new_entry)
+      @written << new_entry
+      @current_entry = new_entry
+    end
+
+    # Copies an entry from another archive without recompressing it. With
+    # `touch: true` the entry's current permissions and mtime are written
+    # instead of the source's. The native writer can do that or a rename,
+    # not both, and carries nothing else over from the entry object;
+    # `Entry#write_to_zip_output_stream` re-streams edited entries instead.
+    def copy_raw_entry(entry, new_name = nil, touch: false) # :nodoc:
+      raise Error, 'zip stream is closed' if @closed
+      raise Error, 'entry is not a ZipEntry' unless entry.kind_of?(Entry)
+      raise Error, "entry '#{entry.name}' is not in an archive" if entry.archive.nil?
+      if entry.index.nil?
+        raise Error, "entry '#{entry.name}' shares its name with another record and cannot be copied raw"
+      end
+
+      touch_opts =
+        if touch && new_name.nil?
+          time = DOSTime.from_time(entry.time)
+          { dos_date: time.to_binary_dos_date, dos_time: time.to_binary_dos_time,
+            unix_perms: entry.unix_perms }
+        end
+      @writer.raw_copy(entry.archive, entry.index, new_name, touch_opts)
+      @written << entry
+      @current_entry = nil
+    end
+
+    # Modeled after IO.<<
+    def <<(data)
+      raise IOError, 'closed stream' if @closed || @current_entry.nil?
+
+      @writer.write(data.to_s.b)
+      self
+    end
+
+    private
+
+    def finish_archive
+      comment = @comment.to_s.b
+      raise ArgumentError, "archive comment is #{comment.bytesize} bytes; the limit is 65535" if comment.bytesize > 0xFFFF
+
+      @writer.comment = comment
+      @current_entry = nil
+      bytes, stats = @writer.finish
+      stats.each_with_index do |(offset, size, compressed_size, crc), i|
+        @written[i].written_as(offset, size, compressed_size, crc)
+      end
+      # A seekable IO already holds the archive; a pipe gets it now.
+      return unless bytes && @io
+
+      @io.write(bytes)
+      @io.flush if @io.respond_to?(:flush)
+    end
+
+    def init_next_entry(entry)
+      unless WRITABLE_COMPRESSION_METHODS.include?(entry.compression_method)
+        raise ::Ziperu::CompressionMethodError, entry.compression_method
+      end
+
+      opts = native_entry_options(entry)
+      if entry.directory?
+        @writer.add_directory(entry.name, opts)
+      elsif entry.symlink?
+        @writer.add_symlink(entry.name, entry.symlink_target, opts)
+      else
+        opts.merge!(@encrypter.native_options)
+        @writer.start_entry(entry.name.b, opts)
+      end
+    end
+
+    # Translate a Ziperu::Entry into the Hash the native writer takes.
+    def native_entry_options(entry)
+      suppress = @suppress_extra_fields
+      zip64_suppressed = suppress == true || [*suppress].include?(:zip64)
+      extra = entry.extra.dup
+      extra.suppress_fields!(suppress) if suppress
+      extra.delete(:zip64) # the native writer emits its own
+
+      level = entry.compression_level
+      # An extra field may hand back a plain Time.
+      time = DOSTime.from_time(entry.time)
+      {
+        method: entry.compression_method,
+        level: (level if entry.compression_method != Entry::STORED && level &&
+                         level != Zlib::DEFAULT_COMPRESSION),
+        dos_date: time.to_binary_dos_date,
+        dos_time: time.to_binary_dos_time,
+        unix_perms: entry.unix_perms,
+        fstype: entry.fstype,
+        large_file: zip64_needed?(entry, zip64_suppressed),
+        comment: entry.comment.to_s.b,
+        extra: extra.to_local_bin.b,
+        central_extra: extra.to_c_dir_bin.b
+      }
+    end
+
+    # rubyzip writes a zip64 extra for a file entry only when it has to:
+    # the size is unknown up front (it may turn out huge) or is already
+    # over the 32-bit limit. The native writer does the same with
+    # `large_file`.
+    def zip64_needed?(entry, suppressed)
+      return true if entry.size >= 0xFFFFFFFF || entry.compressed_size >= 0xFFFFFFFF
+      return false if suppressed || !Ziperu.write_zip64_support || !entry.file?
+
+      entry.zip64? || !entry.size_known?
+    end
+  end
+end

data/lib/ziperu/pass_thru_compressor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+# Not on any ziperu code path: the Rust core compresses and decompresses.
+# Kept so that code which references these classes keeps loading.
+module Ziperu
+  class PassThruCompressor < Compressor # :nodoc:all
+    def initialize(output_stream, encrypter = NullEncrypter.new)
+      super()
+      @output_stream = output_stream
+      @encrypter = encrypter
+      @crc = Zlib.crc32
+      @size = 0
+    end
+
+    def <<(data)
+      val = data.to_s
+      @crc = Zlib.crc32(val, @crc)
+      @size += val.bytesize
+      @output_stream << @encrypter.encrypt(val)
+    end
+
+    attr_reader :size, :crc
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/ziperu/pass_thru_decompressor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+# Not on any ziperu code path: the Rust core compresses and decompresses.
+# Kept so that code which references these classes keeps loading.
+module Ziperu
+  class PassThruDecompressor < Decompressor # :nodoc:all
+    def initialize(*args)
+      super
+      @read_so_far = 0
+    end
+
+    def read(maxlen = nil)
+      return (maxlen.nil? || maxlen.zero? ? '' : nil) if eof?
+
+      if maxlen.nil? || (@read_so_far + maxlen) > decompressed_size
+        maxlen = decompressed_size - @read_so_far
+      end
+
+      @read_so_far += maxlen
+      input_stream.read(maxlen)
+    end
+
+    def eof?
+      @read_so_far >= decompressed_size
+    end
+
+    # Alias for compatibility. Remove for version 4.
+    alias eof eof?
+  end
+
+  ::Ziperu::Decompressor.register(::Ziperu::COMPRESSION_METHOD_STORE, ::Ziperu::PassThruDecompressor)
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/ziperu/streamable_directory.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Ported from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  class StreamableDirectory < Entry # :nodoc:
+    def initialize(zipfile, entry, src_path = nil, permission = nil)
+      super(zipfile, entry)
+
+      @ftype = :directory
+      get_extra_attributes_from_path(src_path) if src_path
+      @unix_perms = permission if permission
+    end
+  end
+end

data/lib/ziperu/streamable_stream.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Ported from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # An entry whose contents are being written through `get_output_stream`:
+  # the data goes to a tempfile until the archive is committed.
+  class StreamableStream < DelegateClass(Entry) # :nodoc:all
+    def initialize(entry)
+      super
+      @temp_file = Tempfile.new(::File.basename(name))
+      @temp_file.binmode
+    end
+
+    def get_output_stream
+      if block_given?
+        begin
+          yield(@temp_file)
+        ensure
+          @temp_file.close
+        end
+      else
+        @temp_file
+      end
+    end
+
+    def read_all # :nodoc:
+      get_input_stream(&:read)
+    end
+
+    def get_input_stream
+      unless @temp_file.closed?
+        raise StandardError, "cannot open entry for reading while its open for writing - #{name}"
+      end
+
+      @temp_file.open # reopens tempfile from top
+      @temp_file.binmode
+      if block_given?
+        begin
+          yield(@temp_file)
+        ensure
+          @temp_file.close
+        end
+      else
+        @temp_file
+      end
+    end
+
+    def write_to_zip_output_stream(output_stream)
+      output_stream.put_next_entry(self)
+      get_input_stream { |is| ::Ziperu::IOExtras.copy_stream(output_stream, is) }
+    end
+
+    def clean_up
+      super
+      @temp_file.unlink
+    end
+  end
+end

data/lib/ziperu/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ziperu
+  VERSION = "0.1.1"
+  # The rubyzip API this gem tracks.
+  RUBYZIP_COMPAT_VERSION = "3.7"
+end

data/lib/ziperu.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Same standard-library surface rubyzip loads, since code downstream tends
+# to rely on it being there.
+require 'English'
+require 'delegate'
+require 'digest'
+require 'fileutils'
+require 'forwardable'
+require 'pathname'
+require 'rbconfig'
+require 'singleton'
+require 'stringio'
+require 'tempfile'
+require 'zlib'
+
+require_relative "ziperu/version"
+require_relative "ziperu/errors"
+
+# Prefer the precompiled, Ruby-version-specific binary shipped in native gems;
+# fall back to the one rake-compiler builds for source installs.
+begin
+  require "ziperu/#{RUBY_VERSION[/\d+\.\d+/]}/ziperu"
+rescue LoadError
+  require "ziperu/ziperu"
+end
+
+require_relative "ziperu/constants"
+require_relative "ziperu/dos_time"
+require_relative "ziperu/central_directory"
+require_relative "ziperu/ioextras"
+require_relative "ziperu/dirtyable"
+require_relative "ziperu/extra_field"
+require_relative "ziperu/crypto"
+require_relative "ziperu/null_input_stream"
+require_relative "ziperu/input_stream"
+require_relative "ziperu/output_stream"
+require_relative "ziperu/entry"
+require_relative "ziperu/entry_set"
+require_relative "ziperu/streamable_stream"
+require_relative "ziperu/compressor"
+require_relative "ziperu/decompressor"
+require_relative "ziperu/null_compressor"
+require_relative "ziperu/null_decompressor"
+require_relative "ziperu/pass_thru_compressor"
+require_relative "ziperu/pass_thru_decompressor"
+require_relative "ziperu/inflater"
+require_relative "ziperu/deflater"
+require_relative "ziperu/streamable_directory"
+require_relative "ziperu/file_split"
+require_relative "ziperu/file"
+
+# Drop-in replacement for rubyzip, backed by a Rust core.
+#
+# The main entry points are File, InputStream and OutputStream. Global
+# behaviour is configured with Ziperu.setup, exactly as in rubyzip:
+#
+#   Ziperu.setup do |c|
+#     c.on_exists_proc = true
+#     c.unicode_names = true
+#   end
+module Ziperu
+  # Used by the ported Deflater only; kept because rubyzip exposes it.
+  ZLIB_FLUSHING_STRATEGY = defined?(JRUBY_VERSION) ? Zlib::SYNC_FLUSH : Zlib::NO_FLUSH
+
+  extend self
+
+  attr_accessor :unicode_names,
+                :on_exists_proc,
+                :continue_on_exists_proc,
+                :sort_entries,
+                :default_compression,
+                :write_zip64_support,
+                :warn_invalid_date,
+                :case_insensitive_match,
+                :force_entry_names_encoding,
+                :validate_entry_sizes,
+                :validate_declared_number_of_entries,
+                :max_entries,
+                :max_total_size
+
+  DEFAULT_RESTORE_OPTIONS = {
+    restore_ownership:   false,
+    restore_permissions: true,
+    restore_times:       true
+  }.freeze # :nodoc:
+
+  def reset! # :nodoc:
+    @_ran_once = false
+    @unicode_names = false
+    @on_exists_proc = false
+    @continue_on_exists_proc = false
+    @sort_entries = false
+    @default_compression = Zlib::DEFAULT_COMPRESSION
+    @write_zip64_support = true
+    @warn_invalid_date = true
+    @case_insensitive_match = false
+    @force_entry_names_encoding = nil
+    @validate_entry_sizes = true
+    @validate_declared_number_of_entries = false
+    # Opening an archive with more entries, or more declared uncompressed
+    # bytes, than these raises Ziperu::LimitError. Nil means no limit. With
+    # `validate_entry_sizes` on, no entry inflates past its declared size,
+    # so the total is a real bound on what can be extracted.
+    @max_entries = nil
+    @max_total_size = nil
+  end
+
+  # Set options in one block. The block runs only the first time.
+  def setup
+    yield self unless @_ran_once
+    @_ran_once = true
+  end
+
+  reset!
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: ziperu
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: aarch64-linux
+authors:
+- Maor Caplan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-11-09 00:00:00.000000000 Z
+dependencies: []
+description: Zip reading and writing for Ruby with rubyzip's API under the Ziperu
+  namespace, implemented on the Rust `zip` crate via Magnus. `require "zip"` aliases
+  Zip = Ziperu so rubyzip code runs unchanged. Precompiled binaries, no C toolchain
+  needed.
+email:
+- caplanmaor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE-rubyzip.txt
+- LICENSE.txt
+- README.md
+- lib/rubyzip.rb
+- lib/zip.rb
+- lib/zip/central_directory.rb
+- lib/zip/compressor.rb
+- lib/zip/constants.rb
+- lib/zip/crypto.rb
+- lib/zip/crypto/aes_encryption.rb
+- lib/zip/crypto/decrypted_io.rb
+- lib/zip/crypto/encryption.rb
+- lib/zip/crypto/null_encryption.rb
+- lib/zip/crypto/traditional_encryption.rb
+- lib/zip/decompressor.rb
+- lib/zip/deflater.rb
+- lib/zip/dirtyable.rb
+- lib/zip/dos_time.rb
+- lib/zip/entry.rb
+- lib/zip/entry_set.rb
+- lib/zip/errors.rb
+- lib/zip/extra_field.rb
+- lib/zip/extra_field/aes.rb
+- lib/zip/extra_field/generic.rb
+- lib/zip/extra_field/ntfs.rb
+- lib/zip/extra_field/old_unix.rb
+- lib/zip/extra_field/universal_time.rb
+- lib/zip/extra_field/unix.rb
+- lib/zip/extra_field/unknown.rb
+- lib/zip/extra_field/zip64.rb
+- lib/zip/file.rb
+- lib/zip/file_split.rb
+- lib/zip/filesystem.rb
+- lib/zip/filesystem/dir.rb
+- lib/zip/filesystem/directory_iterator.rb
+- lib/zip/filesystem/file.rb
+- lib/zip/filesystem/file_stat.rb
+- lib/zip/filesystem/zip_file_name_mapper.rb
+- lib/zip/inflater.rb
+- lib/zip/input_stream.rb
+- lib/zip/ioextras.rb
+- lib/zip/ioextras/abstract_input_stream.rb
+- lib/zip/ioextras/abstract_output_stream.rb
+- lib/zip/ioextras/fake_io.rb
+- lib/zip/null_compressor.rb
+- lib/zip/null_decompressor.rb
+- lib/zip/null_input_stream.rb
+- lib/zip/output_stream.rb
+- lib/zip/pass_thru_compressor.rb
+- lib/zip/pass_thru_decompressor.rb
+- lib/zip/streamable_directory.rb
+- lib/zip/streamable_stream.rb
+- lib/zip/version.rb
+- lib/ziperu.rb
+- lib/ziperu/3.1/ziperu.so
+- lib/ziperu/3.2/ziperu.so
+- lib/ziperu/3.3/ziperu.so
+- lib/ziperu/3.4/ziperu.so
+- lib/ziperu/4.0/ziperu.so
+- lib/ziperu/central_directory.rb
+- lib/ziperu/compressor.rb
+- lib/ziperu/constants.rb
+- lib/ziperu/crypto.rb
+- lib/ziperu/decompressor.rb
+- lib/ziperu/deflater.rb
+- lib/ziperu/dirtyable.rb
+- lib/ziperu/dos_time.rb
+- lib/ziperu/entry.rb
+- lib/ziperu/entry_set.rb
+- lib/ziperu/errors.rb
+- lib/ziperu/extra_field.rb
+- lib/ziperu/extra_field/aes.rb
+- lib/ziperu/extra_field/generic.rb
+- lib/ziperu/extra_field/ntfs.rb
+- lib/ziperu/extra_field/old_unix.rb
+- lib/ziperu/extra_field/universal_time.rb
+- lib/ziperu/extra_field/unix.rb
+- lib/ziperu/extra_field/unknown.rb
+- lib/ziperu/extra_field/zip64.rb
+- lib/ziperu/file.rb
+- lib/ziperu/file_split.rb
+- lib/ziperu/filesystem.rb
+- lib/ziperu/filesystem/dir.rb
+- lib/ziperu/filesystem/directory_iterator.rb
+- lib/ziperu/filesystem/file.rb
+- lib/ziperu/filesystem/file_stat.rb
+- lib/ziperu/filesystem/zip_file_name_mapper.rb
+- lib/ziperu/inflater.rb
+- lib/ziperu/input_stream.rb
+- lib/ziperu/ioextras.rb
+- lib/ziperu/ioextras/abstract_input_stream.rb
+- lib/ziperu/ioextras/abstract_output_stream.rb
+- lib/ziperu/ioextras/fake_io.rb
+- lib/ziperu/null_compressor.rb
+- lib/ziperu/null_decompressor.rb
+- lib/ziperu/null_input_stream.rb
+- lib/ziperu/output_stream.rb
+- lib/ziperu/pass_thru_compressor.rb
+- lib/ziperu/pass_thru_decompressor.rb
+- lib/ziperu/streamable_directory.rb
+- lib/ziperu/streamable_stream.rb
+- lib/ziperu/version.rb
+homepage: https://github.com/caplanmaor/ziperu
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/caplanmaor/ziperu
+  source_code_uri: https://github.com/caplanmaor/ziperu
+  changelog_uri: https://github.com/caplanmaor/ziperu/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: A drop-in rubyzip replacement backed by Rust.
+test_files: []