rubyzip 1.3.0 → 3.0.0.alpha

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,16 @@ 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
+      buffer = @zlib_deflater.deflate(data, Zlib::SYNC_FLUSH)
+      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:
@@ -24,21 +28,58 @@ module Zip
         ((year - 1980) << 9)
     end
 
-    # Dos time is only stored with two seconds accuracy
     def dos_equals(other)
-      to_i / 2 == other.to_i / 2
+      warn 'Zip::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
 
-    def self.parse_binary_dos_format(binaryDosDate, binaryDosTime)
-      second = 2 * (0b11111 & binaryDosTime)
-      minute = (0b11111100000 & binaryDosTime) >> 5
-      hour   = (0b1111100000000000 & binaryDosTime) >> 11
-      day    = (0b11111 & binaryDosDate)
-      month  = (0b111100000 & binaryDosDate) >> 5
-      year   = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980
-      begin
-        local(year, month, day, hour, minute, second)
+    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
+
+      local(year, month, day, hour, minute, second)
+    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