rubyzip 1.0.0 → 2.4.1

data/lib/zip/filesystem.rb

@@ -1,115 +1,111 @@
 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)
-      @zipFsFile = ZipFsFile.new(mappedZip)
-      @zipFsDir.file = @zipFsFile
-      @zipFsFile.dir = @zipFsDir
+      mapped_zip       = ZipFileNameMapper.new(self)
+      @zip_fs_dir      = ZipFsDir.new(mapped_zip)
+      @zip_fs_file     = ZipFsFile.new(mapped_zip)
+      @zip_fs_dir.file = @zip_fs_file
+      @zip_fs_file.dir = @zip_fs_dir
     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
+      @zip_fs_dir
     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
+      @zip_fs_file
     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)
+                  @zip_fs_file.#{method}(@entry_name) #   @zip_fs_file.file?(@entry_name)
                 end                                # end
-              end_eval
+              END_EVAL
             end
           end
-
         end
 
-        def initialize(zipFsFile, entryName)
-          @zipFsFile = zipFsFile
-          @entryName = entryName
+        def initialize(zip_fs_file, entry_name)
+          @zip_fs_file = zip_fs_file
+          @entry_name = entry_name
         end
 
-        def kind_of?(t)
-          super || t == ::File::Stat 
+        def kind_of?(type)
+          super || type == ::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)
+          @zip_fs_file.__send__(:get_entry, @entry_name)
         end
         private :get_entry
 
         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,306 +113,316 @@ 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
 
-      def initialize(mappedZip)
-        @mappedZip = mappedZip
+      def initialize(mapped_zip)
+        @mapped_zip = mapped_zip
       end
 
-      def get_entry(fileName)
-        if ! exists?(fileName)
-          raise Errno::ENOENT, "No such file or directory - #{fileName}"
+      def get_entry(filename)
+        unless exists?(filename)
+          raise Errno::ENOENT, "No such file or directory - #{filename}"
         end
-        @mappedZip.find_entry(fileName)
+
+        @mapped_zip.find_entry(filename)
       end
       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
+      def unix_mode_cmp(filename, mode)
+        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
+      def exists?(filename)
+        expand_path(filename) == '/' || !@mapped_zip.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)
+      def readable?(filename)
+        unix_mode_cmp(filename, 0o444)
       end
-      alias readable_real?   readable?
+      alias readable_real? readable?
 
-      def writable?(fileName)
-        unix_mode_cmp(fileName, 0222)
+      def writable?(filename)
+        unix_mode_cmp(filename, 0o222)
       end
-      alias writable_real?   writable?
+      alias writable_real? writable?
 
-      def executable?(fileName)
-        unix_mode_cmp(fileName, 0111)
+      def executable?(filename)
+        unix_mode_cmp(filename, 0o111)
       end
       alias executable_real? executable?
 
-      def setuid?(fileName)
-        unix_mode_cmp(fileName, 04000)
+      def setuid?(filename)
+        unix_mode_cmp(filename, 0o4000)
       end
 
-      def setgid?(fileName)
-        unix_mode_cmp(fileName, 02000)
+      def setgid?(filename)
+        unix_mode_cmp(filename, 0o2000)
       end
 
-      def sticky?(fileName)
-        unix_mode_cmp(fileName, 01000)
+      def sticky?(filename)
+        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?)
+      def directory?(filename)
+        entry = @mapped_zip.find_entry(filename)
+        expand_path(filename) == '/' || (!entry.nil? && entry.directory?)
       end
 
-      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"
+      def open(filename, mode = 'r', permissions = 0o644, &block)
+        mode = mode.delete('b') # ignore b option
+        case mode
+        when 'r'
+          @mapped_zip.get_input_stream(filename, &block)
+        when 'w'
+          @mapped_zip.get_output_stream(filename, permissions, &block)
+        else
+          raise StandardError, "openmode '#{mode} not supported" unless mode == 'r'
         end
       end
 
-      def new(fileName, openMode = "r")
-        open(fileName, openMode)
+      def new(filename, mode = 'r')
+        self.open(filename, mode)
       end
 
-      def size(fileName)
-        @mappedZip.get_entry(fileName).size
+      def size(filename)
+        @mapped_zip.get_entry(filename).size
       end
 
       # 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
+      def size?(filename)
+        entry = @mapped_zip.find_entry(filename)
+        entry.nil? || entry.directory? ? nil : entry.size
       end
 
-      def chown(ownerInt, groupInt, *filenames)
-        filenames.each { |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
-        }
+      def chown(owner, group, *filenames)
+        filenames.each do |filename|
+          e = get_entry(filename)
+          e.extra.create('IUnix') unless e.extra.member?('IUnix')
+          e.extra['IUnix'].uid = owner
+          e.extra['IUnix'].gid = group
+        end
         filenames.size
       end
 
-      def chmod (modeInt, *filenames)
-        filenames.each { |fileName|
-          e = get_entry(fileName)
+      def chmod(mode, *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.unix_perms = mode
+          e.external_file_attributes = mode << 16
           e.dirty = true
-        }
+        end
         filenames.size
       end
 
-      def zero?(fileName)
-        sz = size(fileName)
-        sz == nil || sz == 0
+      def zero?(filename)
+        sz = size(filename)
+        sz.nil? || sz == 0
       rescue Errno::ENOENT
         false
       end
 
-      def file?(fileName)
-        entry = @mappedZip.find_entry(fileName)
-        entry != nil && entry.file?
-      end      
+      def file?(filename)
+        entry = @mapped_zip.find_entry(filename)
+        !entry.nil? && entry.file?
+      end
 
-      def dirname(fileName)
-        ::File.dirname(fileName)
+      def dirname(filename)
+        ::File.dirname(filename)
       end
 
-      def basename(fileName)
-        ::File.basename(fileName)
+      def basename(filename)
+        ::File.basename(filename)
       end
 
-      def split(fileName)
-        ::File.split(fileName)
+      def split(filename)
+        ::File.split(filename)
       end
 
       def join(*fragments)
         ::File.join(*fragments)
       end
 
-      def utime(modifiedTime, *fileNames)
-        fileNames.each { |fileName|
-          get_entry(fileName).time = modifiedTime
-        }
+      def utime(modified_time, *filenames)
+        filenames.each do |filename|
+          get_entry(filename).time = modified_time
+        end
       end
 
-      def mtime(fileName)
-        @mappedZip.get_entry(fileName).mtime
+      def mtime(filename)
+        @mapped_zip.get_entry(filename).mtime
       end
 
-      def atime(fileName)
-        e = get_entry(fileName)
-        if e.extra.member? "UniversalTime"
-          e.extra["UniversalTime"].atime
-        else
-          nil
+      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
         end
       end
 
-      def ctime(fileName)
-        e = get_entry(fileName)
-        if e.extra.member? "UniversalTime"
-          e.extra["UniversalTime"].ctime
-        else
-          nil
+      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
         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"
+      def ftype(filename)
+        @mapped_zip.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, _symlink_name)
+        raise NotImplementedError, 'The symlink() function is not implemented'
       end
 
-      def link(fileName, symlinkName)
-        raise NotImplementedError, "The link() function is not implemented"
+      def link(_filename, _symlink_name)
+        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
-        ZipFsStat.new(self, fileName)
+      def stat(filename)
+        raise Errno::ENOENT, filename unless exists?(filename)
+
+        ZipFsStat.new(self, filename)
       end
 
       alias lstat stat
 
-      def readlines(fileName)
-        open(fileName) { |is| is.readlines }
+      def readlines(filename)
+        self.open(filename, &:readlines)
       end
 
-      def read(fileName)
-        @mappedZip.read(fileName)
+      def read(filename)
+        @mapped_zip.read(filename)
       end
 
-      def popen(*args, &aProc)
-        ::File.popen(*args, &aProc)
+      def popen(*args, &a_proc)
+        ::File.popen(*args, &a_proc)
       end
 
-      def foreach(fileName, aSep = $/, &aProc)
-        open(fileName) { |is| is.each_line(aSep, &aProc) }
+      def foreach(filename, sep = $INPUT_RECORD_SEPARATOR, &a_proc)
+        self.open(filename) { |is| is.each_line(sep, &a_proc) }
       end
 
       def delete(*args)
-        args.each {
-          |fileName|
-          if directory?(fileName)
-            raise Errno::EISDIR, "Is a directory - \"#{fileName}\""
+        args.each do |filename|
+          if directory?(filename)
+            raise Errno::EISDIR, "Is a directory - \"#{filename}\""
           end
-          @mappedZip.remove(fileName)
-        }
+
+          @mapped_zip.remove(filename)
+        end
       end
 
-      def rename(fileToRename, newName)
-        @mappedZip.rename(fileToRename, newName) { true }
+      def rename(file_to_rename, new_name)
+        @mapped_zip.rename(file_to_rename, new_name) { true }
       end
 
-      alias :unlink :delete
+      alias unlink delete
 
-      def expand_path(aPath)
-        @mappedZip.expand_path(aPath)
+      def expand_path(path)
+        @mapped_zip.expand_path(path)
       end
     end
 
@@ -427,187 +433,202 @@ module Zip
     # The individual methods are not documented due to their
     # similarity with the methods in Dir
     class ZipFsDir
-
-      def initialize(mappedZip)
-        @mappedZip = mappedZip
+      def initialize(mapped_zip)
+        @mapped_zip = mapped_zip
       end
 
       attr_writer :file
 
-      def new(aDirectoryName)
-        ZipFsDirIterator.new(entries(aDirectoryName))
+      def new(directory_name)
+        ZipFsDirIterator.new(entries(directory_name))
       end
 
-      def open(aDirectoryName)
-        dirIt = new(aDirectoryName)
+      def open(directory_name)
+        dir_iter = new(directory_name)
         if block_given?
           begin
-            yield(dirIt)
+            yield(dir_iter)
             return nil
           ensure
-            dirIt.close
+            dir_iter.close
           end
         end
-        dirIt
+        dir_iter
       end
 
-      def pwd; @mappedZip.pwd; end
+      def pwd
+        @mapped_zip.pwd
+      end
       alias getwd pwd
 
-      def chdir(aDirectoryName)
-        unless @file.stat(aDirectoryName).directory?
-          raise Errno::EINVAL, "Invalid argument - #{aDirectoryName}"
+      def chdir(directory_name)
+        unless @file.stat(directory_name).directory?
+          raise Errno::EINVAL, "Invalid argument - #{directory_name}"
         end
-        @mappedZip.pwd = @file.expand_path(aDirectoryName)
+
+        @mapped_zip.pwd = @file.expand_path(directory_name)
       end
 
-      def entries(aDirectoryName)
+      def entries(directory_name)
         entries = []
-        foreach(aDirectoryName) { |e| entries << e }
+        foreach(directory_name) { |e| entries << e }
         entries
       end
 
-      def glob(*args,&block)
-        @mappedZip.glob(*args,&block)
+      def glob(*args, &block)
+        @mapped_zip.glob(*args, &block)
       end
 
-      def foreach(aDirectoryName)
-        unless @file.stat(aDirectoryName).directory?
-          raise Errno::ENOTDIR, aDirectoryName
+      def foreach(directory_name)
+        unless @file.stat(directory_name).directory?
+          raise Errno::ENOTDIR, directory_name
         end
-        path = @file.expand_path(aDirectoryName)
+
+        path = @file.expand_path(directory_name)
         path << '/' unless path.end_with?('/')
         path = Regexp.escape(path)
-        subDirEntriesRegex = Regexp.new("^#{path}([^/]+)$")
-        @mappedZip.each { 
-          |fileName|
-          match = subDirEntriesRegex.match(fileName)
-          yield(match[1]) unless match == nil
-        }
+        subdir_entry_regex = Regexp.new("^#{path}([^/]+)$")
+        @mapped_zip.each do |filename|
+          match = subdir_entry_regex.match(filename)
+          yield(match[1]) unless match.nil?
+        end
       end
 
-      def delete(entryName)
-        unless @file.stat(entryName).directory?
-          raise Errno::EINVAL, "Invalid argument - #{entryName}"
+      def delete(entry_name)
+        unless @file.stat(entry_name).directory?
+          raise Errno::EINVAL, "Invalid argument - #{entry_name}"
         end
-        @mappedZip.remove(entryName)
+
+        @mapped_zip.remove(entry_name)
       end
-      alias rmdir  delete
+      alias rmdir delete
       alias unlink delete
 
-      def mkdir(entryName, permissionInt = 0755)
-        @mappedZip.mkdir(entryName, permissionInt)
+      def mkdir(entry_name, permissions = 0o755)
+        @mapped_zip.mkdir(entry_name, permissions)
       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
       include Enumerable
 
-      def initialize(arrayOfFileNames)
-        @fileNames = arrayOfFileNames
+      def initialize(filenames)
+        @filenames = filenames
         @index = 0
       end
 
       def close
-        @fileNames = nil
+        @filenames = nil
       end
 
-      def each(&aProc)
-        raise IOError, "closed directory" if @fileNames == nil
-        @fileNames.each(&aProc)
+      def each(&a_proc)
+        raise IOError, 'closed directory' if @filenames.nil?
+
+        @filenames.each(&a_proc)
       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
-        @index = anIntegerPosition
+      def seek(position)
+        raise IOError, 'closed directory' if @filenames.nil?
+
+        @index = position
       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 = "/"
+      def initialize(zip_file)
+        @zip_file = zip_file
+        @pwd = '/'
       end
 
       attr_accessor :pwd
 
-      def find_entry(fileName)
-        @zipFile.find_entry(expand_to_entry(fileName))
+      def find_entry(filename)
+        @zip_file.find_entry(expand_to_entry(filename))
       end
 
-      def get_entry(fileName)
-        @zipFile.get_entry(expand_to_entry(fileName))
+      def get_entry(filename)
+        @zip_file.get_entry(expand_to_entry(filename))
       end
 
-      def get_input_stream(fileName, &aProc)
-        @zipFile.get_input_stream(expand_to_entry(fileName), &aProc)
+      def get_input_stream(filename, &a_proc)
+        @zip_file.get_input_stream(expand_to_entry(filename), &a_proc)
       end
 
-      def get_output_stream(fileName, permissionInt = nil, &aProc)
-        @zipFile.get_output_stream(expand_to_entry(fileName), permissionInt, &aProc)
+      def get_output_stream(filename, permissions = nil, &a_proc)
+        @zip_file.get_output_stream(
+          expand_to_entry(filename), permissions, &a_proc
+        )
       end
 
-      def read(fileName)
-        @zipFile.read(expand_to_entry(fileName))
+      def glob(pattern, *flags, &block)
+        @zip_file.glob(expand_to_entry(pattern), *flags, &block)
       end
 
-      def remove(fileName)
-        @zipFile.remove(expand_to_entry(fileName))
+      def read(filename)
+        @zip_file.read(expand_to_entry(filename))
       end
 
-      def rename(fileName, newName, &continueOnExistsProc)
-        @zipFile.rename(expand_to_entry(fileName), expand_to_entry(newName), 
-                        &continueOnExistsProc)
+      def remove(filename)
+        @zip_file.remove(expand_to_entry(filename))
       end
 
-      def mkdir(fileName, permissionInt = 0755)
-        @zipFile.mkdir(expand_to_entry(fileName), permissionInt)
+      def rename(filename, new_name, &continue_on_exists_proc)
+        @zip_file.rename(
+          expand_to_entry(filename),
+          expand_to_entry(new_name),
+          &continue_on_exists_proc
+        )
+      end
+
+      def mkdir(filename, permissions = 0o755)
+        @zip_file.mkdir(expand_to_entry(filename), permissions)
       end
 
       # Turns entries into strings and adds leading /
       # and removes trailing slash on directories
       def each
-        @zipFile.each {
-          |e|
-          yield("/"+e.to_s.chomp("/"))
-        }
+        @zip_file.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
+      def expand_path(path)
+        expanded = path.start_with?('/') ? path.dup : ::File.join(@pwd, path)
+        expanded.gsub!(/\/\.(\/|$)/, '')
+        expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, '')
+        expanded.empty? ? '/' : expanded
       end
 
       private
 
-      def expand_to_entry(aPath)
-        expand_path(aPath)[1..-1]
+      def expand_to_entry(path)
+        expand_path(path)[1..-1]
       end
     end
   end