rubyzip 0.9.9 → 1.0.0.beta1

data/lib/zip/entry_set.rb

@@ -0,0 +1,86 @@
+module Zip
+  class EntrySet #:nodoc:all
+    include Enumerable
+    attr_accessor :entry_set, :entry_order
+
+    def initialize(an_enumerable = [])
+      super()
+      @entry_set   = {}
+      @entry_order = []
+      an_enumerable.each { |o| push(o) }
+    end
+
+    def include?(entry)
+      @entry_set.include?(to_key(entry))
+    end
+
+    def find_entry(entry)
+      @entry_set[to_key(entry)]
+    end
+
+    def <<(entry)
+      @entry_order.delete(to_key(entry))
+      @entry_order << to_key(entry)
+      @entry_set[to_key(entry)] = entry
+    end
+
+    alias :push :<<
+
+    def size
+      @entry_set.size
+    end
+
+    alias :length :size
+
+    def delete(entry)
+      if @entry_order.delete(to_key(entry)) && @entry_set.delete(to_key(entry))
+        entry
+      else
+        nil
+      end
+    end
+
+    def each(&block)
+      @entry_order.each do |key|
+        block.call @entry_set[key]
+      end
+    end
+
+    def entries
+      @entry_order.map { |key| @entry_set[key] }
+    end
+
+    # deep clone
+    def dup
+      EntrySet.new(@entry_order.map { |key| @entry_set[key].dup })
+    end
+
+    def ==(other)
+      return false unless other.kind_of?(EntrySet)
+      @entry_set == other.entry_set && @entry_order == other.entry_order
+    end
+
+    def parent(entry)
+      @entry_set[to_key(entry.parent_as_string)]
+    end
+
+    def glob(pattern, flags = ::File::FNM_PATHNAME|::File::FNM_DOTMATCH)
+      entries.map do |entry|
+        next nil unless ::File.fnmatch(pattern, entry.name.chomp('/'), flags)
+        yield(entry) if block_given?
+        entry
+      end.compact
+    end
+
+    protected
+
+    private
+    def to_key(entry)
+      entry.to_s.sub(/\/$/, '')
+    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/errors.rb

@@ -0,0 +1,8 @@
+module Zip
+  class ZipError < StandardError; end
+  class ZipEntryExistsError < ZipError; end
+  class ZipDestinationFileExistsError < ZipError; end
+  class ZipCompressionMethodError < ZipError; end
+  class ZipEntryNameError < ZipError; end
+  class ZipInternalError < ZipError; end
+end

data/lib/zip/extra_field.rb

@@ -0,0 +1,90 @@
+module Zip
+  class ExtraField < Hash
+    ID_MAP = {}
+
+    def initialize(binstr = nil)
+      binstr and merge(binstr)
+    end
+
+    def extra_field_type_exist(binstr, id, len, i)
+      field_name = ID_MAP[id].name
+      if self.member?(field_name)
+        self[field_name].merge(binstr[i, len + 4])
+      else
+        field_obj        = ID_MAP[id].new(binstr[i, len + 4])
+        self[field_name] = field_obj
+      end
+    end
+
+    def extra_field_type_unknown(binstr, len, i)
+      create_unknown_item unless self['Unknown']
+      if !len || len + 4 > binstr[i..-1].bytesize
+        self['Unknown'] << binstr[i..-1]
+        return
+      end
+      self['Unknown'] << binstr[i, len + 4]
+    end
+
+    def create_unknown_item
+      s = ''
+      class << s
+        alias_method :to_c_dir_bin, :to_s
+        alias_method :to_local_bin, :to_s
+      end
+      self['Unknown'] = s
+    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').first
+        if id && ID_MAP.member?(id)
+          extra_field_type_exist(binstr, id, len, i)
+        elsif id
+          create_unknown_item unless self['Unknown']
+          break unless extra_field_type_unknown(binstr, len, i)
+        end
+        i += len + 4
+      end
+    end
+
+    def create(name)
+      unless field_class = ID_MAP.values.find { |k| k.name == name }
+        raise ZipError, "Unknown extra field '#{name}'"
+      end
+      self[name] = field_class.new
+    end
+
+    def to_local_bin
+      self.map { |_, v| v.to_local_bin }.join
+    end
+
+    alias :to_s :to_local_bin
+
+    def to_c_dir_bin
+      self.map { |_, v| v.to_c_dir_bin }.join
+    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
+
+require 'zip/extra_field/generic'
+require 'zip/extra_field/universal_time'
+require 'zip/extra_field/unix'
+# 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/extra_field/generic.rb

@@ -0,0 +1,43 @@
+module Zip
+  class ExtraField::Generic
+    def self.register_map
+      if self.const_defined?(:HEADER_ID)
+        ::Zip::ExtraField::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
+end

data/lib/zip/extra_field/universal_time.rb

@@ -0,0 +1,47 @@
+module Zip
+  # Info-ZIP Additional timestamp field
+  class ExtraField::UniversalTime < ExtraField::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 ||= ::Zip::DOSTime.at(mtime)
+      atime and @atime ||= ::Zip::DOSTime.at(atime)
+      ctime and @ctime ||= ::Zip::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
+end

data/lib/zip/extra_field/unix.rb

@@ -0,0 +1,39 @@
+module Zip
+  # Info-ZIP Extra for UNIX uid/gid
+  class ExtraField::IUnix < ExtraField::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
+
+end

data/lib/zip/{zip_file.rb → file.rb}

@@ -42,9 +42,13 @@ module Zip
   # ZipFileSystem offers an alternative API that emulates ruby's
   # interface for accessing the filesystem, ie. the File and Dir classes.
 
-  class ZipFile < ZipCentralDirectory
+  class File < CentralDirectory
 
-    CREATE = 1
+    CREATE           = 1
+    SPLIT_SIGNATURE  = 0x08074b50
+    MAX_SEGMENT_SIZE = 3221225472
+    MIN_SEGMENT_SIZE = 65536
+    DATA_BUFFER_SIZE = 8192
 
     attr_reader :name
 
@@ -59,24 +63,25 @@ module Zip
     # a new archive if it doesn't exist already.
     def initialize(fileName, create = nil, buffer = false)
       super()
-      @name = fileName
+      @name    = fileName
       @comment = ""
+      @create = create
       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"
+      when ::File.exists?(fileName) && !buffer
+        @create = nil
+        ::File.open(name, "rb") do |f|
+          read_from_stream(f)
+        end
+      when create
+        @entry_set = EntrySet.new
+      else
+        raise ZipError, "File #{fileName} not found"
       end
-      @create = create
-      @storedEntries = @entrySet.dup
-      @storedComment = @comment
-      @restore_ownership = false
+      @storedEntries       = @entry_set.dup
+      @storedComment       = @comment
+      @restore_ownership   = false
       @restore_permissions = false
-      @restore_times = true
+      @restore_times       = true
     end
 
     class << self
@@ -84,7 +89,7 @@ module Zip
       # 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)
+        zf = ::Zip::File.new(fileName, create)
         if block_given?
           begin
             yield zf
@@ -98,7 +103,7 @@ module Zip
 
       # Same as #open. But outputs data to a buffer instead of a file
       def add_buffer
-        zf = ZipFile.new('', true, true)
+        zf = ::Zip::File.new('', true, true)
         yield zf
         zf.write_buffer
       end
@@ -108,7 +113,7 @@ module Zip
       # (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)
+        zf = ::Zip::File.new('', true, true)
         if io.is_a? IO
           zf.read_from_stream(io)
         elsif io.is_a? String
@@ -132,9 +137,83 @@ module Zip
           zipFile.each(&block)
         end
       end
+
+      def get_segment_size_for_split(segment_size)
+        case
+        when MIN_SEGMENT_SIZE > segment_size
+          MIN_SEGMENT_SIZE
+        when MAX_SEGMENT_SIZE < segment_size
+          MAX_SEGMENT_SIZE
+        else
+          segment_size
+        end
+      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?
+        partial_zip_file_name ||= zip_file_name
+        partial_zip_file_name
+      end
+
+      def get_segment_count_for_split(zip_file_size, segment_size)
+        (zip_file_size / segment_size).to_i + (zip_file_size % segment_size == 0 ? 0 : 1)
+      end
+
+      def put_split_signature(szip_file, segment_size)
+        signature_packed = [SPLIT_SIGNATURE].pack('V')
+        szip_file << signature_packed
+        segment_size - signature_packed.size
+      end
+
+      #
+      # TODO: Make the code more understandable
+      #
+      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)}"
+        ::File.open(szip_file_name, 'wb') do |szip_file|
+          if szip_file_index == 1
+            ssegment_size = put_split_signature(szip_file, segment_size)
+          end
+          chunk_bytes = 0
+          until ssegment_size == chunk_bytes || zip_file.eof?
+            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
+            szip_file << chunk
+            # Info for track splitting
+            yield segment_count, szip_file_index, chunk_bytes, ssegment_size if block_given?
+          end
+        end
+      end
+
+      # Splits an archive into parts with segment size
+      def split(zip_file_name, segment_size = MAX_SEGMENT_SIZE, delete_zip_file = true, partial_zip_file_name = nil)
+        raise ZipError, "File #{zip_file_name} not found" unless ::File.exists?(zip_file_name)
+        raise Errno::ENOENT, zip_file_name unless ::File.readable?(zip_file_name)
+        zip_file_size = ::File.size(zip_file_name)
+        segment_size  = get_segment_size_for_split(segment_size)
+        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) {}
+        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|
+          until zip_file.eof?
+            szip_file_index += 1
+            save_splited_part(zip_file, partial_zip_file_name, zip_file_size, szip_file_index, segment_size, segment_count)
+          end
+        end
+        ::File.delete(zip_file_name) if delete_zip_file
+        szip_file_index
+      end
     end
 
-  # Returns the zip files comment, if it has one
+    # 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
@@ -148,14 +227,14 @@ module Zip
     # 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)
+      newEntry = entry.kind_of?(Entry) ? entry : Entry.new(@name, entry.to_s)
       if newEntry.directory?
         raise ArgumentError,
-          "cannot open stream to directory entry - '#{newEntry}'"
+              "cannot open stream to directory entry - '#{newEntry}'"
       end
       newEntry.unix_perms = permissionInt
-      zipStreamableEntry = ZipStreamableStream.new(newEntry)
-      @entrySet << zipStreamableEntry
+      zipStreamableEntry  = StreamableStream.new(newEntry)
+      @entry_set << zipStreamableEntry
       zipStreamableEntry.get_output_stream(&aProc)
     end
 
@@ -170,26 +249,26 @@ module Zip
     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)
+    def add(entry, srcPath, &continue_on_exists_proc)
+      continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc }
+      check_entry_exists(entry, continue_on_exists_proc, "add")
+      newEntry = entry.kind_of?(Entry) ? entry : Entry.new(@name, entry.to_s)
       newEntry.gather_fileinfo_from_srcpath(srcPath)
-      @entrySet << newEntry
+      @entry_set << newEntry
     end
 
     # Removes the specified entry.
     def remove(entry)
-      @entrySet.delete(get_entry(entry))
+      @entry_set.delete(get_entry(entry))
     end
 
     # Renames the specified entry.
-    def rename(entry, newName, &continueOnExistsProc)
+    def rename(entry, new_name, &continue_on_exists_proc)
       foundEntry = get_entry(entry)
-      check_entry_exists(newName, continueOnExistsProc, "rename")
-      @entrySet.delete(foundEntry)
-      foundEntry.name = newName
-      @entrySet << foundEntry
+      check_entry_exists(new_name, continue_on_exists_proc, 'rename')
+      @entry_set.delete(foundEntry)
+      foundEntry.name = new_name
+      @entry_set << foundEntry
     end
 
     # Replaces the specified entry with the contents of srcPath (from
@@ -200,11 +279,11 @@ module Zip
       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)
+    # Extracts entry to file dest_path.
+    def extract(entry, dest_path, &block)
+      block       ||= proc { ::Zip.on_exists_proc }
+      found_entry = get_entry(entry)
+      found_entry.extract(dest_path, &block)
     end
 
     # Commits changes that has been made since the previous commit to
@@ -213,10 +292,10 @@ module Zip
       return if !commit_required?
       on_success_replace(name) {
         |tmpFile|
-        ZipOutputStream.open(tmpFile) {
+        OutputStream.open(tmpFile) {
           |zos|
 
-          @entrySet.each {
+          @entry_set.each {
             |e|
             e.write_to_zip_output_stream(zos)
             e.dirty = false
@@ -230,8 +309,8 @@ module Zip
 
     # 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) }
+      buffer = OutputStream.write_buffer do |zos|
+        @entry_set.each { |e| e.write_to_zip_output_stream(zos) }
         zos.comment = comment
       end
       return buffer
@@ -245,21 +324,21 @@ module Zip
     # Returns true if any changes has been made to this archive since
     # the previous commit
     def commit_required?
-      @entrySet.each do |e|
+      @entry_set.each do |e|
         return true if e.dirty
       end
-      @comment != @storedComment || @entrySet != @storedEntries || @create == ZipFile::CREATE
+      @comment != @storedComment || @entry_set != @storedEntries || @create == File::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)
+      @entry_set.find_entry(entry_name)
     end
 
     # Searches for entries given a glob
-    def glob(*args,&block)
-      @entrySet.glob(*args,&block)
+    def glob(*args, &block)
+      @entry_set.glob(*args, &block)
     end
 
     # Searches for an entry just as find_entry, but throws Errno::ENOENT
@@ -269,9 +348,9 @@ module Zip
       unless selectedEntry
         raise Errno::ENOENT, entry
       end
-      selectedEntry.restore_ownership = @restore_ownership
+      selectedEntry.restore_ownership   = @restore_ownership
       selectedEntry.restore_permissions = @restore_permissions
-      selectedEntry.restore_times = @restore_times
+      selectedEntry.restore_times       = @restore_times
       selectedEntry
     end
 
@@ -282,31 +361,31 @@ module Zip
       end
       entryName = entryName.dup.to_s
       entryName << '/' unless entryName.end_with?('/')
-      @entrySet << ZipStreamableDirectory.new(@name, entryName, nil, permissionInt)
+      @entry_set << StreamableDirectory.new(@name, entryName, nil, permissionInt)
     end
 
     private
 
     def is_directory(newEntry, srcPath)
       srcPathIsDirectory = ::File.directory?(srcPath)
-      if newEntry.is_directory && ! srcPathIsDirectory
+      if newEntry.is_directory && !srcPathIsDirectory
         raise ArgumentError,
-          "entry name '#{newEntry}' indicates directory entry, but "+
-          "'#{srcPath}' is not a directory"
+              "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
+    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 ZipEntryExistsError,
-            procedureName + " failed. Entry #{entryName} already exists"
+                procedureName + " failed. Entry #{entryName} already exists"
         end
       end
     end
@@ -318,7 +397,7 @@ module Zip
     end
 
     def on_success_replace(aFilename)
-      tmpfile = get_tempfile
+      tmpfile     = get_tempfile
       tmpFilename = tmpfile.path
       tmpfile.close
       if yield tmpFilename