superp-rubyzip 0.1.0

data/lib/zip/output_stream.rb

@@ -0,0 +1,175 @@
+module Zip
+  # ZipOutputStream is the basic class for writing zip files. It is
+  # possible to create a ZipOutputStream object directly, passing
+  # the zip file name to the constructor, but more often than not
+  # the ZipOutputStream will be obtained from a ZipFile (perhaps using the
+  # ZipFileSystem interface) object for a particular entry in the zip
+  # archive.
+  #
+  # A ZipOutputStream inherits IOExtras::AbstractOutputStream in order
+  # to provide an IO-like interface for writing to a single zip
+  # entry. Beyond methods for mimicking an IO-object it contains
+  # the method put_next_entry that closes the current entry
+  # and creates a new.
+  #
+  # Please refer to ZipInputStream for example code.
+  #
+  # java.util.zip.ZipOutputStream is the original inspiration for this
+  # class.
+
+  class OutputStream
+    include ::Zip::IOExtras::AbstractOutputStream
+
+    attr_accessor :comment
+
+    # Opens the indicated zip file. If a file with that name already
+    # exists it will be overwritten.
+    def initialize(fileName, stream=false)
+      super()
+      @fileName = fileName
+      if stream
+        @output_stream = ::StringIO.new
+      else
+        @output_stream = ::File.new(@fileName, "wb")
+      end
+      @entry_set = ::Zip::EntrySet.new
+      @compressor = ::Zip::NullCompressor.instance
+      @closed = false
+      @currentEntry = nil
+      @comment = nil
+    end
+
+    # Same as #initialize but if a block is passed the opened
+    # stream is passed to the block and closed when the block
+    # returns.
+    class << self
+      def open(fileName)
+        return new(fileName) unless block_given?
+        zos = new(fileName)
+        yield zos
+      ensure
+        zos.close if zos
+      end
+
+	    # Same as #open but writes to a filestream instead
+      def write_buffer
+        zos = new('', true)
+        yield zos
+        return zos.close_buffer
+      end
+    end
+
+    # Closes the stream and writes the central directory to the zip file
+    def close
+      return if @closed
+      finalize_current_entry
+      update_local_headers
+      write_central_directory
+      @output_stream.close
+      @closed = true
+    end
+
+    # Closes the stream and writes the central directory to the zip file
+    def close_buffer
+      return @output_stream if @closed
+      finalize_current_entry
+      update_local_headers
+      write_central_directory
+      @closed = true
+      @output_stream
+    end
+
+	  # Closes the current entry and opens a new for writing.
+    # +entry+ can be a ZipEntry object or a string.
+    def put_next_entry(entryname, comment = nil, extra = nil, compression_method = Entry::DEFLATED,  level = Zlib::DEFAULT_COMPRESSION)
+      raise ZipError, "zip stream is closed" if @closed
+      if entryname.kind_of?(Entry)
+        new_entry = entryname
+      else
+        new_entry = Entry.new(@fileName, entryname.to_s)
+      end
+      new_entry.comment = comment if !comment.nil?
+      if (!extra.nil?)
+        new_entry.extra = ExtraField === extra ? extra : ExtraField.new(extra.to_s)
+      end
+      new_entry.compression_method = compression_method if !compression_method.nil?
+      init_next_entry(new_entry, level)
+      @currentEntry = new_entry
+    end
+
+    def copy_raw_entry(entry)
+      entry = entry.dup
+      raise ZipError, "zip stream is closed" if @closed
+      raise ZipError, "entry is not a ZipEntry" if !entry.kind_of?(Entry)
+      finalize_current_entry
+      @entry_set << entry
+      src_pos = entry.local_entry_offset
+      entry.write_local_entry(@output_stream)
+      @compressor = NullCompressor.instance
+      entry.get_raw_input_stream do |is|
+        is.seek(src_pos, IO::SEEK_SET)
+        IOExtras.copy_stream_n(@output_stream, is, entry.compressed_size)
+      end
+      @compressor = NullCompressor.instance
+      @currentEntry = nil
+    end
+
+    private
+
+    def finalize_current_entry
+      return unless @currentEntry
+      finish
+      @currentEntry.compressed_size = @output_stream.tell - @currentEntry.local_header_offset - @currentEntry.calculate_local_header_size
+      @currentEntry.size = @compressor.size
+      @currentEntry.crc = @compressor.crc
+      @currentEntry = nil
+      @compressor = NullCompressor.instance
+    end
+
+    def init_next_entry(entry, level = Zlib::DEFAULT_COMPRESSION)
+      finalize_current_entry
+      @entry_set << entry
+      entry.write_local_entry(@output_stream)
+      @compressor = get_compressor(entry, level)
+    end
+
+    def get_compressor(entry, level)
+      case entry.compression_method
+        when Entry::DEFLATED then Deflater.new(@output_stream, level)
+        when Entry::STORED   then PassThruCompressor.new(@output_stream)
+      else raise ZipCompressionMethodError,
+        "Invalid compression method: '#{entry.compression_method}'"
+      end
+    end
+
+    def update_local_headers
+      pos = @output_stream.pos
+      @entry_set.each do |entry|
+        @output_stream.pos = entry.local_header_offset
+        entry.write_local_entry(@output_stream)
+      end
+      @output_stream.pos = pos
+    end
+
+    def write_central_directory
+      cdir = CentralDirectory.new(@entry_set, @comment)
+      cdir.write_to_stream(@output_stream)
+    end
+
+    protected
+
+    def finish
+      @compressor.finish
+    end
+
+    public
+    # Modeled after IO.<<
+    def << (data)
+      @compressor << data
+    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/pass_thru_compressor.rb

@@ -0,0 +1,23 @@
+module Zip
+  class PassThruCompressor < Compressor #:nodoc:all
+    def initialize(outputStream)
+      super()
+      @output_stream = outputStream
+      @crc = Zlib::crc32
+      @size = 0
+    end
+    
+    def << (data)
+      val = data.to_s
+      @crc = Zlib::crc32(val, @crc)
+      @size += val.bytesize
+      @output_stream << val
+    end
+
+    attr_reader :size, :crc
+  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/pass_thru_decompressor.rb

@@ -0,0 +1,41 @@
+module Zip
+  class PassThruDecompressor < Decompressor  #:nodoc:all
+
+    def initialize(input_stream, chars_to_read)
+      super(input_stream)
+      @chars_to_read = chars_to_read
+      @read_so_far = 0
+      @has_returned_empty_string = false
+    end
+
+    def sysread(number_of_bytes = nil, buf = nil)
+      if input_finished?
+        has_returned_empty_string_val = @has_returned_empty_string
+        @has_returned_empty_string = true
+        return '' unless has_returned_empty_string_val
+        return
+      end
+
+      if (number_of_bytes == nil || @read_so_far + number_of_bytes > @chars_to_read)
+        number_of_bytes = @chars_to_read - @read_so_far
+      end
+      @read_so_far += number_of_bytes
+      @input_stream.read(number_of_bytes, buf)
+    end
+
+    def produce_input
+      sysread(::Zip::Decompressor::CHUNK_SIZE)
+    end
+
+    def input_finished?
+      @read_so_far >= @chars_to_read
+    end
+
+    alias :eof :input_finished?
+    alias :eof? :input_finished?
+  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/streamable_directory.rb

@@ -0,0 +1,15 @@
+module Zip
+  class StreamableDirectory < Entry
+    def initialize(zipfile, entry, srcPath = nil, permissionInt = nil)
+      super(zipfile, entry)
+
+      @ftype = :directory
+      entry.get_extra_attributes_from_path(srcPath) if (srcPath)
+      @unix_perms = permissionInt if (permissionInt)
+    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/streamable_stream.rb

@@ -0,0 +1,47 @@
+module Zip
+  class StreamableStream < DelegateClass(Entry) #nodoc:all
+    def initialize(entry)
+      super(entry)
+      @tempFile = Tempfile.new(::File.basename(name), ::File.dirname(zipfile))
+      @tempFile.binmode
+    end
+
+    def get_output_stream
+      if block_given?
+        begin
+          yield(@tempFile)
+        ensure
+          @tempFile.close
+        end
+      else
+        @tempFile
+      end
+    end
+
+    def get_input_stream
+      if ! @tempFile.closed?
+        raise StandardError, "cannot open entry for reading while its open for writing - #{name}"
+      end
+      @tempFile.open # reopens tempfile from top
+      @tempFile.binmode
+      if block_given?
+        begin
+          yield(@tempFile)
+        ensure
+          @tempFile.close
+        end
+      else
+        @tempFile
+      end
+    end
+    
+    def write_to_zip_output_stream(aZipOutputStream)
+      aZipOutputStream.put_next_entry(self)
+      get_input_stream { |is| ::Zip::IOExtras.copy_stream(aZipOutputStream, is) }
+    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/version.rb

@@ -0,0 +1,3 @@
+module Zip
+  VERSION = '0.1.0'
+end

data/samples/example.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+$: << "../lib"
+system("zip example.zip example.rb gtkRubyzip.rb")
+
+require 'zip/zip'
+
+####### Using ZipInputStream alone: #######
+
+Zip::InputStream.open("example.zip") {
+  |zis|
+  entry = zis.get_next_entry
+  print "First line of '#{entry.name} (#{entry.size} bytes):  "
+  puts "'#{zis.gets.chomp}'"
+  entry = zis.get_next_entry
+  print "First line of '#{entry.name} (#{entry.size} bytes):  "
+  puts "'#{zis.gets.chomp}'"
+}
+
+
+####### Using ZipFile to read the directory of a zip file: #######
+
+zf = Zip::File.new("example.zip")
+zf.each_with_index {
+  |entry, index|
+  
+  puts "entry #{index} is #{entry.name}, size = #{entry.size}, compressed size = #{entry.compressed_size}"
+  # use zf.get_input_stream(entry) to get a ZipInputStream for the entry
+  # entry can be the ZipEntry object or any object which has a to_s method that
+  # returns the name of the entry.
+}
+
+
+####### Using ZipOutputStream to write a zip file: #######
+
+Zip::OutputStream.open("exampleout.zip") {
+  |zos|
+  zos.put_next_entry("the first little entry")
+  zos.puts "Hello hello hello hello hello hello hello hello hello"
+
+  zos.put_next_entry("the second little entry")
+  zos.puts "Hello again"
+
+  # Use rubyzip or your zip client of choice to verify
+  # the contents of exampleout.zip
+}
+
+####### Using ZipFile to change a zip file: #######
+
+Zip::File.open("exampleout.zip") {
+  |zf|
+  zf.add("thisFile.rb", "example.rb")
+  zf.rename("thisFile.rb", "ILikeThisName.rb")
+  zf.add("Again", "example.rb")
+}
+
+# Lets check
+Zip::File.open("exampleout.zip") {
+  |zf|
+  puts "Changed zip file contains: #{zf.entries.join(', ')}"
+  zf.remove("Again")
+  puts "Without 'Again': #{zf.entries.join(', ')}"
+}
+
+####### Using ZipFile to split a zip file: #######
+
+# Creating large zip file for splitting
+Zip::OutputStream.open("large_zip_file.zip") do |zos|
+  puts "Creating zip file..."
+  10.times do |i|
+    zos.put_next_entry("large_entry_#{i}.txt")
+    zos.puts "Hello" * 104857600
+  end
+end
+
+# Splitting created large zip file
+part_zips_count = Zip::File.split("large_zip_file.zip", 2097152, false)
+puts "Zip file splitted in #{part_zips_count} parts"
+
+# Track splitting an archive
+Zip::File.split("large_zip_file.zip", 1048576, true, 'part_zip_file') do
+  |part_count, part_index, chunk_bytes, segment_bytes|
+  puts "#{part_index} of #{part_count} part splitting: #{(chunk_bytes.to_f/segment_bytes.to_f * 100).to_i}%"
+end
+
+
+# For other examples, look at zip.rb and ziptest.rb
+
+# Copyright (C) 2002 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/samples/example_filesystem.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+$: << "../lib"
+
+require 'zip/zipfilesystem'
+
+EXAMPLE_ZIP = "filesystem.zip"
+
+File.delete(EXAMPLE_ZIP) if File.exists?(EXAMPLE_ZIP)
+
+Zip::File.open(EXAMPLE_ZIP, Zip::File::CREATE) {
+  |zf|
+  zf.file.open("file1.txt", "w") { |os| os.write "first file1.txt" }
+  zf.dir.mkdir("dir1")
+  zf.dir.chdir("dir1")
+  zf.file.open("file1.txt", "w") { |os| os.write "second file1.txt" }
+  puts zf.file.read("file1.txt")
+  puts zf.file.read("../file1.txt")
+  zf.dir.chdir("..")
+  zf.file.open("file2.txt", "w") { |os| os.write "first file2.txt" }
+  puts "Entries:                   #{zf.entries.join(', ')}"
+}
+
+Zip::File.open(EXAMPLE_ZIP) {
+  |zf|
+  puts "Entries from reloaded zip: #{zf.entries.join(', ')}"
+}
+
+# For other examples, look at zip.rb and ziptest.rb
+
+# Copyright (C) 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/samples/example_recursive.rb

@@ -0,0 +1,49 @@
+require 'zip/zip'
+
+# This is a simple example which uses rubyzip to
+# recursively generate a zip file from the contents of
+# a specified directory. The directory itself is not
+# included in the archive, rather just its contents.
+#
+# Usage:
+#   directoryToZip = "/tmp/input"
+#   outputFile = "/tmp/out.zip"   
+#   zf = ZipFileGenerator.new(directoryToZip, outputFile)
+#   zf.write()
+class ZipFileGenerator
+
+  # Initialize with the directory to zip and the location of the output archive.
+  def initialize(inputDir, outputFile)
+    @inputDir = inputDir
+    @outputFile = outputFile
+  end
+
+  # Zip the input directory.
+  def write()
+    entries = Dir.entries(@inputDir); entries.delete("."); entries.delete("..") 
+    io = Zip::File.open(@outputFile, Zip::File::CREATE);
+
+    writeEntries(entries, "", io)
+    io.close();
+  end
+
+  # A helper method to make the recursion work.
+  private
+  def writeEntries(entries, path, io)
+    
+    entries.each { |e|
+      zipFilePath = path == "" ? e : File.join(path, e)
+      diskFilePath = File.join(@inputDir, zipFilePath)
+      puts "Deflating " + diskFilePath
+      if  File.directory?(diskFilePath)
+        io.mkdir(zipFilePath)
+        subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..") 
+        writeEntries(subdir, zipFilePath, io)
+      else
+        io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read())}
+      end
+    }
+  end
+    
+end
+