rubyzip 1.0.0 → 1.2.0

data/lib/zip/filesystem.rb

@@ -1,41 +1,39 @@
 require 'zip'
 
 module Zip
-
-  # The ZipFileSystem API provides an API for accessing entries in 
-  # a zip archive that is similar to ruby's builtin File and Dir 
+  # The ZipFileSystem API provides an API for accessing entries in
+  # a zip archive that is similar to ruby's builtin File and Dir
   # classes.
   #
-  # Requiring 'zip/zipfilesystem' includes this module in ZipFile
-  # making the methods in this module available on ZipFile objects.
+  # Requiring 'zip/filesystem' includes this module in Zip::File
+  # making the methods in this module available on Zip::File objects.
   #
-  # Using this API the following example creates a new zip file 
+  # Using this API the following example creates a new zip file
   # <code>my.zip</code> containing a normal entry with the name
   # <code>first.txt</code>, a directory entry named <code>mydir</code>
   # and finally another normal entry named <code>second.txt</code>
   #
   #   require 'zip/filesystem'
-  #   
-  #   Zip::File.open("my.zip", Zip::ZipFile::CREATE) {
+  #
+  #   Zip::File.open("my.zip", Zip::File::CREATE) {
   #     |zipfile|
   #     zipfile.file.open("first.txt", "w") { |f| f.puts "Hello world" }
   #     zipfile.dir.mkdir("mydir")
   #     zipfile.file.open("mydir/second.txt", "w") { |f| f.puts "Hello again" }
   #   }
   #
-  # Reading is as easy as writing, as the following example shows. The 
+  # Reading is as easy as writing, as the following example shows. The
   # example writes the contents of <code>first.txt</code> from zip archive
   # <code>my.zip</code> to standard out.
   #
   #   require 'zip/filesystem'
-  #   
+  #
   #   Zip::File.open("my.zip") {
   #     |zipfile|
   #     puts zipfile.file.read("first.txt")
   #   }
 
   module FileSystem
-
     def initialize # :nodoc:
       mappedZip = ZipFileNameMapper.new(self)
       @zipFsDir  = ZipFsDir.new(mappedZip)
@@ -45,44 +43,40 @@ module Zip
     end
 
     # Returns a ZipFsDir which is much like ruby's builtin Dir (class)
-    # object, except it works on the ZipFile on which this method is
+    # object, except it works on the Zip::File on which this method is
     # invoked
     def dir
       @zipFsDir
     end
 
     # Returns a ZipFsFile which is much like ruby's builtin File (class)
-    # object, except it works on the ZipFile on which this method is
+    # object, except it works on the Zip::File on which this method is
     # invoked
     def file
       @zipFsFile
     end
 
     # Instances of this class are normally accessed via the accessor
-    # ZipFile::file. An instance of ZipFsFile behaves like ruby's
-    # builtin File (class) object, except it works on ZipFile entries.
+    # Zip::File::file. An instance of ZipFsFile behaves like ruby's
+    # builtin File (class) object, except it works on Zip::File entries.
     #
     # The individual methods are not documented due to their
     # similarity with the methods in File
     class ZipFsFile
-
       attr_writer :dir
-#      protected :dir
+      # protected :dir
 
       class ZipFsStat
-
         class << self
-
           def delegate_to_fs_file(*methods)
             methods.each do |method|
-              self.class_eval <<-end_eval, __FILE__, __LINE__ + 1
+              class_eval <<-end_eval, __FILE__, __LINE__ + 1
                 def #{method}                      # def file?
                   @zipFsFile.#{method}(@entryName) #   @zipFsFile.file?(@entryName)
                 end                                # end
               end_eval
             end
           end
-
         end
 
         def initialize(zipFsFile, entryName)
@@ -91,15 +85,17 @@ module Zip
         end
 
         def kind_of?(t)
-          super || t == ::File::Stat 
+          super || t == ::File::Stat
         end
 
         delegate_to_fs_file :file?, :directory?, :pipe?, :chardev?, :symlink?,
-          :socket?, :blockdev?, :readable?, :readable_real?, :writable?, :ctime,
-          :writable_real?, :executable?, :executable_real?, :sticky?, :owned?,
-          :grpowned?, :setuid?, :setgid?, :zero?, :size, :size?, :mtime, :atime
+                            :socket?, :blockdev?, :readable?, :readable_real?, :writable?, :ctime,
+                            :writable_real?, :executable?, :executable_real?, :sticky?, :owned?,
+                            :grpowned?, :setuid?, :setgid?, :zero?, :size, :size?, :mtime, :atime
 
-        def blocks; nil; end
+        def blocks
+          nil
+        end
 
         def get_entry
           @zipFsFile.__send__(:get_entry, @entryName)
@@ -108,8 +104,8 @@ module Zip
 
         def gid
           e = get_entry
-          if e.extra.member? "IUnix"
-            e.extra["IUnix"].gid || 0
+          if e.extra.member? 'IUnix'
+            e.extra['IUnix'].gid || 0
           else
             0
           end
@@ -117,43 +113,57 @@ module Zip
 
         def uid
           e = get_entry
-          if e.extra.member? "IUnix"
-            e.extra["IUnix"].uid || 0
+          if e.extra.member? 'IUnix'
+            e.extra['IUnix'].uid || 0
           else
             0
           end
         end
 
-        def ino; 0; end
+        def ino
+          0
+        end
 
-        def dev; 0; end
+        def dev
+          0
+        end
 
-        def rdev; 0; end
+        def rdev
+          0
+        end
 
-        def rdev_major; 0; end
+        def rdev_major
+          0
+        end
 
-        def rdev_minor; 0; end
+        def rdev_minor
+          0
+        end
 
         def ftype
           if file?
-            return "file"
+            return 'file'
           elsif directory?
-            return "directory"
+            return 'directory'
           else
-            raise StandardError, "Unknown file type"
+            raise StandardError, 'Unknown file type'
           end
         end
 
-        def nlink; 1; end
+        def nlink
+          1
+        end
 
-        def blksize; nil; end
+        def blksize
+          nil
+        end
 
         def mode
           e = get_entry
           if e.fstype == 3
             e.external_file_attributes >> 16
           else
-            33206 # 33206 is equivalent to -rw-rw-rw-
+            33_206 # 33206 is equivalent to -rw-rw-rw-
           end
         end
       end
@@ -163,7 +173,7 @@ module Zip
       end
 
       def get_entry(fileName)
-        if ! exists?(fileName)
+        unless exists?(fileName)
           raise Errno::ENOENT, "No such file or directory - #{fileName}"
         end
         @mappedZip.find_entry(fileName)
@@ -171,33 +181,31 @@ module Zip
       private :get_entry
 
       def unix_mode_cmp(fileName, mode)
-        begin
-          e = get_entry(fileName)
-          e.fstype == 3 && ((e.external_file_attributes >> 16) & mode ) != 0
-        rescue Errno::ENOENT
-          false
-        end
+        e = get_entry(fileName)
+        e.fstype == 3 && ((e.external_file_attributes >> 16) & mode) != 0
+      rescue Errno::ENOENT
+        false
       end
       private :unix_mode_cmp
 
       def exists?(fileName)
-        expand_path(fileName) == "/" || @mappedZip.find_entry(fileName) != nil
+        expand_path(fileName) == '/' || !@mappedZip.find_entry(fileName).nil?
       end
-      alias :exist? :exists?
+      alias exist? exists?
 
       # Permissions not implemented, so if the file exists it is accessible
-      alias owned?           exists?
-      alias grpowned?        exists?
+      alias owned? exists?
+      alias grpowned? exists?
 
       def readable?(fileName)
         unix_mode_cmp(fileName, 0444)
       end
-      alias readable_real?   readable?
+      alias readable_real? readable?
 
       def writable?(fileName)
         unix_mode_cmp(fileName, 0222)
       end
-      alias writable_real?   writable?
+      alias writable_real? writable?
 
       def executable?(fileName)
         unix_mode_cmp(fileName, 0111)
@@ -220,28 +228,28 @@ module Zip
         ::File.umask(*args)
       end
 
-      def truncate(fileName, len)
-        raise StandardError, "truncate not supported"
+      def truncate(_fileName, _len)
+        raise StandardError, 'truncate not supported'
       end
 
       def directory?(fileName)
         entry = @mappedZip.find_entry(fileName)
-        expand_path(fileName) == "/" || (entry != nil && entry.directory?)
+        expand_path(fileName) == '/' || (!entry.nil? && entry.directory?)
       end
 
-      def open(fileName, openMode = "r", permissionInt = 0644, &block)
-        openMode.gsub!("b", "") # ignore b option
+      def open(fileName, openMode = 'r', permissionInt = 0644, &block)
+        openMode.gsub!('b', '') # ignore b option
         case openMode
-          when "r"
-            @mappedZip.get_input_stream(fileName, &block)
-          when "w"
-            @mappedZip.get_output_stream(fileName, permissionInt, &block)
-          else
-            raise StandardError, "openmode '#{openMode} not supported" unless openMode == "r"
+        when 'r'
+          @mappedZip.get_input_stream(fileName, &block)
+        when 'w'
+          @mappedZip.get_output_stream(fileName, permissionInt, &block)
+        else
+          raise StandardError, "openmode '#{openMode} not supported" unless openMode == 'r'
         end
       end
 
-      def new(fileName, openMode = "r")
+      def new(fileName, openMode = 'r')
         open(fileName, openMode)
       end
 
@@ -252,43 +260,41 @@ module Zip
       # Returns nil for not found and nil for directories
       def size?(fileName)
         entry = @mappedZip.find_entry(fileName)
-        return (entry == nil || entry.directory?) ? nil : entry.size
+        (entry.nil? || entry.directory?) ? nil : entry.size
       end
 
       def chown(ownerInt, groupInt, *filenames)
-        filenames.each { |fileName|
+        filenames.each do |fileName|
           e = get_entry(fileName)
-          unless e.extra.member?("IUnix")
-            e.extra.create("IUnix")
-          end
-          e.extra["IUnix"].uid = ownerInt
-          e.extra["IUnix"].gid = groupInt
-        }
+          e.extra.create('IUnix') unless e.extra.member?('IUnix')
+          e.extra['IUnix'].uid = ownerInt
+          e.extra['IUnix'].gid = groupInt
+        end
         filenames.size
       end
 
-      def chmod (modeInt, *filenames)
-        filenames.each { |fileName|
+      def chmod(modeInt, *filenames)
+        filenames.each do |fileName|
           e = get_entry(fileName)
           e.fstype = 3 # force convertion filesystem type to unix
           e.unix_perms = modeInt
           e.external_file_attributes = modeInt << 16
           e.dirty = true
-        }
+        end
         filenames.size
       end
 
       def zero?(fileName)
         sz = size(fileName)
-        sz == nil || sz == 0
+        sz.nil? || sz == 0
       rescue Errno::ENOENT
         false
       end
 
       def file?(fileName)
         entry = @mappedZip.find_entry(fileName)
-        entry != nil && entry.file?
-      end      
+        !entry.nil? && entry.file?
+      end
 
       def dirname(fileName)
         ::File.dirname(fileName)
@@ -307,9 +313,9 @@ module Zip
       end
 
       def utime(modifiedTime, *fileNames)
-        fileNames.each { |fileName|
+        fileNames.each do |fileName|
           get_entry(fileName).time = modifiedTime
-        }
+        end
       end
 
       def mtime(fileName)
@@ -318,66 +324,64 @@ module Zip
 
       def atime(fileName)
         e = get_entry(fileName)
-        if e.extra.member? "UniversalTime"
-          e.extra["UniversalTime"].atime
-        else
-          nil
+        if e.extra.member? 'UniversalTime'
+          e.extra['UniversalTime'].atime
+        elsif e.extra.member? 'NTFS'
+          e.extra['NTFS'].atime
         end
       end
 
       def ctime(fileName)
         e = get_entry(fileName)
-        if e.extra.member? "UniversalTime"
-          e.extra["UniversalTime"].ctime
-        else
-          nil
+        if e.extra.member? 'UniversalTime'
+          e.extra['UniversalTime'].ctime
+        elsif e.extra.member? 'NTFS'
+          e.extra['NTFS'].ctime
         end
       end
 
-      def pipe?(filename)
+      def pipe?(_filename)
         false
       end
 
-      def blockdev?(filename)
+      def blockdev?(_filename)
         false
       end
 
-      def chardev?(filename)
+      def chardev?(_filename)
         false
       end
 
-      def symlink?(fileName)
+      def symlink?(_fileName)
         false
       end
 
-      def socket?(fileName)
+      def socket?(_fileName)
         false
       end
 
       def ftype(fileName)
-        @mappedZip.get_entry(fileName).directory? ? "directory" : "file"
+        @mappedZip.get_entry(fileName).directory? ? 'directory' : 'file'
       end
 
-      def readlink(fileName)
-        raise NotImplementedError, "The readlink() function is not implemented"
+      def readlink(_fileName)
+        raise NotImplementedError, 'The readlink() function is not implemented'
       end
 
-      def symlink(fileName, symlinkName)
-        raise NotImplementedError, "The symlink() function is not implemented"
+      def symlink(_fileName, _symlinkName)
+        raise NotImplementedError, 'The symlink() function is not implemented'
       end
 
-      def link(fileName, symlinkName)
-        raise NotImplementedError, "The link() function is not implemented"
+      def link(_fileName, _symlinkName)
+        raise NotImplementedError, 'The link() function is not implemented'
       end
 
       def pipe
-        raise NotImplementedError, "The pipe() function is not implemented"
+        raise NotImplementedError, 'The pipe() function is not implemented'
       end
 
       def stat(fileName)
-        if ! exists?(fileName)
-          raise Errno::ENOENT, fileName
-        end
+        raise Errno::ENOENT, fileName unless exists?(fileName)
         ZipFsStat.new(self, fileName)
       end
 
@@ -400,20 +404,19 @@ module Zip
       end
 
       def delete(*args)
-        args.each {
-          |fileName|
+        args.each do |fileName|
           if directory?(fileName)
             raise Errno::EISDIR, "Is a directory - \"#{fileName}\""
           end
           @mappedZip.remove(fileName)
-        }
+        end
       end
 
       def rename(fileToRename, newName)
         @mappedZip.rename(fileToRename, newName) { true }
       end
 
-      alias :unlink :delete
+      alias unlink delete
 
       def expand_path(aPath)
         @mappedZip.expand_path(aPath)
@@ -427,7 +430,6 @@ module Zip
     # The individual methods are not documented due to their
     # similarity with the methods in Dir
     class ZipFsDir
-
       def initialize(mappedZip)
         @mappedZip = mappedZip
       end
@@ -451,7 +453,9 @@ module Zip
         dirIt
       end
 
-      def pwd; @mappedZip.pwd; end
+      def pwd
+        @mappedZip.pwd
+      end
       alias getwd pwd
 
       def chdir(aDirectoryName)
@@ -467,8 +471,8 @@ module Zip
         entries
       end
 
-      def glob(*args,&block)
-        @mappedZip.glob(*args,&block)
+      def glob(*args, &block)
+        @mappedZip.glob(*args, &block)
       end
 
       def foreach(aDirectoryName)
@@ -479,11 +483,10 @@ module Zip
         path << '/' unless path.end_with?('/')
         path = Regexp.escape(path)
         subDirEntriesRegex = Regexp.new("^#{path}([^/]+)$")
-        @mappedZip.each { 
-          |fileName|
+        @mappedZip.each do |fileName|
           match = subDirEntriesRegex.match(fileName)
-          yield(match[1]) unless match == nil
-        }
+          yield(match[1]) unless match.nil?
+        end
       end
 
       def delete(entryName)
@@ -492,17 +495,16 @@ module Zip
         end
         @mappedZip.remove(entryName)
       end
-      alias rmdir  delete
+      alias rmdir delete
       alias unlink delete
 
       def mkdir(entryName, permissionInt = 0755)
         @mappedZip.mkdir(entryName, permissionInt)
       end
 
-      def chroot(*args)
-        raise NotImplementedError, "The chroot() function is not implemented"
+      def chroot(*_args)
+        raise NotImplementedError, 'The chroot() function is not implemented'
       end
-
     end
 
     class ZipFsDirIterator # :nodoc:all
@@ -518,39 +520,39 @@ module Zip
       end
 
       def each(&aProc)
-        raise IOError, "closed directory" if @fileNames == nil
+        raise IOError, 'closed directory' if @fileNames.nil?
         @fileNames.each(&aProc)
       end
 
       def read
-        raise IOError, "closed directory" if @fileNames == nil
-        @fileNames[(@index+=1)-1]
+        raise IOError, 'closed directory' if @fileNames.nil?
+        @fileNames[(@index += 1) - 1]
       end
 
       def rewind
-        raise IOError, "closed directory" if @fileNames == nil
+        raise IOError, 'closed directory' if @fileNames.nil?
         @index = 0
       end
 
       def seek(anIntegerPosition)
-        raise IOError, "closed directory" if @fileNames == nil
+        raise IOError, 'closed directory' if @fileNames.nil?
         @index = anIntegerPosition
       end
 
       def tell
-        raise IOError, "closed directory" if @fileNames == nil
+        raise IOError, 'closed directory' if @fileNames.nil?
         @index
       end
     end
 
-    # All access to ZipFile from ZipFsFile and ZipFsDir goes through a
+    # All access to Zip::File from ZipFsFile and ZipFsDir goes through a
     # ZipFileNameMapper, which has one responsibility: ensure
     class ZipFileNameMapper # :nodoc:all
       include Enumerable
 
       def initialize(zipFile)
         @zipFile = zipFile
-        @pwd = "/"
+        @pwd = '/'
       end
 
       attr_accessor :pwd
@@ -580,7 +582,7 @@ module Zip
       end
 
       def rename(fileName, newName, &continueOnExistsProc)
-        @zipFile.rename(expand_to_entry(fileName), expand_to_entry(newName), 
+        @zipFile.rename(expand_to_entry(fileName), expand_to_entry(newName),
                         &continueOnExistsProc)
       end
 
@@ -591,17 +593,16 @@ module Zip
       # Turns entries into strings and adds leading /
       # and removes trailing slash on directories
       def each
-        @zipFile.each {
-          |e|
-          yield("/"+e.to_s.chomp("/"))
-        }
+        @zipFile.each do |e|
+          yield('/' + e.to_s.chomp('/'))
+        end
       end
 
       def expand_path(aPath)
-        expanded = aPath.start_with?("/") ? aPath : ::File.join(@pwd, aPath)
-        expanded.gsub!(/\/\.(\/|$)/, "")
-        expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, "")
-        expanded.empty? ? "/" : expanded
+        expanded = aPath.start_with?('/') ? aPath : ::File.join(@pwd, aPath)
+        expanded.gsub!(/\/\.(\/|$)/, '')
+        expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, '')
+        expanded.empty? ? '/' : expanded
       end
 
       private

data/lib/zip/inflater.rb

@@ -1,15 +1,16 @@
 module Zip
   class Inflater < Decompressor #:nodoc:all
-    def initialize(input_stream)
-      super
+    def initialize(input_stream, decrypter = NullDecrypter.new)
+      super(input_stream)
       @zlib_inflater           = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
       @output_buffer           = ''
       @has_returned_empty_string = false
+      @decrypter               = decrypter
     end
 
-    def sysread(number_of_bytes = nil, buf = nil)
+    def sysread(number_of_bytes = nil, buf = '')
       readEverything = number_of_bytes.nil?
-      while (readEverything || @output_buffer.bytesize < number_of_bytes)
+      while readEverything || @output_buffer.bytesize < number_of_bytes
         break if internal_input_finished?
         @output_buffer << internal_produce_input(buf)
       end
@@ -19,7 +20,7 @@ module Zip
     end
 
     def produce_input
-      if (@output_buffer.empty?)
+      if @output_buffer.empty?
         internal_produce_input
       else
         @output_buffer.slice!(0...(@output_buffer.length))
@@ -32,15 +33,15 @@ module Zip
       @output_buffer.empty? && internal_input_finished?
     end
 
-    alias :eof :input_finished?
-    alias :eof? :input_finished?
+    alias :eof input_finished?
+    alias :eof? input_finished?
 
     private
 
-    def internal_produce_input(buf = nil)
+    def internal_produce_input(buf = '')
       retried = 0
       begin
-        @zlib_inflater.inflate(@input_stream.read(Decompressor::CHUNK_SIZE, buf))
+        @zlib_inflater.inflate(@decrypter.decrypt(@input_stream.read(Decompressor::CHUNK_SIZE, buf)))
       rescue Zlib::BufError
         raise if retried >= 5 # how many times should we retry?
         retried += 1