rubyzip 0.9.9 → 1.0.0.beta1

data/lib/zip/{zipfilesystem.rb → filesystem.rb}

@@ -1,4 +1,4 @@
-require 'zip/zip'
+require 'zip'
 
 module Zip
 
@@ -14,9 +14,9 @@ module Zip
   # <code>first.txt</code>, a directory entry named <code>mydir</code>
   # and finally another normal entry named <code>second.txt</code>
   #
-  #   require 'zip/zipfilesystem'
+  #   require 'zip/filesystem'
   #   
-  #   Zip::ZipFile.open("my.zip", Zip::ZipFile::CREATE) {
+  #   Zip::File.open("my.zip", Zip::ZipFile::CREATE) {
   #     |zipfile|
   #     zipfile.file.open("first.txt", "w") { |f| f.puts "Hello world" }
   #     zipfile.dir.mkdir("mydir")
@@ -27,14 +27,14 @@ module Zip
   # example writes the contents of <code>first.txt</code> from zip archive
   # <code>my.zip</code> to standard out.
   #
-  #   require 'zip/zipfilesystem'
+  #   require 'zip/filesystem'
   #   
-  #   Zip::ZipFile.open("my.zip") {
+  #   Zip::File.open("my.zip") {
   #     |zipfile|
   #     puts zipfile.file.read("first.txt")
   #   }
 
-  module ZipFileSystem
+  module FileSystem
 
     def initialize # :nodoc:
       mappedZip = ZipFileNameMapper.new(self)
@@ -151,7 +151,7 @@ module Zip
         def mode
           e = get_entry
           if e.fstype == 3
-            e.externalFileAttributes >> 16
+            e.external_file_attributes >> 16
           else
             33206 # 33206 is equivalent to -rw-rw-rw-
           end
@@ -173,7 +173,7 @@ module Zip
       def unix_mode_cmp(fileName, mode)
         begin
           e = get_entry(fileName)
-          e.fstype == 3 && ((e.externalFileAttributes >> 16) & mode ) != 0
+          e.fstype == 3 && ((e.external_file_attributes >> 16) & mode ) != 0
         rescue Errno::ENOENT
           false
         end
@@ -272,7 +272,7 @@ module Zip
           e = get_entry(fileName)
           e.fstype = 3 # force convertion filesystem type to unix
           e.unix_perms = modeInt
-          e.externalFileAttributes = modeInt << 16
+          e.external_file_attributes = modeInt << 16
           e.dirty = true
         }
         filenames.size
@@ -392,7 +392,7 @@ module Zip
       end
 
       def popen(*args, &aProc)
-        File.popen(*args, &aProc)
+        ::File.popen(*args, &aProc)
       end
 
       def foreach(fileName, aSep = $/, &aProc)
@@ -612,8 +612,8 @@ module Zip
     end
   end
 
-  class ZipFile
-    include ZipFileSystem
+  class File
+    include FileSystem
   end
 end
 

data/lib/zip/inflater.rb

@@ -1,36 +1,37 @@
 module Zip
-  class Inflater < Decompressor  #:nodoc:all
-    def initialize(inputStream)
+  class Inflater < Decompressor #:nodoc:all
+    def initialize(input_stream)
       super
-      @zlibInflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
-      @outputBuffer=""
-      @hasReturnedEmptyString = ! EMPTY_FILE_RETURNS_EMPTY_STRING_FIRST
+      @zlib_inflater           = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
+      @output_buffer           = ''
+      @has_returned_empty_string = false
     end
 
-    def sysread(numberOfBytes = nil, buf = nil)
-      readEverything = numberOfBytes.nil?
-      while (readEverything || @outputBuffer.bytesize < numberOfBytes)
+    def sysread(number_of_bytes = nil, buf = nil)
+      readEverything = number_of_bytes.nil?
+      while (readEverything || @output_buffer.bytesize < number_of_bytes)
         break if internal_input_finished?
-        @outputBuffer << internal_produce_input(buf)
+        @output_buffer << internal_produce_input(buf)
       end
-      return value_when_finished if @outputBuffer.bytesize == 0 && input_finished?
-      endIndex = numberOfBytes.nil? ? @outputBuffer.bytesize : numberOfBytes
-      return @outputBuffer.slice!(0...endIndex)
+      return value_when_finished if @output_buffer.bytesize == 0 && input_finished?
+      end_index = number_of_bytes.nil? ? @output_buffer.bytesize : number_of_bytes
+      @output_buffer.slice!(0...end_index)
     end
 
     def produce_input
-      if (@outputBuffer.empty?)
-        return internal_produce_input
+      if (@output_buffer.empty?)
+        internal_produce_input
       else
-        return @outputBuffer.slice!(0...(@outputBuffer.length))
+        @output_buffer.slice!(0...(@output_buffer.length))
       end
     end
 
     # to be used with produce_input, not read (as read may still have more data cached)
     # is data cached anywhere other than @outputBuffer?  the comment above may be wrong
     def input_finished?
-      @outputBuffer.empty? && internal_input_finished?
+      @output_buffer.empty? && internal_input_finished?
     end
+
     alias :eof :input_finished?
     alias :eof? :input_finished?
 
@@ -39,23 +40,22 @@ module Zip
     def internal_produce_input(buf = nil)
       retried = 0
       begin
-        @zlibInflater.inflate(@inputStream.read(Decompressor::CHUNK_SIZE, buf))
+        @zlib_inflater.inflate(@input_stream.read(Decompressor::CHUNK_SIZE, buf))
       rescue Zlib::BufError
-        raise if (retried >= 5) # how many times should we retry?
+        raise if retried >= 5 # how many times should we retry?
         retried += 1
         retry
       end
     end
 
     def internal_input_finished?
-      @zlibInflater.finished?
+      @zlib_inflater.finished?
     end
 
-    # TODO: Specialize to handle different behaviour in ruby > 1.7.0 ?
-    def value_when_finished   # mimic behaviour of ruby File object.
-      return if @hasReturnedEmptyString
-      @hasReturnedEmptyString = true
-      return ""
+    def value_when_finished # mimic behaviour of ruby File object.
+      return if @has_returned_empty_string
+      @has_returned_empty_string = true
+      ''
     end
   end
 end

data/lib/zip/{zip_input_stream.rb → input_stream.rb}

@@ -40,8 +40,8 @@ module Zip
   # java.util.zip.ZipInputStream is the original inspiration for this 
   # class.
 
-  class ZipInputStream 
-    include IOExtras::AbstractInputStream
+  class InputStream
+    include ::Zip::IOExtras::AbstractInputStream
 
     # Opens the indicated zip file. An exception is thrown
     # if the specified offset in the specified filename is
@@ -65,7 +65,7 @@ module Zip
     # 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)
+    def InputStream.open(filename)
       return new(filename) unless block_given?
       
       zio = new(filename)
@@ -74,7 +74,7 @@ module Zip
       zio.close if zio
     end
 
-    def ZipInputStream.open_buffer(io)
+    def InputStream.open_buffer(io)
       return new('',0,io) unless block_given?
       zio = new('',0,io)
       yield zio
@@ -96,7 +96,8 @@ module Zip
     def rewind
       return if @currentEntry.nil?
       @lineno = 0
-      @archiveIO.seek(@currentEntry.localHeaderOffset, 
+      @pos = 0
+      @archiveIO.seek(@currentEntry.local_header_offset,
 		      IO::SEEK_SET)
       open_entry
     end
@@ -107,19 +108,19 @@ module Zip
     end
 
     def eof
-      @outputBuffer.empty? && @decompressor.eof
+      @output_buffer.empty? && @decompressor.eof
     end
     alias :eof? :eof
 
     protected
 
     def open_entry
-      @currentEntry = ZipEntry.read_local_entry(@archiveIO)
+      @currentEntry = Entry.read_local_entry(@archiveIO)
       if @currentEntry.nil?
 	      @decompressor = NullDecompressor.instance
-      elsif @currentEntry.compression_method == ZipEntry::STORED
+      elsif @currentEntry.compression_method == Entry::STORED
 	      @decompressor = PassThruDecompressor.new(@archiveIO, @currentEntry.size)
-      elsif @currentEntry.compression_method == ZipEntry::DEFLATED
+      elsif @currentEntry.compression_method == Entry::DEFLATED
 	      @decompressor = Inflater.new(@archiveIO)
       else
 	      raise ZipCompressionMethodError,
@@ -141,4 +142,4 @@ 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.
+# modify it under the terms of the ruby license.

data/lib/zip/ioextras.rb

@@ -1,163 +1,185 @@
-module IOExtras  #:nodoc:
+module Zip
+  module IOExtras #:nodoc:
 
-  CHUNK_SIZE = 131072
+    CHUNK_SIZE = 131072
 
-  RANGE_ALL = 0..-1
+    RANGE_ALL = 0..-1
 
-  def self.copy_stream(ostream, istream)
-    s = ''
-    ostream.write(istream.read(CHUNK_SIZE, s)) until istream.eof? 
-  end
+    def self.copy_stream(ostream, istream)
+      s = ''
+      ostream.write(istream.read(CHUNK_SIZE, s)) until istream.eof?
+    end
 
-  def self.copy_stream_n(ostream, istream, nbytes)
-    s = ''
-    toread = nbytes
-    while (toread > 0 && ! istream.eof?) 
-      tr = toread > CHUNK_SIZE ? CHUNK_SIZE : toread
-      ostream.write(istream.read(tr, s))
-      toread -= tr
-    end 
-  end
+    def self.copy_stream_n(ostream, istream, nbytes)
+      s      = ''
+      toread = nbytes
+      while (toread > 0 && !istream.eof?)
+        tr = toread > CHUNK_SIZE ? CHUNK_SIZE : toread
+        ostream.write(istream.read(tr, s))
+        toread -= tr
+      end
+    end
 
 
-  # Implements kind_of? in order to pretend to be an IO object
-  module FakeIO
-    def kind_of?(object)
-      object == IO || super
-    end
-  end
-
-  # Implements many of the convenience methods of IO
-  # such as gets, getc, readline and readlines 
-  # depends on: input_finished?, produce_input and read
-  module AbstractInputStream  
-    include Enumerable
-    include FakeIO
-
-    def initialize
-      super
-      @lineno = 0
-      @outputBuffer = ""
+    # Implements kind_of? in order to pretend to be an IO object
+    module FakeIO
+      def kind_of?(object)
+        object == IO || super
+      end
     end
 
-    attr_accessor :lineno
-
-    def read(numberOfBytes = nil, buf = nil)
-      tbuf = nil
+    # Implements many of the convenience methods of IO
+    # such as gets, getc, readline and readlines
+    # depends on: input_finished?, produce_input and read
+    module AbstractInputStream
+      include Enumerable
+      include FakeIO
+
+      def initialize
+        super
+        @lineno        = 0
+        @pos           = 0
+        @output_buffer = ""
+      end
 
-      if @outputBuffer.bytesize > 0
-        if numberOfBytes <= @outputBuffer.bytesize
-          tbuf = @outputBuffer.slice!(0, numberOfBytes)
+      attr_accessor :lineno
+      attr_reader :pos
+
+      def read(numberOfBytes = nil, buf = nil)
+        tbuf = nil
+
+        if @output_buffer.bytesize > 0
+          if numberOfBytes <= @output_buffer.bytesize
+            tbuf = @output_buffer.slice!(0, numberOfBytes)
+          else
+            numberOfBytes -= @output_buffer.bytesize if (numberOfBytes)
+            rbuf = sysread(numberOfBytes, buf)
+            tbuf = @output_buffer
+            tbuf << rbuf if (rbuf)
+            @output_buffer = ""
+          end
         else
-          numberOfBytes -= @outputBuffer.bytesize if (numberOfBytes)
-          rbuf = sysread(numberOfBytes, buf)
-          tbuf = @outputBuffer
-          tbuf << rbuf if (rbuf)
-          @outputBuffer = ""
+          tbuf = sysread(numberOfBytes, buf)
         end
-      else
-        tbuf = sysread(numberOfBytes, buf)
-      end
 
-      return nil unless (tbuf)
+        @pos += tbuf.length
 
-      if buf
-        buf.replace(tbuf)
-      else
-        buf = tbuf
-      end
+        return nil unless (tbuf)
 
-      buf
-    end
-
-    def readlines(aSepString = $/)
-      retVal = []
-      each_line(aSepString) { |line| retVal << line }
-      retVal
-    end
+        if buf
+          buf.replace(tbuf)
+        else
+          buf = tbuf
+        end
 
-    def gets(aSepString = $/)
-      @lineno = @lineno.next
-      return read if aSepString.nil?
-      aSepString = "#{$/}#{$/}" if aSepString.empty?
+        buf
+      end
 
-      bufferIndex = 0
-      while ((matchIndex = @outputBuffer.index(aSepString, bufferIndex)) == nil)
-        bufferIndex = @outputBuffer.bytesize
-        if input_finished?
-          return @outputBuffer.empty? ? nil : flush
-        end
-        @outputBuffer << produce_input
+      def readlines(aSepString = $/)
+        retVal = []
+        each_line(aSepString) { |line| retVal << line }
+        retVal
       end
-      sepIndex = matchIndex + aSepString.bytesize
-      return @outputBuffer.slice!(0...sepIndex)
-    end
 
-    def flush
-      retVal = @outputBuffer
-      @outputBuffer=""
-      return retVal
-    end
+      def gets(aSepString = $/, numberOfBytes = nil)
+        @lineno = @lineno.next
 
-    def readline(aSepString = $/)
-      retVal = gets(aSepString)
-      raise EOFError if retVal == nil
-      retVal
-    end
+        if numberOfBytes.respond_to?(:to_int)
+          numberOfBytes = numberOfBytes.to_int
+          aSepString = aSepString.to_str if aSepString
+        elsif aSepString.respond_to?(:to_int)
+          numberOfBytes = aSepString.to_int
+          aSepString    = $/
+        else
+          numberOfBytes = nil
+          aSepString = aSepString.to_str if aSepString
+        end
 
-    def each_line(aSepString = $/)
-      while true
-        yield readline(aSepString)
+        return read(numberOfBytes) if aSepString.nil?
+        aSepString = "#{$/}#{$/}" if aSepString.empty?
+
+        bufferIndex = 0
+        overLimit   = (numberOfBytes && @output_buffer.bytesize >= numberOfBytes)
+        while ((matchIndex = @output_buffer.index(aSepString, bufferIndex)) == nil && !overLimit)
+          bufferIndex = [bufferIndex, @output_buffer.bytesize - aSepString.bytesize].max
+          if input_finished?
+            return @output_buffer.empty? ? nil : flush
+          end
+          @output_buffer << produce_input
+          overLimit = (numberOfBytes && @output_buffer.bytesize >= numberOfBytes)
+        end
+        sepIndex = [matchIndex + aSepString.bytesize, numberOfBytes || @output_buffer.bytesize].min
+        @pos     += sepIndex
+        return @output_buffer.slice!(0...sepIndex)
       end
-    rescue EOFError
-    end
 
-    alias_method :each, :each_line
-  end
+      def flush
+        retVal        = @output_buffer
+        @output_buffer=""
+        return retVal
+      end
 
+      def readline(aSepString = $/)
+        retVal = gets(aSepString)
+        raise EOFError if retVal == nil
+        retVal
+      end
 
-  # Implements many of the output convenience methods of IO.
-  # relies on <<
-  module AbstractOutputStream 
-    include FakeIO
+      def each_line(aSepString = $/)
+        while true
+          yield readline(aSepString)
+        end
+      rescue EOFError
+      end
 
-    def write(data)
-      self << data
-      data.to_s.bytesize
+      alias_method :each, :each_line
     end
 
 
-    def print(*params)
-      self << params.join($,) << $\.to_s
-    end
+    # Implements many of the output convenience methods of IO.
+    # relies on <<
+    module AbstractOutputStream
+      include FakeIO
+
+      def write(data)
+        self << data
+        data.to_s.bytesize
+      end
 
-    def printf(aFormatString, *params)
-      self << sprintf(aFormatString, *params)
-    end
 
-    def putc(anObject)
-      self << case anObject
-      when Fixnum then anObject.chr
-      when String then anObject
-      else raise TypeError, "putc: Only Fixnum and String supported"
+      def print(*params)
+        self << params.join($,) << $\.to_s
       end
-      anObject
-    end
 
-    def puts(*params)
-      params << "\n" if params.empty?
-      params.flatten.each do |element|
-        val = element.to_s
-        self << val
-        self << "\n" unless val[-1,1] == "\n"
+      def printf(aFormatString, *params)
+        self << sprintf(aFormatString, *params)
       end
-    end
 
-  end
+      def putc(anObject)
+        self << case anObject
+                when Fixnum then
+                  anObject.chr
+                when String then
+                  anObject
+                else
+                  raise TypeError, "putc: Only Fixnum and String supported"
+                end
+        anObject
+      end
 
-end # IOExtras namespace module
+      def puts(*params)
+        params << "\n" if params.empty?
+        params.flatten.each do |element|
+          val = element.to_s
+          self << val
+          self << "\n" unless val[-1, 1] == "\n"
+        end
+      end
 
+    end
 
+  end # IOExtras namespace module
+end
 
 # Copyright (C) 2002-2004 Thomas Sondergaard
 # rubyzip is free software; you can redistribute it and/or