ziperu 0.1.1

data/lib/ziperu/constants.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# rubyzip's constants, verbatim, plus the newer compression methods the Rust
+# core can read.
+module Ziperu
+  # :stopdoc:
+
+  RUNNING_ON_WINDOWS = RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
+
+  CENTRAL_DIRECTORY_ENTRY_SIGNATURE = 0x02014b50
+  CDIR_ENTRY_STATIC_HEADER_LENGTH   = 46
+
+  LOCAL_ENTRY_SIGNATURE                  = 0x04034b50
+  LOCAL_ENTRY_STATIC_HEADER_LENGTH       = 30
+  LOCAL_ENTRY_TRAILING_DESCRIPTOR_LENGTH = 4 + 4 + 4
+  VERSION_MADE_BY                        = 52
+  VERSION_NEEDED_TO_EXTRACT              = 20
+  VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
+  VERSION_NEEDED_TO_EXTRACT_AES          = 51
+
+  SPLIT_FILE_SIGNATURE = 0x08074b50
+
+  FILE_TYPE_FILE    = 0o10
+  FILE_TYPE_DIR     = 0o04
+  FILE_TYPE_SYMLINK = 0o12
+
+  FSTYPE_FAT      = 0
+  FSTYPE_AMIGA    = 1
+  FSTYPE_VMS      = 2
+  FSTYPE_UNIX     = 3
+  FSTYPE_VM_CMS   = 4
+  FSTYPE_ATARI    = 5
+  FSTYPE_HPFS     = 6
+  FSTYPE_MAC      = 7
+  FSTYPE_Z_SYSTEM = 8
+  FSTYPE_CPM      = 9
+  FSTYPE_TOPS20   = 10
+  FSTYPE_NTFS     = 11
+  FSTYPE_QDOS     = 12
+  FSTYPE_ACORN    = 13
+  FSTYPE_VFAT     = 14
+  FSTYPE_MVS      = 15
+  FSTYPE_BEOS     = 16
+  FSTYPE_TANDEM   = 17
+  FSTYPE_THEOS    = 18
+  FSTYPE_MAC_OSX  = 19
+  FSTYPE_ATHEOS   = 30
+
+  FSTYPES = {
+    FSTYPE_FAT      => 'FAT',
+    FSTYPE_AMIGA    => 'Amiga',
+    FSTYPE_VMS      => 'VMS (Vax or Alpha AXP)',
+    FSTYPE_UNIX     => 'Unix',
+    FSTYPE_VM_CMS   => 'VM/CMS',
+    FSTYPE_ATARI    => 'Atari ST',
+    FSTYPE_HPFS     => 'OS/2 or NT HPFS',
+    FSTYPE_MAC      => 'Macintosh',
+    FSTYPE_Z_SYSTEM => 'Z-System',
+    FSTYPE_CPM      => 'CP/M',
+    FSTYPE_TOPS20   => 'TOPS-20',
+    FSTYPE_NTFS     => 'NTFS',
+    FSTYPE_QDOS     => 'SMS/QDOS',
+    FSTYPE_ACORN    => 'Acorn RISC OS',
+    FSTYPE_VFAT     => 'Win32 VFAT',
+    FSTYPE_MVS      => 'MVS',
+    FSTYPE_BEOS     => 'BeOS',
+    FSTYPE_TANDEM   => 'Tandem NSK',
+    FSTYPE_THEOS    => 'Theos',
+    FSTYPE_MAC_OSX  => 'Mac OS/X (Darwin)',
+    FSTYPE_ATHEOS   => 'AtheOS'
+  }.freeze
+
+  COMPRESSION_METHOD_STORE = 0
+  COMPRESSION_METHOD_SHRINK = 1
+  COMPRESSION_METHOD_REDUCE_1 = 2
+  COMPRESSION_METHOD_REDUCE_2 = 3
+  COMPRESSION_METHOD_REDUCE_3 = 4
+  COMPRESSION_METHOD_REDUCE_4 = 5
+  COMPRESSION_METHOD_IMPLODE = 6
+  COMPRESSION_METHOD_DEFLATE = 8
+  COMPRESSION_METHOD_DEFLATE_64 = 9
+  COMPRESSION_METHOD_DEFLATE64 = COMPRESSION_METHOD_DEFLATE_64
+  COMPRESSION_METHOD_PKWARE_DCLI = 10
+  COMPRESSION_METHOD_BZIP2 = 12
+  COMPRESSION_METHOD_LZMA = 14
+  COMPRESSION_METHOD_IBM_CMPSC = 16
+  COMPRESSION_METHOD_IBM_TERSE = 18
+  COMPRESSION_METHOD_IBM_LZ77 = 19
+  COMPRESSION_METHOD_ZSTD = 93
+  COMPRESSION_METHOD_XZ = 95
+  COMPRESSION_METHOD_JPEG = 96
+  COMPRESSION_METHOD_WAVPACK = 97
+  COMPRESSION_METHOD_PPMD = 98
+  COMPRESSION_METHOD_AES = 99
+
+  COMPRESSION_METHODS = {
+    COMPRESSION_METHOD_STORE       => 'Store (no compression)',
+    COMPRESSION_METHOD_SHRINK      => 'Shrink',
+    COMPRESSION_METHOD_REDUCE_1    => 'Reduce with compression factor 1',
+    COMPRESSION_METHOD_REDUCE_2    => 'Reduce with compression factor 2',
+    COMPRESSION_METHOD_REDUCE_3    => 'Reduce with compression factor 3',
+    COMPRESSION_METHOD_REDUCE_4    => 'Reduce with compression factor 4',
+    COMPRESSION_METHOD_IMPLODE     => 'Implode',
+    COMPRESSION_METHOD_DEFLATE     => 'Deflate',
+    COMPRESSION_METHOD_DEFLATE_64  => 'Deflate64(tm)',
+    COMPRESSION_METHOD_PKWARE_DCLI => 'PKWARE Data Compression Library Imploding (old IBM TERSE)',
+    COMPRESSION_METHOD_BZIP2       => 'BZIP2',
+    COMPRESSION_METHOD_LZMA        => 'LZMA',
+    COMPRESSION_METHOD_IBM_CMPSC   => 'IBM z/OS CMPSC Compression',
+    COMPRESSION_METHOD_IBM_TERSE   => 'IBM TERSE (new)',
+    COMPRESSION_METHOD_IBM_LZ77    => 'IBM LZ77 z Architecture (PFS)',
+    COMPRESSION_METHOD_ZSTD        => 'Zstandard',
+    COMPRESSION_METHOD_XZ          => 'XZ',
+    COMPRESSION_METHOD_JPEG        => 'JPEG variant',
+    COMPRESSION_METHOD_WAVPACK     => 'WavPack compressed data',
+    COMPRESSION_METHOD_PPMD        => 'PPMd version I, Rev 1',
+    COMPRESSION_METHOD_AES         => 'AES encryption'
+  }.freeze
+
+  # Methods the Rust core can decompress.
+  READABLE_COMPRESSION_METHODS = [
+    COMPRESSION_METHOD_STORE,
+    COMPRESSION_METHOD_SHRINK,
+    COMPRESSION_METHOD_REDUCE_1,
+    COMPRESSION_METHOD_REDUCE_2,
+    COMPRESSION_METHOD_REDUCE_3,
+    COMPRESSION_METHOD_REDUCE_4,
+    COMPRESSION_METHOD_IMPLODE,
+    COMPRESSION_METHOD_DEFLATE,
+    COMPRESSION_METHOD_DEFLATE_64,
+    COMPRESSION_METHOD_BZIP2,
+    COMPRESSION_METHOD_LZMA,
+    COMPRESSION_METHOD_ZSTD,
+    COMPRESSION_METHOD_XZ,
+    COMPRESSION_METHOD_PPMD,
+    COMPRESSION_METHOD_AES
+  ].freeze
+
+  # Methods the Rust core can compress with.
+  WRITABLE_COMPRESSION_METHODS = [
+    COMPRESSION_METHOD_STORE,
+    COMPRESSION_METHOD_DEFLATE,
+    COMPRESSION_METHOD_BZIP2,
+    COMPRESSION_METHOD_ZSTD
+  ].freeze
+
+  # :startdoc:
+end

data/lib/ziperu/crypto.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Ziperu
+  # The encrypter/decrypter objects rubyzip's API passes around
+  # (`encrypter:` / `decrypter:` keywords). The Rust core does the actual
+  # ZipCrypto/AES work, so these are typed password holders.
+  class Decrypter # :nodoc:
+    attr_reader :password
+
+    def initialize(password)
+      @password = password.to_s
+    end
+  end
+
+  class TraditionalDecrypter < Decrypter; end
+
+  class AESDecrypter < Decrypter
+    def initialize(password, _strength = nil)
+      super(password)
+    end
+  end
+
+  module AESEncryption # :nodoc:
+    STRENGTH_128_BIT = 0x01
+    STRENGTH_192_BIT = 0x02
+    STRENGTH_256_BIT = 0x03
+  end
+
+  class Encrypter # :nodoc:
+    attr_reader :password
+
+    def initialize(password)
+      @password = password.to_s
+    end
+
+    # Options for the native writer.
+    def native_options # :nodoc:
+      {}
+    end
+  end
+
+  class NullEncrypter < Encrypter
+    def initialize
+      super(nil)
+    end
+  end
+
+  # ZipCrypto, the weak legacy cipher that Windows Explorer and other
+  # AES-less tools can open. Entries are written with general purpose bits
+  # 0 and 3 set, as rubyzip writes them; only Stored and Deflate entries
+  # can be encrypted this way.
+  class TraditionalEncrypter < Encrypter
+    def native_options # :nodoc:
+      { password: @password.b, zipcrypto: true }
+    end
+  end
+
+  class AESEncrypter < Encrypter
+    include AESEncryption
+
+    attr_reader :strength
+
+    def initialize(password, strength = STRENGTH_256_BIT)
+      super(password)
+      @strength = strength
+    end
+
+    def native_options # :nodoc:
+      { password: @password.b, aes_mode: @strength }
+    end
+  end
+end

data/lib/ziperu/decompressor.rb

@@ -0,0 +1,35 @@
+# 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 Decompressor # :nodoc:all
+    CHUNK_SIZE = 32_768
+
+    def self.decompressor_classes
+      @decompressor_classes ||= {}
+    end
+
+    def self.register(compression_method, decompressor_class)
+      decompressor_classes[compression_method] = decompressor_class
+    end
+
+    def self.find_by_compression_method(compression_method)
+      decompressor_classes[compression_method]
+    end
+
+    attr_reader :decompressed_size, :input_stream
+
+    def initialize(input_stream, decompressed_size = nil)
+      super()
+
+      @input_stream = input_stream
+      @decompressed_size = decompressed_size
+    end
+  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/deflater.rb

@@ -0,0 +1,41 @@
+# 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 Deflater < Compressor # :nodoc:all
+    def initialize(output_stream, level = Ziperu.default_compression, encrypter = NullEncrypter.new)
+      super()
+      @output_stream = output_stream
+      @zlib_deflater = ::Zlib::Deflate.new(level, -::Zlib::MAX_WBITS)
+      @size          = 0
+      @crc           = ::Zlib.crc32
+      @encrypter     = encrypter
+    end
+
+    def <<(data)
+      val   = data.to_s
+      @crc  = Zlib.crc32(val, @crc)
+      @size += val.bytesize
+
+      # When JRuby#3962 is fixed, we can remove the flushing parameter here.
+      buffer = @zlib_deflater.deflate(data, Ziperu::ZLIB_FLUSHING_STRATEGY)
+      return @output_stream if buffer.empty?
+
+      @output_stream << @encrypter.encrypt(buffer)
+    end
+
+    def finish
+      buffer = @zlib_deflater.finish
+      @output_stream << @encrypter.encrypt(buffer) unless buffer.empty?
+      @zlib_deflater.close
+    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/dirtyable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Ported from rubyzip (Copyright (C) 2002-2026 the rubyzip authors), with
+# the setters that dirtied the object recorded as well as the flag: an
+# entry whose only change the native raw copy can carry (a rename, or a
+# chmod) need not be recompressed on commit.
+
+module Ziperu
+  module Dirtyable # :nodoc:all
+    def initialize(dirty_on_create: true)
+      @dirty = dirty_on_create
+      @dirty_fields = []
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    # The setters called since the object was last clean, as symbols.
+    def dirty_fields
+      @dirty_fields ||= []
+    end
+
+    def mark_dirty!(field)
+      @dirty = true
+      dirty_fields << field unless dirty_fields.include?(field)
+    end
+
+    module ClassMethods # :nodoc:
+      def mark_dirty(*symbols) # :nodoc:
+        # Move the original method and call it after we've set the dirty flag.
+        symbols.each do |symbol|
+          orig_name = "orig_#{symbol}"
+          alias_method orig_name, symbol
+
+          define_method(symbol) do |param|
+            mark_dirty!(symbol)
+            send(orig_name, param)
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/ziperu/dos_time.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Ported from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # A Time that knows how to round-trip the MS-DOS date/time packed into a
+  # zip header. Mirrors rubyzip's class so `entry.time` behaves identically.
+  class DOSTime < Time # :nodoc:all
+    # MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
+    #
+    # Register CX, the Time:
+    # Bits 0-4  2 second increments (0-29)
+    # Bits 5-10 minutes (0-59)
+    # bits 11-15 hours (0-24)
+    #
+    # Register DX, the Date:
+    # Bits 0-4 day (1-31)
+    # bits 5-8 month (1-12)
+    # bits 9-15 year (four digit year minus 1980)
+
+    # The MS-DOS date field is seven bits of "year minus 1980", so only
+    # 1980-01-01 00:00:00 through 2107-12-31 23:59:58 can be represented.
+    # Times outside that are clamped rather than allowed to wrap: the real
+    # time is still carried in the universal time (UT) extra field, but the
+    # DOS fields have to stay in range for readers that only look at those.
+    DOS_EPOCH_YEAR = 1980
+    DOS_MAX_YEAR = 2107
+    DOS_MIN_DATE = 0x0021 # 1980-01-01
+    DOS_MAX_DATE = 0xff9f # 2107-12-31
+    DOS_MIN_TIME = 0x0000 # 00:00:00
+    DOS_MAX_TIME = 0xbf7d # 23:59:58
+
+    attr_writer :absolute_time # :nodoc:
+
+    # Times built from a DOS field carry no timezone; everything else does.
+    def absolute_time?
+      @absolute_time.nil? || @absolute_time
+    end
+
+    def to_binary_dos_time
+      return DOS_MIN_TIME if year < DOS_EPOCH_YEAR
+      return DOS_MAX_TIME if year > DOS_MAX_YEAR
+
+      (sec / 2) + (min << 5) + (hour << 11)
+    end
+
+    def to_binary_dos_date
+      return DOS_MIN_DATE if year < DOS_EPOCH_YEAR
+      return DOS_MAX_DATE if year > DOS_MAX_YEAR
+
+      day + (month << 5) + ((year - DOS_EPOCH_YEAR) << 9)
+    end
+
+    # Deprecated. Remove for version 4.
+    def dos_equals(other)
+      warn 'Ziperu::DOSTime#dos_equals is deprecated. Use `==` instead.'
+      self == other
+    end
+
+    # DOS time is only stored with two seconds accuracy.
+    def <=>(other)
+      return unless other.kind_of?(Time)
+
+      (to_i / 2) <=> (other.to_i / 2)
+    end
+
+    # Create a DOSTime instance from a vanilla Time instance.
+    def self.from_time(time)
+      local(time.year, time.month, time.day, time.hour, time.min, time.sec)
+    end
+
+    # Raises ArgumentError for fields that don't make a valid date, like
+    # rubyzip; callers decide whether to warn.
+    def self.parse_binary_dos_format(bin_dos_date, bin_dos_time)
+      second = 2 * (0b11111 & bin_dos_time)
+      minute = (0b11111100000 & bin_dos_time) >> 5
+      hour   = (0b1111100000000000 & bin_dos_time) >> 11
+      day    = (0b11111 & bin_dos_date)
+      month  = (0b111100000 & bin_dos_date) >> 5
+      year   = ((0b1111111000000000 & bin_dos_date) >> 9) + 1980
+
+      time = local(year, month, day, hour, minute, second)
+      time.absolute_time = false
+      time
+    end
+  end
+end