rubyzip 0.9.9 → 1.3.0

data/lib/zip/zip_extra_field.rb

@@ -1,213 +0,0 @@
-module Zip
-  class ZipExtraField < Hash
-    ID_MAP = {}
-
-    # Meta class for extra fields
-    class Generic
-      def self.register_map
-        if self.const_defined?(:HEADER_ID)
-          ID_MAP[self.const_get(:HEADER_ID)] = self
-        end
-      end
-
-      def self.name
-        self.to_s.split("::")[-1]
-      end
-
-      # return field [size, content] or false
-      def initial_parse(binstr)
-        if ! binstr
-          # If nil, start with empty.
-          return false
-        elsif binstr[0,2] != self.class.const_get(:HEADER_ID)
-          $stderr.puts "Warning: weired extra feild header ID. skip parsing"
-          return false
-        end
-        [binstr[2,2].unpack("v")[0], binstr[4..-1]]
-      end
-
-      def ==(other)
-        return false if self.class != other.class
-        each do |k, v|
-          v != other[k] and return false
-        end
-        true
-      end
-
-      def to_local_bin
-        s = pack_for_local
-        self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") + s
-      end
-
-      def to_c_dir_bin
-        s = pack_for_c_dir
-        self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") + s
-      end
-    end
-
-    # Info-ZIP Additional timestamp field
-    class UniversalTime < Generic
-      HEADER_ID = "UT"
-      register_map
-
-      def initialize(binstr = nil)
-        @ctime = nil
-        @mtime = nil
-        @atime = nil
-        @flag  = nil
-        binstr and merge(binstr)
-      end
-      attr_accessor :atime, :ctime, :mtime, :flag
-
-      def merge(binstr)
-        return if binstr.empty?
-        size, content = initial_parse(binstr)
-        size or return
-        @flag, mtime, atime, ctime = content.unpack("CVVV")
-        mtime and @mtime ||= DOSTime.at(mtime)
-        atime and @atime ||= DOSTime.at(atime)
-        ctime and @ctime ||= DOSTime.at(ctime)
-      end
-
-      def ==(other)
-        @mtime == other.mtime &&
-        @atime == other.atime &&
-        @ctime == other.ctime
-      end
-
-      def pack_for_local
-        s = [@flag].pack("C")
-        @flag & 1 != 0 and s << [@mtime.to_i].pack("V")
-        @flag & 2 != 0 and s << [@atime.to_i].pack("V")
-        @flag & 4 != 0 and s << [@ctime.to_i].pack("V")
-        s
-      end
-
-      def pack_for_c_dir
-        s = [@flag].pack("C")
-        @flag & 1 == 1 and s << [@mtime.to_i].pack("V")
-        s
-      end
-    end
-
-    # Info-ZIP Extra for UNIX uid/gid
-    class IUnix < Generic
-      HEADER_ID = "Ux"
-      register_map
-
-      def initialize(binstr = nil)
-        @uid = 0
-        @gid = 0
-        binstr and merge(binstr)
-      end
-      attr_accessor :uid, :gid
-
-      def merge(binstr)
-        return if binstr.empty?
-        size, content = initial_parse(binstr)
-        # size: 0 for central directory. 4 for local header
-        return if(!size || size == 0)
-        uid, gid = content.unpack("vv")
-        @uid ||= uid
-        @gid ||= gid
-      end
-
-      def ==(other)
-        @uid == other.uid &&
-        @gid == other.gid
-      end
-
-      def pack_for_local
-        [@uid, @gid].pack("vv")
-      end
-
-      def pack_for_c_dir
-        ""
-      end
-    end
-
-    ## start main of ZipExtraField < Hash
-    def initialize(binstr = nil)
-      binstr and merge(binstr)
-    end
-
-    def merge(binstr)
-      return if binstr.empty?
-      i = 0 
-      while i < binstr.bytesize
-        id = binstr[i,2]
-        len = binstr[i + 2,2].to_s.unpack("v")[0]
-        if id && ID_MAP.member?(id)
-          field_name = ID_MAP[id].name
-          if self.member?(field_name)
-            self[field_name].mergea(binstr[i, len + 4])
-          else
-            field_obj = ID_MAP[id].new(binstr[i, len + 4])
-            self[field_name] = field_obj
-          end
-        elsif id
-          unless self["Unknown"]
-            s = ""
-            class << s
-              alias_method :to_c_dir_bin, :to_s
-              alias_method :to_local_bin, :to_s
-            end
-            self["Unknown"] = s
-          end
-          if !len || len + 4 > binstr[i..-1].bytesize
-            self["Unknown"] << binstr[i..-1]
-            break
-          end
-          self["Unknown"] << binstr[i, len + 4]
-        end
-        i += len + 4
-      end
-    end
-
-    def create(name)
-      field_class = nil
-      ID_MAP.each { |id, klass|
-        if klass.name == name
-          field_class = klass
-          break
-        end
-      }
-      if ! field_class
-        raise ZipError, "Unknown extra field '#{name}'"
-      end
-      self[name] = field_class.new()
-    end
-
-    def to_local_bin
-      s = ""
-      each do |k, v|
-        s << v.to_local_bin
-      end
-      s
-    end
-    alias :to_s :to_local_bin
-
-    def to_c_dir_bin
-      s = ""
-      each do |k, v|
-        s << v.to_c_dir_bin
-      end
-      s
-    end
-
-    def c_dir_length
-      to_c_dir_bin.bytesize
-    end
-    def local_length
-      to_local_bin.bytesize
-    end
-    alias :c_dir_size :c_dir_length
-    alias :local_size :local_length
-    alias :length     :local_length
-    alias :size       :local_length
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/zip/zip_file.rb

@@ -1,340 +0,0 @@
-module Zip
-  # ZipFile is modeled after java.util.zip.ZipFile from the Java SDK.
-  # The most important methods are those inherited from
-  # ZipCentralDirectory for accessing information about the entries in
-  # the archive and methods such as get_input_stream and
-  # get_output_stream for reading from and writing entries to the
-  # archive. The class includes a few convenience methods such as
-  # #extract for extracting entries to the filesystem, and #remove,
-  # #replace, #rename and #mkdir for making simple modifications to
-  # the archive.
-  #
-  # Modifications to a zip archive are not committed until #commit or
-  # #close is called. The method #open accepts a block following
-  # the pattern from File.open offering a simple way to
-  # automatically close the archive when the block returns.
-  #
-  # The following example opens zip archive <code>my.zip</code>
-  # (creating it if it doesn't exist) and adds an entry
-  # <code>first.txt</code> and a directory entry <code>a_dir</code>
-  # to it.
-  #
-  #   require 'zip/zip'
-  #
-  #   Zip::ZipFile.open("my.zip", Zip::ZipFile::CREATE) {
-  #    |zipfile|
-  #     zipfile.get_output_stream("first.txt") { |f| f.puts "Hello from ZipFile" }
-  #     zipfile.mkdir("a_dir")
-  #   }
-  #
-  # The next example reopens <code>my.zip</code> writes the contents of
-  # <code>first.txt</code> to standard out and deletes the entry from
-  # the archive.
-  #
-  #   require 'zip/zip'
-  #
-  #   Zip::ZipFile.open("my.zip", Zip::ZipFile::CREATE) {
-  #     |zipfile|
-  #     puts zipfile.read("first.txt")
-  #     zipfile.remove("first.txt")
-  #   }
-  #
-  # ZipFileSystem offers an alternative API that emulates ruby's
-  # interface for accessing the filesystem, ie. the File and Dir classes.
-
-  class ZipFile < ZipCentralDirectory
-
-    CREATE = 1
-
-    attr_reader :name
-
-    # default -> false
-    attr_accessor :restore_ownership
-    # default -> false
-    attr_accessor :restore_permissions
-    # default -> true
-    attr_accessor :restore_times
-
-    # Opens a zip archive. Pass true as the second parameter to create
-    # a new archive if it doesn't exist already.
-    def initialize(fileName, create = nil, buffer = false)
-      super()
-      @name = fileName
-      @comment = ""
-      case
-        when ::File.exists?(fileName) && !buffer
-          ::File.open(name, "rb") do |f|
-            read_from_stream(f)
-          end
-        when create
-          @entrySet = ZipEntrySet.new
-        else
-          raise ZipError, "File #{fileName} not found"
-      end
-      @create = create
-      @storedEntries = @entrySet.dup
-      @storedComment = @comment
-      @restore_ownership = false
-      @restore_permissions = false
-      @restore_times = true
-    end
-
-    class << self
-      # 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(fileName, create = nil)
-        zf = ZipFile.new(fileName, create)
-        if block_given?
-          begin
-            yield zf
-          ensure
-            zf.close
-          end
-        else
-          zf
-        end
-      end
-
-      # Same as #open. But outputs data to a buffer instead of a file
-      def add_buffer
-        zf = ZipFile.new('', true, true)
-        yield zf
-        zf.write_buffer
-      end
-
-      # Like #open, but reads zip archive contents from a String or open IO
-      # stream, and outputs data to a buffer.
-      # (This can be used to extract data from a 
-      # downloaded zip archive without first saving it to disk.)
-      def open_buffer(io)
-        zf = ZipFile.new('',true,true)
-        if io.is_a? IO
-          zf.read_from_stream(io)
-        elsif io.is_a? String
-          require 'stringio'
-          zf.read_from_stream(StringIO.new(io))
-        else
-          raise "Zip::ZipFile.open_buffer expects an argument of class String or IO. Found: #{io.class}"
-        end
-        yield zf
-        zf.write_buffer
-      end
-
-      # Iterates over the contents of the ZipFile. This is more efficient
-      # than using a ZipInputStream since this methods simply iterates
-      # through the entries in the central directory structure in the archive
-      # whereas ZipInputStream jumps through the entire archive accessing the
-      # local entry headers (which contain the same information as the
-      # central directory).
-      def foreach(aZipFileName, &block)
-        open(aZipFileName) do |zipFile|
-          zipFile.each(&block)
-        end
-      end
-    end
-
-  # Returns the zip files comment, if it has one
-    attr_accessor :comment
-
-    # 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.
-    def get_input_stream(entry, &aProc)
-      get_entry(entry).get_input_stream(&aProc)
-    end
-
-    # Returns an output 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.
-    def get_output_stream(entry, permissionInt = nil, &aProc)
-      newEntry = entry.kind_of?(ZipEntry) ? entry : ZipEntry.new(@name, entry.to_s)
-      if newEntry.directory?
-        raise ArgumentError,
-          "cannot open stream to directory entry - '#{newEntry}'"
-      end
-      newEntry.unix_perms = permissionInt
-      zipStreamableEntry = ZipStreamableStream.new(newEntry)
-      @entrySet << zipStreamableEntry
-      zipStreamableEntry.get_output_stream(&aProc)
-    end
-
-    # Returns the name of the zip archive
-    def to_s
-      @name
-    end
-
-    # Returns a string containing the contents of the specified entry
-    def read(entry)
-      get_input_stream(entry) { |is| is.read }
-    end
-
-    # Convenience method for adding the contents of a file to the archive
-    def add(entry, srcPath, &continueOnExistsProc)
-      continueOnExistsProc ||= proc { Zip.options[:continue_on_exists_proc] }
-      check_entry_exists(entry, continueOnExistsProc, "add")
-      newEntry = entry.kind_of?(ZipEntry) ? entry : ZipEntry.new(@name, entry.to_s)
-      newEntry.gather_fileinfo_from_srcpath(srcPath)
-      @entrySet << newEntry
-    end
-
-    # Removes the specified entry.
-    def remove(entry)
-      @entrySet.delete(get_entry(entry))
-    end
-
-    # Renames the specified entry.
-    def rename(entry, newName, &continueOnExistsProc)
-      foundEntry = get_entry(entry)
-      check_entry_exists(newName, continueOnExistsProc, "rename")
-      @entrySet.delete(foundEntry)
-      foundEntry.name = newName
-      @entrySet << foundEntry
-    end
-
-    # Replaces the specified entry with the contents of srcPath (from
-    # the file system).
-    def replace(entry, srcPath)
-      check_file(srcPath)
-      remove(entry)
-      add(entry, srcPath)
-    end
-
-    # Extracts entry to file destPath.
-    def extract(entry, destPath, &onExistsProc)
-      onExistsProc ||= proc { Zip.options[:on_exists_proc] }
-      foundEntry = get_entry(entry)
-      foundEntry.extract(destPath, &onExistsProc)
-    end
-
-    # Commits changes that has been made since the previous commit to
-    # the zip archive.
-    def commit
-      return if !commit_required?
-      on_success_replace(name) {
-        |tmpFile|
-        ZipOutputStream.open(tmpFile) {
-          |zos|
-
-          @entrySet.each {
-            |e|
-            e.write_to_zip_output_stream(zos)
-            e.dirty = false
-          }
-          zos.comment = comment
-        }
-        true
-      }
-      initialize(name)
-    end
-
-    # Write buffer write changes to buffer and return
-    def write_buffer
-      buffer = ZipOutputStream.write_buffer do |zos|
-        @entrySet.each { |e| e.write_to_zip_output_stream(zos) }
-        zos.comment = comment
-      end
-      return buffer
-    end
-
-    # Closes the zip file committing any changes that has been made.
-    def close
-      commit
-    end
-
-    # Returns true if any changes has been made to this archive since
-    # the previous commit
-    def commit_required?
-      @entrySet.each do |e|
-        return true if e.dirty
-      end
-      @comment != @storedComment || @entrySet != @storedEntries || @create == ZipFile::CREATE
-    end
-
-    # Searches for entry with the specified name. Returns nil if
-    # no entry is found. See also get_entry
-    def find_entry(entry_name)
-      @entrySet.find_entry(entry_name)
-    end
-
-    # Searches for entries given a glob
-    def glob(*args,&block)
-      @entrySet.glob(*args,&block)
-    end
-
-    # Searches for an entry just as find_entry, but throws Errno::ENOENT
-    # if no entry is found.
-    def get_entry(entry)
-      selectedEntry = find_entry(entry)
-      unless selectedEntry
-        raise Errno::ENOENT, entry
-      end
-      selectedEntry.restore_ownership = @restore_ownership
-      selectedEntry.restore_permissions = @restore_permissions
-      selectedEntry.restore_times = @restore_times
-      selectedEntry
-    end
-
-    # Creates a directory
-    def mkdir(entryName, permissionInt = 0755)
-      if find_entry(entryName)
-        raise Errno::EEXIST, "File exists - #{entryName}"
-      end
-      entryName = entryName.dup.to_s
-      entryName << '/' unless entryName.end_with?('/')
-      @entrySet << ZipStreamableDirectory.new(@name, entryName, nil, permissionInt)
-    end
-
-    private
-
-    def is_directory(newEntry, srcPath)
-      srcPathIsDirectory = ::File.directory?(srcPath)
-      if newEntry.is_directory && ! srcPathIsDirectory
-        raise ArgumentError,
-          "entry name '#{newEntry}' indicates directory entry, but "+
-          "'#{srcPath}' is not a directory"
-      elsif !newEntry.is_directory && srcPathIsDirectory
-        newEntry.name += "/"
-      end
-      newEntry.is_directory && srcPathIsDirectory
-    end
-
-    def check_entry_exists(entryName, continueOnExistsProc, procedureName)
-      continueOnExistsProc ||= proc { Zip.options[:continue_on_exists_proc] }
-      if @entrySet.include?(entryName)
-        if continueOnExistsProc.call
-          remove get_entry(entryName)
-        else
-          raise ZipEntryExistsError,
-            procedureName + " failed. Entry #{entryName} already exists"
-        end
-      end
-    end
-
-    def check_file(path)
-      unless ::File.readable?(path)
-        raise Errno::ENOENT, path
-      end
-    end
-
-    def on_success_replace(aFilename)
-      tmpfile = get_tempfile
-      tmpFilename = tmpfile.path
-      tmpfile.close
-      if yield tmpFilename
-        ::File.rename(tmpFilename, name)
-      end
-    end
-
-    def get_tempfile
-      tempFile = Tempfile.new(::File.basename(name), ::File.dirname(name))
-      tempFile.binmode
-      tempFile
-    end
-
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/zip/zip_input_stream.rb

@@ -1,144 +0,0 @@
-module Zip
-  # ZipInputStream is the basic class for reading zip entries in a 
-  # zip file. It is possible to create a ZipInputStream object directly, 
-  # passing the zip file name to the constructor, but more often than not 
-  # the ZipInputStream will be obtained from a ZipFile (perhaps using the 
-  # ZipFileSystem interface) object for a particular entry in the zip 
-  # archive.
-  #
-  # A ZipInputStream inherits IOExtras::AbstractInputStream in order
-  # to provide an IO-like interface for reading from a single zip 
-  # entry. Beyond methods for mimicking an IO-object it contains 
-  # the method get_next_entry for iterating through the entries of 
-  # an archive. get_next_entry returns a ZipEntry object that describes
-  # the zip entry the ZipInputStream is currently reading from.
-  #
-  # Example that creates a zip archive with ZipOutputStream and reads it 
-  # back again with a ZipInputStream.
-  #
-  #   require 'zip/zip'
-  #   
-  #   Zip::ZipOutputStream::open("my.zip") { 
-  #     |io|
-  #   
-  #     io.put_next_entry("first_entry.txt")
-  #     io.write "Hello world!"
-  #   
-  #     io.put_next_entry("adir/first_entry.txt")
-  #     io.write "Hello again!"
-  #   }
-  #
-  #   
-  #   Zip::ZipInputStream::open("my.zip") {
-  #     |io|
-  #   
-  #     while (entry = io.get_next_entry)
-  #       puts "Contents of #{entry.name}: '#{io.read}'"
-  #     end
-  #   }
-  #
-  # java.util.zip.ZipInputStream is the original inspiration for this 
-  # class.
-
-  class ZipInputStream 
-    include IOExtras::AbstractInputStream
-
-    # Opens the indicated zip file. An exception is thrown
-    # if the specified offset in the specified filename is
-    # not a local zip entry header.
-    def initialize(filename, offset = 0, io = nil)
-      super()
-      if (io.nil?) 
-        @archiveIO = ::File.open(filename, "rb")
-        @archiveIO.seek(offset, IO::SEEK_SET)
-      else
-        @archiveIO = io
-      end
-      @decompressor = NullDecompressor.instance
-      @currentEntry = nil
-    end
-    
-    def close
-      @archiveIO.close
-    end
-
-    # Same as #initialize but if a block is passed the opened
-    # stream is passed to the block and closed when the block
-    # returns.    
-    def ZipInputStream.open(filename)
-      return new(filename) unless block_given?
-      
-      zio = new(filename)
-      yield zio
-    ensure
-      zio.close if zio
-    end
-
-    def ZipInputStream.open_buffer(io)
-      return new('',0,io) unless block_given?
-      zio = new('',0,io)
-      yield zio
-    ensure
-      zio.close if zio
-    end
-
-    # Returns a ZipEntry object. It is necessary to call this
-    # method on a newly created ZipInputStream before reading from 
-    # the first entry in the archive. Returns nil when there are 
-    # no more entries.
-
-    def get_next_entry
-      @archiveIO.seek(@currentEntry.next_header_offset, IO::SEEK_SET) if @currentEntry
-      open_entry
-    end
-
-    # Rewinds the stream to the beginning of the current entry
-    def rewind
-      return if @currentEntry.nil?
-      @lineno = 0
-      @archiveIO.seek(@currentEntry.localHeaderOffset, 
-		      IO::SEEK_SET)
-      open_entry
-    end
-
-    # Modeled after IO.sysread
-    def sysread(numberOfBytes = nil, buf = nil)
-      @decompressor.sysread(numberOfBytes, buf)
-    end
-
-    def eof
-      @outputBuffer.empty? && @decompressor.eof
-    end
-    alias :eof? :eof
-
-    protected
-
-    def open_entry
-      @currentEntry = ZipEntry.read_local_entry(@archiveIO)
-      if @currentEntry.nil?
-	      @decompressor = NullDecompressor.instance
-      elsif @currentEntry.compression_method == ZipEntry::STORED
-	      @decompressor = PassThruDecompressor.new(@archiveIO, @currentEntry.size)
-      elsif @currentEntry.compression_method == ZipEntry::DEFLATED
-	      @decompressor = Inflater.new(@archiveIO)
-      else
-	      raise ZipCompressionMethodError,
-              "Unsupported compression method #{@currentEntry.compression_method}"
-      end
-      flush
-      return @currentEntry
-    end
-
-    def produce_input
-      @decompressor.produce_input
-    end
-
-    def input_finished?
-      @decompressor.input_finished?
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.