ziperu 0.1.1-aarch64-linux-musl

data/lib/zip/null_decompressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/null_decompressor"

data/lib/zip/null_input_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/null_input_stream"

data/lib/zip/output_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/output_stream"

data/lib/zip/pass_thru_compressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/pass_thru_compressor"

data/lib/zip/pass_thru_decompressor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/pass_thru_decompressor"

data/lib/zip/streamable_directory.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/streamable_directory"

data/lib/zip/streamable_stream.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/streamable_stream"

data/lib/zip/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubyzip path kept for code that requires this file directly.
+require "zip"
+require "ziperu/version"

data/lib/zip.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# rubyzip's entry point. Loading ziperu this way makes `Zip` an alias of
+# `Ziperu`, so code written against rubyzip (`Zip::File`, `Zip.setup`, ...)
+# runs unchanged. If another library already defines `Zip` (rubyzip itself,
+# most likely), the two cannot share the name: load ziperu with
+# `require "ziperu"` and use `Ziperu::` directly instead.
+if defined?(::Zip) && !(defined?(::Ziperu) && ::Zip.equal?(::Ziperu))
+  raise LoadError, "ziperu cannot alias Zip = Ziperu: a Zip constant is already defined " \
+                   "(by #{Object.const_source_location(:Zip)&.first || 'another library'}). " \
+                   "Remove rubyzip, or require \"ziperu\" and use Ziperu:: instead."
+end
+
+require "ziperu"
+Zip = Ziperu unless defined?(::Zip)
+
+# The `zip/...` paths rubyzip's files live at (`require "zip/filesystem"`
+# is the common one) are kept under lib/zip/ as one-line shims onto the
+# matching lib/ziperu/ file.

data/lib/ziperu/central_directory.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# The end-of-central-directory parsing is ported from rubyzip
+# (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # Reads just the end-of-central-directory records of an archive, in Ruby.
+  #
+  # The native core refuses archives whose EOCD declares more entries than
+  # the central directory holds, so `Ziperu::File.open` raises on them
+  # where rubyzip warns (or raises `EntryNumberMismatchError` when
+  # `Ziperu.validate_declared_number_of_entries` is set). This gives
+  # `Ziperu::File.count_entries` rubyzip's behaviour at least.
+  class CentralDirectory # :nodoc:all
+    END_OF_CD_SIG          = 0x06054b50
+    ZIP64_END_OF_CD_SIG    = 0x06064b50
+    ZIP64_EOCD_LOCATOR_SIG = 0x07064b50
+
+    STATIC_EOCD_SIZE       = 22
+    ZIP64_STATIC_EOCD_SIZE = 56
+    ZIP64_EOCD_LOC_SIZE    = 20
+    MAX_FILE_COMMENT_SIZE  = (1 << 16) - 1
+    MAX_END_OF_CD_SIZE     =
+      MAX_FILE_COMMENT_SIZE + STATIC_EOCD_SIZE + ZIP64_EOCD_LOC_SIZE
+
+    attr_reader :size, :cdir_offset, :comment
+
+    # Number of entries declared by the EOCD of `path_or_io`.
+    def self.count_entries(path_or_io)
+      if path_or_io.respond_to?(:read)
+        new.count_entries(path_or_io)
+      else
+        ::File.open(path_or_io.to_s, 'rb') { |io| new.count_entries(io) }
+      end
+    end
+
+    def count_entries(io)
+      read_eocds(io)
+      @size
+    end
+
+    private
+
+    def unpack_64_e_o_c_d(buffer)
+      _, # ZIP64_END_OF_CD_SIG. We know we have this at this point.
+      _size_of_zip64_e_o_c_d,
+      _version_made_by,
+      _version_needed_for_extract,
+      _number_of_this_disk,
+      _number_of_disk_with_start_of_cdir,
+      _total_number_of_entries_in_cdir_on_this_disk,
+      @size,
+      size_in_bytes,
+      @cdir_offset = buffer.unpack('VQ<vvVVQ<Q<Q<Q<')
+
+      validate_size!(@size, size_in_bytes)
+    end
+
+    def unpack_64_eocd_locator(buffer)
+      _, _, zip64_eocd_offset, = buffer.unpack('VVQ<V')
+      zip64_eocd_offset
+    end
+
+    # Returns true when the plain EOCD was complete (no zip64 needed).
+    def unpack_e_o_c_d(buffer)
+      _, # END_OF_CD_SIG. We know we have this at this point.
+      number_of_this_disk,
+      number_of_disk_with_start_of_cdir,
+      total_number_of_entries_in_cdir_on_this_disk,
+      @size,
+      size_in_bytes,
+      @cdir_offset,
+      comment_length = buffer.unpack('VvvvvVVv')
+
+      complete = !([number_of_this_disk, number_of_disk_with_start_of_cdir,
+                    total_number_of_entries_in_cdir_on_this_disk, @size].any?(0xFFFF) ||
+                    size_in_bytes == 0xFFFFFFFF || @cdir_offset == 0xFFFFFFFF)
+
+      validate_size!(@size, size_in_bytes) if complete
+
+      @comment = comment_length.positive? ? buffer.slice(STATIC_EOCD_SIZE, comment_length) : ''
+      complete
+    end
+
+    def read_eocds(io)
+      base_location, data = eocd_data(io)
+
+      eocd_location = data.rindex([END_OF_CD_SIG].pack('V'))
+      raise Error, 'Zip end of central directory signature not found' unless eocd_location
+
+      return if unpack_e_o_c_d(data.slice(eocd_location..-1))
+
+      zip64_eocd_locator = data.rindex([ZIP64_EOCD_LOCATOR_SIG].pack('V'), eocd_location)
+      unless zip64_eocd_locator
+        raise Error, 'Zip64 end of central directory locator signature expected but not found'
+      end
+
+      zip64_eocd_location = data.rindex([ZIP64_END_OF_CD_SIG].pack('V'), zip64_eocd_locator)
+
+      zip64_eocd_data =
+        if zip64_eocd_location
+          data.slice(zip64_eocd_location..zip64_eocd_locator)
+        else
+          zip64_eocd_location = unpack_64_eocd_locator(
+            data.slice(zip64_eocd_locator..eocd_location)
+          )
+          raise Error, 'Zip64 end of central directory signature not found' unless zip64_eocd_location
+
+          io.seek(zip64_eocd_location, IO::SEEK_SET)
+          io.read(base_location + zip64_eocd_locator - zip64_eocd_location)
+        end
+
+      unpack_64_e_o_c_d(zip64_eocd_data)
+    end
+
+    def eocd_data(io)
+      io.binmode if io.respond_to?(:binmode)
+      begin
+        io.seek(-MAX_END_OF_CD_SIZE, IO::SEEK_END)
+      rescue Errno::EINVAL
+        io.seek(0, IO::SEEK_SET)
+      end
+
+      [io.tell, io.read.to_s.b]
+    end
+
+    def validate_size!(size, size_in_bytes)
+      return if size * CDIR_ENTRY_STATIC_HEADER_LENGTH <= size_in_bytes
+
+      error = EntryNumberMismatchError.new(size, size_in_bytes)
+      raise error if Ziperu.validate_declared_number_of_entries
+
+      warn error.message
+    end
+  end
+end

data/lib/ziperu/compressor.rb

@@ -0,0 +1,14 @@
+# 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 Compressor # :nodoc:all
+    def finish; 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/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