ziperu 0.1.1-aarch64-linux

data/lib/ziperu/entry_set.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# Ported from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  class EntrySet # :nodoc:all
+    include Enumerable
+
+    attr_reader :entry_set
+    protected   :entry_set
+
+    def initialize(an_enumerable = [])
+      super()
+      # Keyed by name for lookup, as in rubyzip; `@all` keeps every entry
+      # in order, which only differs when an archive holds several records
+      # under one name (see `push_record`).
+      @entry_set = {}
+      @all = []
+      @shadowed = 0
+      an_enumerable.each { |o| push(o) }
+    end
+
+    def include?(entry)
+      @entry_set.include?(to_key(entry))
+    end
+
+    def find_entry(entry)
+      @entry_set[to_key(entry)]
+    end
+
+    def <<(entry)
+      return unless entry
+
+      key = to_key(entry)
+      old = @entry_set[key]
+      return if old.equal?(entry)
+
+      remove_from_all(old) if old
+      @entry_set[key] = entry
+      @all << entry
+    end
+
+    alias push <<
+
+    # Adds a record read from an archive. Unlike `<<`, an earlier record
+    # of the very same name stays listed (and readable); the lookup by name
+    # finds the later one, as rubyzip's does. Names that only share a key
+    # (`Ziperu.case_insensitive_match`, or a trailing slash) collapse to
+    # the later one, as in rubyzip.
+    def push_record(entry)
+      key = to_key(entry)
+      old = @entry_set[key]
+      return self << entry if old.nil? || old.name.b != entry.name.b
+
+      @shadowed += 1
+      @entry_set[key] = entry
+      @all << entry
+    end
+
+    # True for a record that a later one of the same name hides from the
+    # lookup by name: it is listed and readable, but not written back.
+    def shadowed?(entry)
+      return false if @shadowed.zero?
+
+      current = @entry_set[to_key(entry)]
+      !current.nil? && !current.equal?(entry)
+    end
+
+    def size
+      @all.size
+    end
+
+    alias length size
+
+    def delete(entry)
+      key = to_key(entry)
+      removed = @entry_set.delete(key)
+      return if removed.nil?
+
+      remove_from_all(removed)
+      # A record this one shadowed takes over its name.
+      if @shadowed.positive? && (shadowed = @all.reverse_each.find { |e| to_key(e) == key })
+        @shadowed -= 1
+        @entry_set[key] = shadowed
+      end
+      entry
+    end
+
+    def each(&block)
+      entries.each(&block)
+    end
+
+    def entries
+      sorted_entries
+    end
+
+    # deep clone
+    def dup
+      copy = EntrySet.new
+      @all.each { |e| copy.push_record(e.dup) }
+      copy
+    end
+
+    def ==(other)
+      return false unless other.kind_of?(EntrySet)
+
+      entries == other.entries
+    end
+
+    def parent(entry)
+      @entry_set[to_key(entry.parent_as_string)]
+    end
+
+    def glob(pattern, flags = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH | ::File::FNM_EXTGLOB)
+      entries.filter_map do |entry|
+        next nil unless ::File.fnmatch(pattern, entry.name.chomp('/'), flags)
+
+        yield(entry) if block_given?
+        entry
+      end
+    end
+
+    protected
+
+    # A copy: callers rename or remove entries while iterating.
+    def sorted_entries
+      ::Ziperu.sort_entries ? @all.sort_by { |e| to_key(e) } : @all.dup
+    end
+
+    private
+
+    # Removes `entry` itself (not another of the same name) from `@all`.
+    def remove_from_all(entry)
+      i = @all.index { |e| e.equal?(entry) }
+      @all.delete_at(i) if i
+    end
+
+    # Keyed by name bytes: entry names are binary strings (as in rubyzip),
+    # and a lookup with the same bytes in another encoding should find
+    # them (which in rubyzip it does not).
+    def to_key(entry)
+      k = entry.to_s.b.chomp('/')
+      k.downcase! if ::Ziperu.case_insensitive_match
+      k
+    end
+  end
+end

data/lib/ziperu/errors.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# The rubyzip 3.x exception hierarchy, with rubyzip's constructor signatures
+# and messages so rescue clauses and error output are unchanged.
+#
+# The native core looks these up by name, so every class here must exist
+# before the extension raises.
+module Ziperu
+  # The superclass for all error types. Simply rescue this one if you don't
+  # need to know what sort of error has been raised.
+  class Error < StandardError; end
+
+  # Error raised if an unsupported compression method is used.
+  class CompressionMethodError < Error
+    attr_reader :compression_method
+
+    def initialize(method)
+      super()
+      @compression_method = method
+    end
+
+    def message
+      "Unsupported compression method: #{COMPRESSION_METHODS[@compression_method]}."
+    end
+  end
+
+  # Error raised if there is a problem while decompressing an archive entry.
+  class DecompressionError < Error
+    attr_reader :zlib_error
+
+    def initialize(zlib_error)
+      super()
+      @zlib_error = zlib_error
+    end
+
+    def message
+      "Zlib error ('#{@zlib_error.message}') while inflating."
+    end
+  end
+
+  # Error raised when trying to extract an archive entry over an existing file.
+  class DestinationExistsError < Error
+    def initialize(destination)
+      super()
+      @destination = destination
+    end
+
+    def message
+      "Cannot create file or directory '#{@destination}'. " \
+        'A file already exists with that name.'
+    end
+  end
+
+  # Error raised when adding an entry whose name already exists.
+  class EntryExistsError < Error
+    def initialize(source, name)
+      super()
+      @source = source
+      @name = name
+    end
+
+    def message
+      "'#{@source}' failed. Entry #{@name} already exists."
+    end
+  end
+
+  # Error raised when an entry name is invalid.
+  class EntryNameError < Error
+    def initialize(name = nil)
+      super()
+      @name = name
+    end
+
+    def message
+      if @name.nil?
+        'Illegal entry name. Names must have fewer than 65,536 characters.'
+      else
+        "Illegal entry name '#{@name}'. Names must not start with '/'."
+      end
+    end
+  end
+
+  # Error raised if an entry is larger on extraction than advertised.
+  class EntrySizeError < Error
+    attr_reader :entry
+
+    def initialize(entry)
+      super()
+      @entry = entry
+    end
+
+    def message
+      "Entry '#{@entry.name}' should be #{@entry.size}B, but is larger when inflated."
+    end
+  end
+
+  class EntryNumberMismatchError < Error
+    def initialize(size, size_in_bytes)
+      super()
+      @size = size
+      @size_in_bytes = size_in_bytes
+    end
+
+    def message
+      "Zip consistency problem: an impossibly high number of entries (#{@size}) " \
+        'is declared in this file, compared to the size of the central directory ' \
+        "(#{@size_in_bytes} bytes)."
+    end
+  end
+
+  # Error raised if a split archive is read.
+  class SplitArchiveError < Error
+    def message
+      'Rubyzip cannot extract from split archives at this time.'
+    end
+  end
+
+  # Error raised if there is not enough metadata for the entry to be streamed.
+  class StreamingError < Error
+    attr_reader :entry
+
+    def initialize(entry)
+      super()
+      @entry = entry
+    end
+
+    def message
+      "The local header of this entry ('#{@entry.name}') does not contain " \
+        'the correct metadata for `Ziperu::InputStream` to be able to ' \
+        'uncompress it. Please use `Ziperu::File` instead of `Ziperu::InputStream`.'
+    end
+  end
+
+  class GPFBit3Error < Error; end
+  class InternalError < Error; end
+
+  # Raised when an archive exceeds `Ziperu.max_entries` or
+  # `Ziperu.max_total_size` on open.
+  class LimitError < Error
+    def initialize(what, actual, limit)
+      super("archive has #{what} of #{actual}, over the limit of #{limit}")
+    end
+  end
+
+  PASSWORD_REQUIRED_MESSAGE = 'A password is required to decode this zip file.'
+
+  # Raised by the Rust core where it lacks the domain object a rubyzip
+  # exception wants; the Ruby layer re-raises the rubyzip-shaped error.
+  module Native
+    class SizeLimitError < Ziperu::Error; end
+    class PasswordError < Ziperu::Error; end
+    class UnsupportedError < Ziperu::Error; end
+  end
+end

data/lib/ziperu/extra_field/aes.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # Info-ZIP Extra for AES encryption
+  class ExtraField::AES < ExtraField::Generic # :nodoc:
+    attr_accessor :vendor_version, :vendor_id, :encryption_strength, :compression_method
+
+    HEADER_ID = [0x9901].pack('v')
+    register_map
+
+    def initialize(binstr = nil)
+      @vendor_version = nil
+      @vendor_id = nil
+      @encryption_strength = nil
+      @compression_method = nil
+      binstr && merge(binstr)
+    end
+
+    def ==(other)
+      @vendor_version == other.vendor_version &&
+        @vendor_id == other.vendor_id &&
+        @encryption_strength == other.encryption_strength &&
+        @compression_method == other.compression_method
+    end
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      (size && content) || return
+
+      @vendor_version, @vendor_id,
+        @encryption_strength, @compression_method = content.unpack('va2Cv')
+    end
+
+    # We can never suppress the AES extra field as it is needed to read the file.
+    def suppress?
+      false
+    end
+
+    def pack_for_local
+      [@vendor_version, @vendor_id,
+       @encryption_strength, @compression_method].pack('va2Cv')
+    end
+
+    def pack_for_c_dir
+      pack_for_local
+    end
+  end
+end

data/lib/ziperu/extra_field/generic.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  class ExtraField::Generic # :nodoc:
+    def self.register_map
+      return unless const_defined?(:HEADER_ID)
+
+      ::Ziperu::ExtraField::ID_MAP[const_get(:HEADER_ID)] = self
+    end
+
+    def self.name
+      @name ||= to_s.split('::').last.downcase.to_sym
+    end
+
+    # return field [size, content] or false
+    def initial_parse(binstr)
+      return false unless binstr
+
+      if binstr[0, 2] != self.class.const_get(:HEADER_ID)
+        warn 'WARNING: weird extra field header ID. Skip parsing it.'
+        return false
+      end
+
+      [binstr[2, 2].unpack1('v'), binstr[4..]]
+    end
+
+    # Default strategy is to suppress all extra fields if we're asked to.
+    # Specific extra field types can override this if they need to be kept.
+    def suppress?
+      true
+    end
+
+    def to_local_bin
+      s = pack_for_local
+      (self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v')) << s
+    end
+
+    def to_c_dir_bin
+      s = pack_for_c_dir
+      (self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v')) << s
+    end
+  end
+end

data/lib/ziperu/extra_field/ntfs.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # PKWARE NTFS Extra Field (0x000a)
+  # Only Tag 0x0001 is supported
+  class ExtraField::NTFS < ExtraField::Generic # :nodoc:
+    HEADER_ID = [0x000A].pack('v')
+    register_map
+
+    WINDOWS_TICK = 10_000_000.0
+    SEC_TO_UNIX_EPOCH = 11_644_473_600
+
+    def initialize(binstr = nil)
+      @ctime = nil
+      @mtime = nil
+      @atime = nil
+      binstr && merge(binstr)
+    end
+
+    attr_accessor :atime, :ctime, :mtime
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      (size && content) || return
+
+      content = content[4..]
+      tags = parse_tags(content)
+
+      tag1 = tags[1]
+      return unless tag1
+
+      ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack('Q<Q<Q<')
+      ntfs_mtime && @mtime ||= from_ntfs_time(ntfs_mtime)
+      ntfs_atime && @atime ||= from_ntfs_time(ntfs_atime)
+      ntfs_ctime && @ctime ||= from_ntfs_time(ntfs_ctime)
+    end
+
+    def ==(other)
+      @mtime == other.mtime &&
+        @atime == other.atime &&
+        @ctime == other.ctime
+    end
+
+    # Info-ZIP note states this extra field is stored at local header
+    def pack_for_local
+      pack_for_c_dir
+    end
+
+    # But 7-zip for Windows only stores at central dir
+    def pack_for_c_dir
+      # reserved 0 and tag 1
+      s = [0, 1].pack('Vv')
+
+      tag1 = (+'').force_encoding(Encoding::BINARY)
+      if @mtime
+        tag1 << [to_ntfs_time(@mtime)].pack('Q<')
+        if @atime
+          tag1 << [to_ntfs_time(@atime)].pack('Q<')
+          tag1 << [to_ntfs_time(@ctime)].pack('Q<') if @ctime
+        end
+      end
+      s << [tag1.bytesize].pack('v') << tag1
+      s
+    end
+
+    private
+
+    def parse_tags(content)
+      return {} if content.nil?
+
+      tags = {}
+      i = 0
+      while i < content.bytesize
+        tag, size = content[i, 4].unpack('vv')
+        i += 4
+        break unless tag && size
+
+        value = content[i, size]
+        i += size
+        tags[tag] = value
+      end
+
+      tags
+    end
+
+    def from_ntfs_time(ntfs_time)
+      ::Ziperu::DOSTime.at((ntfs_time / WINDOWS_TICK) - SEC_TO_UNIX_EPOCH)
+    end
+
+    def to_ntfs_time(time)
+      ((time.to_f + SEC_TO_UNIX_EPOCH) * WINDOWS_TICK).to_i
+    end
+  end
+end

data/lib/ziperu/extra_field/old_unix.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # Olf Info-ZIP Extra for UNIX uid/gid and file timestampes
+  class ExtraField::OldUnix < ExtraField::Generic # :nodoc:
+    HEADER_ID = 'UX'
+    register_map
+
+    def initialize(binstr = nil)
+      @uid = nil
+      @gid = nil
+      @atime = nil
+      @mtime = nil
+      binstr && merge(binstr)
+    end
+
+    attr_accessor :uid, :gid, :atime, :mtime
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      # size: 0 for central directory. 4 for local header
+      return if !size || size == 0
+
+      atime, mtime, uid, gid = content.unpack('VVvv')
+      @uid ||= uid
+      @gid ||= gid
+      @atime ||= atime
+      @mtime ||= mtime # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    def ==(other)
+      @uid == other.uid &&
+        @gid == other.gid &&
+        @atime == other.atime &&
+        @mtime == other.mtime
+    end
+
+    # Fields are nil when only the central directory's (empty) form was
+    # seen; they pack as zero rather than failing.
+    def pack_for_local
+      [@atime, @mtime, @uid, @gid].map(&:to_i).pack('VVvv')
+    end
+
+    def pack_for_c_dir
+      [@atime, @mtime].map(&:to_i).pack('VV')
+    end
+  end
+end

data/lib/ziperu/extra_field/universal_time.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # Info-ZIP Additional timestamp field
+  class ExtraField::UniversalTime < ExtraField::Generic # :nodoc:
+    HEADER_ID = 'UT'
+    register_map
+
+    ATIME_MASK = 0b010
+    CTIME_MASK = 0b100
+    MTIME_MASK = 0b001
+
+    def initialize(binstr = nil)
+      @ctime = nil
+      @mtime = nil
+      @atime = nil
+      @flag  = 0
+
+      merge(binstr) unless binstr.nil?
+    end
+
+    attr_reader :atime, :ctime, :mtime, :flag
+
+    def atime=(time)
+      @flag = time.nil? ? @flag & ~ATIME_MASK : @flag | ATIME_MASK
+      @atime = time
+    end
+
+    def ctime=(time)
+      @flag = time.nil? ? @flag & ~CTIME_MASK : @flag | CTIME_MASK
+      @ctime = time
+    end
+
+    def mtime=(time)
+      @flag = time.nil? ? @flag & ~MTIME_MASK : @flag | MTIME_MASK
+      @mtime = time
+    end
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      return if !size || size <= 0
+
+      @flag, *times = content.unpack('Cl<l<l<')
+
+      # Parse the timestamps, in order, based on which flags are set.
+      return if times[0].nil?
+
+      @mtime ||= ::Ziperu::DOSTime.at(times.shift) unless @flag & MTIME_MASK == 0
+      return if times[0].nil?
+
+      @atime ||= ::Ziperu::DOSTime.at(times.shift) unless @flag & ATIME_MASK == 0
+      return if times[0].nil?
+
+      @ctime ||= ::Ziperu::DOSTime.at(times.shift) unless @flag & CTIME_MASK == 0
+    end
+
+    def ==(other)
+      @mtime == other.mtime &&
+        @atime == other.atime &&
+        @ctime == other.ctime
+    end
+
+    def pack_for_local
+      s = [@flag].pack('C')
+      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
+      s << [@atime.to_i].pack('l<') unless @flag & ATIME_MASK == 0
+      s << [@ctime.to_i].pack('l<') unless @flag & CTIME_MASK == 0
+      s
+    end
+
+    def pack_for_c_dir
+      s = [@flag].pack('C')
+      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
+      s
+    end
+  end
+end

data/lib/ziperu/extra_field/unix.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # Info-ZIP Extra for UNIX uid/gid
+  class ExtraField::IUnix < ExtraField::Generic # :nodoc:
+    HEADER_ID = 'Ux'
+    register_map
+
+    def initialize(binstr = nil)
+      @uid = nil
+      @gid = nil
+      binstr && merge(binstr)
+    end
+
+    attr_accessor :uid, :gid
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      # size: 0 for central directory. 4 for local header
+      return if !size || size == 0
+
+      uid, gid = content.unpack('vv')
+      @uid = uid
+      @gid = gid
+    end
+
+    def ==(other)
+      @uid == other.uid && @gid == other.gid
+    end
+
+    # Nil when only the central directory's (empty) form was seen; packed
+    # as zero rather than failing.
+    def pack_for_local
+      [@uid, @gid].map(&:to_i).pack('vv')
+    end
+
+    def pack_for_c_dir
+      ''
+    end
+  end
+end

data/lib/ziperu/extra_field/unknown.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+require_relative 'generic'
+
+module Ziperu
+  # A class to hold unknown extra fields so that they are preserved.
+  class ExtraField::Unknown < ExtraField::Generic # :nodoc:
+    def initialize
+      @local_bin = +''
+      @cdir_bin = +''
+    end
+
+    def merge(binstr, local: false)
+      return if binstr.empty?
+
+      if local
+        @local_bin << binstr
+      else
+        @cdir_bin << binstr
+      end
+    end
+
+    def to_local_bin
+      @local_bin
+    end
+
+    def to_c_dir_bin
+      @cdir_bin
+    end
+
+    def ==(other)
+      @local_bin == other.to_local_bin && @cdir_bin == other.to_c_dir_bin
+    end
+  end
+end