rubyzip 1.1.7 → 1.3.0

data/lib/zip/file.rb

@@ -43,13 +43,13 @@ module Zip
   # interface for accessing the filesystem, ie. the File and Dir classes.
 
   class File < CentralDirectory
-
-    CREATE               = 1
+    CREATE               = true
     SPLIT_SIGNATURE      = 0x08074b50
     ZIP64_EOCD_SIGNATURE = 0x06064b50
-    MAX_SEGMENT_SIZE     = 3221225472
-    MIN_SEGMENT_SIZE     = 65536
+    MAX_SEGMENT_SIZE     = 3_221_225_472
+    MIN_SEGMENT_SIZE     = 65_536
     DATA_BUFFER_SIZE     = 8192
+    IO_METHODS           = [:tell, :seek, :read, :close]
 
     attr_reader :name
 
@@ -64,23 +64,38 @@ module Zip
 
     # Opens a zip archive. Pass true as the second parameter to create
     # a new archive if it doesn't exist already.
-    def initialize(file_name, create = nil, buffer = false, options = {})
+    def initialize(path_or_io, create = false, buffer = false, options = {})
       super()
-      @name    = file_name
+      @name    = path_or_io.respond_to?(:path) ? path_or_io.path : path_or_io
       @comment = ''
-      @create  = create
-      case
-      when !buffer && ::File.size?(file_name)
-        @create = nil
-        @exist_file_perms = ::File.stat(file_name).mode
-        ::File.open(name, 'rb') do |f|
-          read_from_stream(f)
+      @create  = create ? true : false # allow any truthy value to mean true
+
+      if ::File.size?(@name.to_s)
+        # There is a file, which exists, that is associated with this zip.
+        @create = false
+        @file_permissions = ::File.stat(@name).mode
+
+        if buffer
+          read_from_stream(path_or_io)
+        else
+          ::File.open(@name, 'rb') do |f|
+            read_from_stream(f)
+          end
         end
-      when create
+      elsif buffer && path_or_io.size > 0
+        # This zip is probably a non-empty StringIO.
+        read_from_stream(path_or_io)
+      elsif @create
+        # This zip is completely new/empty and is to be created.
         @entry_set = EntrySet.new
+      elsif ::File.zero?(@name)
+        # A file exists, but it is empty.
+        raise Error, "File #{@name} has zero size. Did you mean to pass the create flag?"
       else
-        raise Error, "File #{file_name} not found"
+        # Everything is wrong.
+        raise Error, "File #{@name} not found"
       end
+
       @stored_entries      = @entry_set.dup
       @stored_comment      = @comment
       @restore_ownership   = options[:restore_ownership]    || false
@@ -92,7 +107,7 @@ module Zip
       # Same as #new. If a block is passed the ZipFile object is passed
       # to the block and is automatically closed afterwards just as with
       # ruby's builtin File.open method.
-      def open(file_name, create = nil)
+      def open(file_name, create = false)
         zf = ::Zip::File.new(file_name, create)
         return zf unless block_given?
         begin
@@ -115,23 +130,23 @@ module Zip
       # (This can be used to extract data from a
       # downloaded zip archive without first saving it to disk.)
       def open_buffer(io, options = {})
-        unless io.is_a?(IO) || io.is_a?(String) || io.is_a?(Tempfile)
-          raise "Zip::File.open_buffer expects an argument of class String, IO, or Tempfile. Found: #{io.class}"
-        end
-        if io.is_a?(::String)
-          require 'stringio'
-          io = ::StringIO.new(io)
-        elsif io.is_a?(IO)
-          # https://github.com/rubyzip/rubyzip/issues/119
-          io.binmode
+        unless IO_METHODS.map { |method| io.respond_to?(method) }.all? || io.is_a?(String)
+          raise "Zip::File.open_buffer expects a String or IO-like argument (responds to #{IO_METHODS.join(', ')}). Found: #{io.class}"
         end
+
+        io = ::StringIO.new(io) if io.is_a?(::String)
+
+        # https://github.com/rubyzip/rubyzip/issues/119
+        io.binmode if io.respond_to?(:binmode)
+
         zf = ::Zip::File.new(io, true, true, options)
-        zf.read_from_stream(io)
+        return zf unless block_given?
         yield zf
+
         begin
           zf.write_buffer(io)
         rescue IOError => e
-          raise unless e.message == "not opened for writing"
+          raise unless e.message == 'not opened for writing'
         end
       end
 
@@ -148,10 +163,9 @@ module Zip
       end
 
       def get_segment_size_for_split(segment_size)
-        case
-        when MIN_SEGMENT_SIZE > segment_size
+        if MIN_SEGMENT_SIZE > segment_size
           MIN_SEGMENT_SIZE
-        when MAX_SEGMENT_SIZE < segment_size
+        elsif MAX_SEGMENT_SIZE < segment_size
           MAX_SEGMENT_SIZE
         else
           segment_size
@@ -159,8 +173,10 @@ module Zip
       end
 
       def get_partial_zip_file_name(zip_file_name, partial_zip_file_name)
-        partial_zip_file_name = zip_file_name.sub(/#{::File.basename(zip_file_name)}\z/,
-                                                  partial_zip_file_name + ::File.extname(zip_file_name)) unless partial_zip_file_name.nil?
+        unless partial_zip_file_name.nil?
+          partial_zip_file_name = zip_file_name.sub(/#{::File.basename(zip_file_name)}\z/,
+                                                    partial_zip_file_name + ::File.extname(zip_file_name))
+        end
         partial_zip_file_name ||= zip_file_name
         partial_zip_file_name
       end
@@ -181,7 +197,7 @@ module Zip
       def save_splited_part(zip_file, partial_zip_file_name, zip_file_size, szip_file_index, segment_size, segment_count)
         ssegment_size  = zip_file_size - zip_file.pos
         ssegment_size  = segment_size if ssegment_size > segment_size
-        szip_file_name = "#{partial_zip_file_name}.#{'%03d'%(szip_file_index)}"
+        szip_file_name = "#{partial_zip_file_name}.#{format('%03d', szip_file_index)}"
         ::File.open(szip_file_name, 'wb') do |szip_file|
           if szip_file_index == 1
             ssegment_size = put_split_signature(szip_file, segment_size)
@@ -191,7 +207,7 @@ module Zip
             segment_bytes_left = ssegment_size - chunk_bytes
             buffer_size        = segment_bytes_left < DATA_BUFFER_SIZE ? segment_bytes_left : DATA_BUFFER_SIZE
             chunk              = zip_file.read(buffer_size)
-            chunk_bytes        += buffer_size
+            chunk_bytes += buffer_size
             szip_file << chunk
             # Info for track splitting
             yield segment_count, szip_file_index, chunk_bytes, ssegment_size if block_given?
@@ -208,7 +224,7 @@ module Zip
         return if zip_file_size <= segment_size
         segment_count = get_segment_count_for_split(zip_file_size, segment_size)
         # Checking for correct zip structure
-        self.open(zip_file_name) {}
+        open(zip_file_name) {}
         partial_zip_file_name = get_partial_zip_file_name(zip_file_name, partial_zip_file_name)
         szip_file_index       = 0
         ::File.open(zip_file_name, 'rb') do |zip_file|
@@ -222,7 +238,6 @@ module Zip
       end
     end
 
-
     # Returns an input stream to the specified entry. If a block is passed
     # the stream object is passed to the block and the stream is automatically
     # closed afterwards just as with ruby's builtin File.open method.
@@ -235,7 +250,7 @@ module Zip
     # specified. If a block is passed the stream object is passed to the block and
     # the stream is automatically closed afterwards just as with ruby's builtin
     # File.open method.
-    def get_output_stream(entry, permission_int = nil, comment = nil, extra = nil, compressed_size = nil, crc = nil, compression_method = nil, size = nil, time = nil,  &aProc)
+    def get_output_stream(entry, permission_int = nil, comment = nil, extra = nil, compressed_size = nil, crc = nil, compression_method = nil, size = nil, time = nil, &aProc)
       new_entry =
         if entry.kind_of?(Entry)
           entry
@@ -265,13 +280,20 @@ module Zip
     # Convenience method for adding the contents of a file to the archive
     def add(entry, src_path, &continue_on_exists_proc)
       continue_on_exists_proc ||= proc { ::Zip.continue_on_exists_proc }
-      check_entry_exists(entry, continue_on_exists_proc, "add")
+      check_entry_exists(entry, continue_on_exists_proc, 'add')
       new_entry = entry.kind_of?(::Zip::Entry) ? entry : ::Zip::Entry.new(@name, entry.to_s)
       new_entry.gather_fileinfo_from_srcpath(src_path)
       new_entry.dirty = true
       @entry_set << new_entry
     end
 
+    # Convenience method for adding the contents of a file to the archive
+    # in Stored format (uncompressed)
+    def add_stored(entry, src_path, &continue_on_exists_proc)
+      entry = ::Zip::Entry.new(@name, entry.to_s, nil, nil, nil, nil, ::Zip::Entry::STORED)
+      add(entry, src_path, &continue_on_exists_proc)
+    end
+
     # Removes the specified entry.
     def remove(entry)
       @entry_set.delete(get_entry(entry))
@@ -304,7 +326,7 @@ module Zip
     # Commits changes that has been made since the previous commit to
     # the zip archive.
     def commit
-      return unless commit_required?
+      return if name.is_a?(StringIO) || !commit_required?
       on_success_replace do |tmp_file|
         ::Zip::OutputStream.open(tmp_file) do |zos|
           @entry_set.each do |e|
@@ -338,7 +360,7 @@ module Zip
       @entry_set.each do |e|
         return true if e.dirty
       end
-      @comment != @stored_comment || @entry_set != @stored_entries || @create == ::Zip::File::CREATE
+      @comment != @stored_comment || @entry_set != @stored_entries || @create
     end
 
     # Searches for entry with the specified name. Returns nil if
@@ -356,9 +378,7 @@ module Zip
     # if no entry is found.
     def get_entry(entry)
       selected_entry = find_entry(entry)
-      unless selected_entry
-        raise Errno::ENOENT, entry
-      end
+      raise Errno::ENOENT, entry unless selected_entry
       selected_entry.restore_ownership   = @restore_ownership
       selected_entry.restore_permissions = @restore_permissions
       selected_entry.restore_times       = @restore_times
@@ -366,10 +386,8 @@ module Zip
     end
 
     # Creates a directory
-    def mkdir(entryName, permissionInt = 0755)
-      if find_entry(entryName)
-        raise Errno::EEXIST, "File exists - #{entryName}"
-      end
+    def mkdir(entryName, permissionInt = 0o755)
+      raise Errno::EEXIST, "File exists - #{entryName}" if find_entry(entryName)
       entryName = entryName.dup.to_s
       entryName << '/' unless entryName.end_with?('/')
       @entry_set << ::Zip::StreamableDirectory.new(@name, entryName, nil, permissionInt)
@@ -377,57 +395,46 @@ module Zip
 
     private
 
-    def is_directory(newEntry, srcPath)
+    def directory?(newEntry, srcPath)
       srcPathIsDirectory = ::File.directory?(srcPath)
-      if newEntry.is_directory && !srcPathIsDirectory
+      if newEntry.directory? && !srcPathIsDirectory
         raise ArgumentError,
-              "entry name '#{newEntry}' indicates directory entry, but "+
-                "'#{srcPath}' is not a directory"
-      elsif !newEntry.is_directory && srcPathIsDirectory
-        newEntry.name += "/"
+              "entry name '#{newEntry}' indicates directory entry, but " \
+                  "'#{srcPath}' is not a directory"
+      elsif !newEntry.directory? && srcPathIsDirectory
+        newEntry.name += '/'
       end
-      newEntry.is_directory && srcPathIsDirectory
+      newEntry.directory? && srcPathIsDirectory
     end
 
     def check_entry_exists(entryName, continue_on_exists_proc, procedureName)
       continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc }
-      if @entry_set.include?(entryName)
-        if continue_on_exists_proc.call
-          remove get_entry(entryName)
-        else
-          raise ::Zip::EntryExistsError,
-                procedureName + " failed. Entry #{entryName} already exists"
-        end
+      return unless @entry_set.include?(entryName)
+      if continue_on_exists_proc.call
+        remove get_entry(entryName)
+      else
+        raise ::Zip::EntryExistsError,
+              procedureName + " failed. Entry #{entryName} already exists"
       end
     end
 
     def check_file(path)
-      unless ::File.readable?(path)
-        raise Errno::ENOENT, path
-      end
+      raise Errno::ENOENT, path unless ::File.readable?(path)
     end
 
     def on_success_replace
-      tmpfile      = get_tempfile
-      tmp_filename = tmpfile.path
-      ObjectSpace.undefine_finalizer(tmpfile)
-      tmpfile.close
-      if yield tmp_filename
-        ::File.rename(tmp_filename, self.name)
-        if defined?(@exist_file_perms)
-          ::File.chmod(@exist_file_perms, self.name)
+      dirname, basename = ::File.split(name)
+      ::Dir::Tmpname.create(basename, dirname) do |tmp_filename|
+        begin
+          if yield tmp_filename
+            ::File.rename(tmp_filename, name)
+            ::File.chmod(@file_permissions, name) unless @create
+          end
+        ensure
+          ::File.unlink(tmp_filename) if ::File.exist?(tmp_filename)
         end
       end
-    ensure
-      tmpfile.unlink if tmpfile
     end
-
-    def get_tempfile
-      temp_file = Tempfile.new(::File.basename(name), ::File.dirname(name))
-      temp_file.binmode
-      temp_file
-    end
-
   end
 end
 

data/lib/zip/filesystem.rb

@@ -1,21 +1,20 @@
 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/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::File::CREATE) {
   #     |zipfile|
   #     zipfile.file.open("first.txt", "w") { |f| f.puts "Hello world" }
@@ -23,19 +22,18 @@ module Zip
   #     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)
@@ -65,24 +63,20 @@ module Zip
     # 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"
+            'file'
           elsif directory?
-            return "directory"
+            '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,77 +181,75 @@ 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)
+        unix_mode_cmp(fileName, 0o444)
       end
-      alias readable_real?   readable?
+      alias readable_real? readable?
 
       def writable?(fileName)
-        unix_mode_cmp(fileName, 0222)
+        unix_mode_cmp(fileName, 0o222)
       end
-      alias writable_real?   writable?
+      alias writable_real? writable?
 
       def executable?(fileName)
-        unix_mode_cmp(fileName, 0111)
+        unix_mode_cmp(fileName, 0o111)
       end
       alias executable_real? executable?
 
       def setuid?(fileName)
-        unix_mode_cmp(fileName, 04000)
+        unix_mode_cmp(fileName, 0o4000)
       end
 
       def setgid?(fileName)
-        unix_mode_cmp(fileName, 02000)
+        unix_mode_cmp(fileName, 0o2000)
       end
 
       def sticky?(fileName)
-        unix_mode_cmp(fileName, 01000)
+        unix_mode_cmp(fileName, 0o1000)
       end
 
       def umask(*args)
         ::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 = 0o644, &block)
+        openMode.delete!('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,70 +324,64 @@ module Zip
 
       def atime(fileName)
         e = get_entry(fileName)
-        if e.extra.member? "UniversalTime"
-          e.extra["UniversalTime"].atime
-        elsif e.extra.member? "NTFS"
-          e.extra["NTFS"].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
-        elsif e.extra.member? "NTFS"
-          e.extra["NTFS"].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
 
@@ -404,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)
@@ -431,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
@@ -455,7 +453,9 @@ module Zip
         dirIt
       end
 
-      def pwd; @mappedZip.pwd; end
+      def pwd
+        @mappedZip.pwd
+      end
       alias getwd pwd
 
       def chdir(aDirectoryName)
@@ -471,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)
@@ -483,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)
@@ -496,17 +495,16 @@ module Zip
         end
         @mappedZip.remove(entryName)
       end
-      alias rmdir  delete
+      alias rmdir delete
       alias unlink delete
 
-      def mkdir(entryName, permissionInt = 0755)
+      def mkdir(entryName, permissionInt = 0o755)
         @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
@@ -522,27 +520,27 @@ 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
@@ -554,7 +552,7 @@ module Zip
 
       def initialize(zipFile)
         @zipFile = zipFile
-        @pwd = "/"
+        @pwd = '/'
       end
 
       attr_accessor :pwd
@@ -575,6 +573,10 @@ module Zip
         @zipFile.get_output_stream(expand_to_entry(fileName), permissionInt, &aProc)
       end
 
+      def glob(pattern, *flags, &block)
+        @zipFile.glob(expand_to_entry(pattern), *flags, &block)
+      end
+
       def read(fileName)
         @zipFile.read(expand_to_entry(fileName))
       end
@@ -584,28 +586,27 @@ 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
 
-      def mkdir(fileName, permissionInt = 0755)
+      def mkdir(fileName, permissionInt = 0o755)
         @zipFile.mkdir(expand_to_entry(fileName), permissionInt)
       end
 
       # 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