rubyzip 2.4.1 → 3.6.0

data/lib/zip/crypto/null_encryption.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  module NullEncryption
+  module NullEncryption # :nodoc:
     def header_bytesize
       0
     end
@@ -9,7 +11,7 @@ module Zip
     end
   end
 
-  class NullEncrypter < Encrypter
+  class NullEncrypter < Encrypter # :nodoc:
     include NullEncryption
 
     def header(_mtime)
@@ -20,22 +22,12 @@ module Zip
       data
     end
 
-    def data_descriptor(_crc32, _compressed_size, _uncomprssed_size)
+    def data_descriptor(_crc32, _compressed_size, _uncompressed_size)
       ''
     end
 
     def reset!; end
   end
-
-  class NullDecrypter < Decrypter
-    include NullEncryption
-
-    def decrypt(data)
-      data
-    end
-
-    def reset!(_header); end
-  end
 end
 
 # Copyright (C) 2002, 2003 Thomas Sondergaard

data/lib/zip/crypto/traditional_encryption.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
 module Zip
-  module TraditionalEncryption
+  module TraditionalEncryption # :nodoc:
     def initialize(password)
       @password = password
       reset_keys!
@@ -26,7 +30,7 @@ module Zip
 
     def update_keys(num)
       @key0 = ~Zlib.crc32(num, ~@key0)
-      @key1 = ((@key1 + (@key0 & 0xff)) * 134_775_813 + 1) & 0xffffffff
+      @key1 = (((@key1 + (@key0 & 0xff)) * 134_775_813) + 1) & 0xffffffff
       @key2 = ~Zlib.crc32((@key1 >> 24).chr, ~@key2)
     end
 
@@ -36,13 +40,13 @@ module Zip
     end
   end
 
-  class TraditionalEncrypter < Encrypter
+  class TraditionalEncrypter < Encrypter # :nodoc:
     include TraditionalEncryption
 
     def header(mtime)
       [].tap do |header|
         (header_bytesize - 2).times do
-          header << Random.rand(0..255)
+          header << SecureRandom.rand(0..255)
         end
         header << (mtime.to_binary_dos_time & 0xff)
         header << (mtime.to_binary_dos_time >> 8)
@@ -53,8 +57,8 @@ module Zip
       data.unpack('C*').map { |x| encode x }.pack('C*')
     end
 
-    def data_descriptor(crc32, compressed_size, uncomprssed_size)
-      [0x08074b50, crc32, compressed_size, uncomprssed_size].pack('VVVV')
+    def data_descriptor(crc32, compressed_size, uncompressed_size)
+      [0x08074b50, crc32, compressed_size, uncompressed_size].pack('VVVV')
     end
 
     def reset!
@@ -70,7 +74,7 @@ module Zip
     end
   end
 
-  class TraditionalDecrypter < Decrypter
+  class TraditionalDecrypter < Decrypter # :nodoc:
     include TraditionalEncryption
 
     def decrypt(data)
@@ -84,6 +88,8 @@ module Zip
       end
     end
 
+    def check_integrity!(_io); end
+
     private
 
     def decode(num)

data/lib/zip/decompressor.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class Decompressor #:nodoc:all
+  class Decompressor # :nodoc:all
     CHUNK_SIZE = 32_768
 
     def self.decompressor_classes
@@ -14,8 +16,7 @@ module Zip
       decompressor_classes[compression_method]
     end
 
-    attr_reader :input_stream
-    attr_reader :decompressed_size
+    attr_reader :decompressed_size, :input_stream
 
     def initialize(input_stream, decompressed_size = nil)
       super()

data/lib/zip/deflater.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class Deflater < Compressor #:nodoc:all
+  class Deflater < Compressor # :nodoc:all
     def initialize(output_stream, level = Zip.default_compression, encrypter = NullEncrypter.new)
       super()
       @output_stream = output_stream
@@ -13,16 +15,18 @@ module Zip
       val   = data.to_s
       @crc  = Zlib.crc32(val, @crc)
       @size += val.bytesize
-      buffer = @zlib_deflater.deflate(data)
-      if buffer.empty?
-        @output_stream
-      else
-        @output_stream << @encrypter.encrypt(buffer)
-      end
+
+      # When JRuby#3962 is fixed, we can remove the flushing parameter here.
+      buffer = @zlib_deflater.deflate(data, Zip::ZLIB_FLUSHING_STRATEGY)
+      return @output_stream if buffer.empty?
+
+      @output_stream << @encrypter.encrypt(buffer)
     end
 
     def finish
-      @output_stream << @encrypter.encrypt(@zlib_deflater.finish) until @zlib_deflater.finished?
+      buffer = @zlib_deflater.finish
+      @output_stream << @encrypter.encrypt(buffer) unless buffer.empty?
+      @zlib_deflater.close
     end
 
     attr_reader :size, :crc

data/lib/zip/dirtyable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Zip
+  module Dirtyable # :nodoc:all
+    def initialize(dirty_on_create: true)
+      @dirty = dirty_on_create
+    end
+
+    def dirty?
+      @dirty
+    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|
+            @dirty = true
+            send(orig_name, param)
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/zip/dos_time.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+
 module Zip
-  class DOSTime < Time #:nodoc:all
+  class DOSTime < Time # :nodoc:all
     # MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
 
     # Register CX, the Time:
@@ -12,21 +16,47 @@ module Zip
     # 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:
+
+    def absolute_time?
+      # If absolute time is not set, we can assume it is an absolute time
+      # because times do have timezone information by default.
+      @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 - 1980) << 9)
+        ((year - DOS_EPOCH_YEAR) << 9)
     end
 
-    def dos_equals(other)
-      Zip.warn_about_v3_api('DOSTime#dos_equals')
-
+    # Deprecated. Remove for version 4.
+    def dos_equals(other) # rubocop:disable Naming/PredicateMethod
+      warn 'Zip::DOSTime#dos_equals is deprecated. Use `==` instead.'
       self == other
     end
 
@@ -50,7 +80,35 @@ module Zip
       month  = (0b111100000 & bin_dos_date) >> 5
       year   = ((0b1111111000000000 & bin_dos_date) >> 9) + 1980
 
-      local(year, month, day, hour, minute, second)
+      time = local(year, month, day, hour, minute, second)
+      time.absolute_time = false
+      time
+    end
+
+    if defined? JRUBY_VERSION && Gem::Version.new(JRUBY_VERSION) < '9.2.18.0'
+      module JRubyCMP # :nodoc:
+        def ==(other)
+          (self <=> other).zero?
+        end
+
+        def <(other)
+          (self <=> other).negative?
+        end
+
+        def <=(other)
+          (self <=> other) <= 0
+        end
+
+        def >(other)
+          (self <=> other).positive?
+        end
+
+        def >=(other)
+          (self <=> other) >= 0
+        end
+      end
+
+      include JRubyCMP
     end
   end
 end