hotplate 0.1.1 → 1.0.0

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/input_stream.rb

@@ -1,164 +0,0 @@
-module Zip
-  # InputStream is the basic class for reading zip entries in a
-  # zip file. It is possible to create a InputStream object directly,
-  # passing the zip file name to the constructor, but more often than not
-  # the InputStream will be obtained from a File (perhaps using the
-  # ZipFileSystem interface) object for a particular entry in the zip
-  # archive.
-  #
-  # A InputStream 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 Entry object that describes
-  # the zip entry the InputStream is currently reading from.
-  #
-  # Example that creates a zip archive with ZipOutputStream and reads it
-  # back again with a InputStream.
-  #
-  #   require 'zip'
-  #
-  #   Zip::OutputStream.open("my.zip") do |io|
-  #
-  #     io.put_next_entry("first_entry.txt")
-  #     io.write "Hello world!"
-  #
-  #     io.put_next_entry("adir/first_entry.txt")
-  #     io.write "Hello again!"
-  #   end
-  #
-  #
-  #   Zip::InputStream.open("my.zip") do |io|
-  #
-  #     while (entry = io.get_next_entry)
-  #       puts "Contents of #{entry.name}: '#{io.read}'"
-  #     end
-  #   end
-  #
-  # java.util.zip.ZipInputStream is the original inspiration for this
-  # class.
-
-  class InputStream
-    include ::Zip::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.
-    #
-    # @param context [String||IO||StringIO] file path or IO/StringIO object
-    # @param offset [Integer] offset in the IO/StringIO
-    def initialize(context, offset = 0, decrypter = nil)
-      super()
-      @archive_io = get_io(context, offset)
-      @decompressor  = ::Zip::NullDecompressor
-      @decrypter     = decrypter || ::Zip::NullDecrypter.new
-      @current_entry = nil
-    end
-
-    def close
-      @archive_io.close
-    end
-
-    # Returns a Entry object. It is necessary to call this
-    # method on a newly created InputStream before reading from
-    # the first entry in the archive. Returns nil when there are
-    # no more entries.
-    def get_next_entry
-      @archive_io.seek(@current_entry.next_header_offset, IO::SEEK_SET) if @current_entry
-      open_entry
-    end
-
-    # Rewinds the stream to the beginning of the current entry
-    def rewind
-      return if @current_entry.nil?
-      @lineno = 0
-      @pos    = 0
-      @archive_io.seek(@current_entry.local_header_offset, IO::SEEK_SET)
-      open_entry
-    end
-
-    # Modeled after IO.sysread
-    def sysread(number_of_bytes = nil, buf = nil)
-      @decompressor.sysread(number_of_bytes, buf)
-    end
-
-    def eof
-      @output_buffer.empty? && @decompressor.eof
-    end
-
-    alias :eof? :eof
-
-    class << self
-      # Same as #initialize but if a block is passed the opened
-      # stream is passed to the block and closed when the block
-      # returns.
-      def open(filename_or_io, offset = 0, decrypter = nil)
-        zio = self.new(filename_or_io, offset, decrypter)
-        return zio unless block_given?
-        begin
-          yield zio
-        ensure
-          zio.close if zio
-        end
-      end
-
-      def open_buffer(filename_or_io, offset = 0)
-        puts "open_buffer is deprecated!!! Use open instead!"
-        self.open(filename_or_io, offset)
-      end
-    end
-
-    protected
-
-    def get_io(io_or_file, offset = 0)
-      case io_or_file
-      when IO, StringIO
-        io = io_or_file.dup
-        io.seek(offset, ::IO::SEEK_SET)
-        io
-      else
-        file = ::File.open(io_or_file, 'rb')
-        file.seek(offset, ::IO::SEEK_SET)
-        file
-      end
-    end
-
-    def open_entry
-      @current_entry = ::Zip::Entry.read_local_entry(@archive_io)
-      if @current_entry and @current_entry.gp_flags & 1 == 1 and @decrypter.is_a? NullEncrypter
-        raise Error, 'password required to decode zip file'
-      end
-      @decompressor  = get_decompressor
-      flush
-      @current_entry
-    end
-
-    def get_decompressor
-      case
-      when @current_entry.nil?
-        ::Zip::NullDecompressor
-      when @current_entry.compression_method == ::Zip::Entry::STORED
-        ::Zip::PassThruDecompressor.new(@archive_io, @current_entry.size)
-      when @current_entry.compression_method == ::Zip::Entry::DEFLATED
-        header = @archive_io.read(@decrypter.header_bytesize)
-        @decrypter.reset!(header)
-        ::Zip::Inflater.new(@archive_io, @decrypter)
-      else
-        raise ::Zip::CompressionMethodError,
-              "Unsupported compression method #{@current_entry.compression_method}"
-      end
-    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.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/ioextras/abstract_input_stream.rb

@@ -1,115 +0,0 @@
-module Zip
-  module IOExtras
-    # 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
-
-      attr_accessor :lineno
-      attr_reader :pos
-
-      def read(number_of_bytes = nil, buf = '')
-        tbuf = if @output_buffer.bytesize > 0
-                 if number_of_bytes <= @output_buffer.bytesize
-                   @output_buffer.slice!(0, number_of_bytes)
-                 else
-                   number_of_bytes -= @output_buffer.bytesize if number_of_bytes
-                   rbuf = sysread(number_of_bytes, buf)
-                   out  = @output_buffer
-                   out << rbuf if rbuf
-                   @output_buffer = ''
-                   out
-                 end
-               else
-                 sysread(number_of_bytes, buf)
-               end
-
-        if tbuf.nil? || tbuf.length == 0
-          return nil if number_of_bytes
-          return ""
-        end
-
-        @pos += tbuf.length
-
-        if buf
-          buf.replace(tbuf)
-        else
-          buf = tbuf
-        end
-        buf
-      end
-
-      def readlines(a_sep_string = $/)
-        ret_val = []
-        each_line(a_sep_string) { |line| ret_val << line }
-        ret_val
-      end
-
-      def gets(a_sep_string = $/, number_of_bytes = nil)
-        @lineno = @lineno.next
-
-        if number_of_bytes.respond_to?(:to_int)
-          number_of_bytes = number_of_bytes.to_int
-          a_sep_string = a_sep_string.to_str if a_sep_string
-        elsif a_sep_string.respond_to?(:to_int)
-          number_of_bytes = a_sep_string.to_int
-          a_sep_string    = $/
-        else
-          number_of_bytes = nil
-          a_sep_string = a_sep_string.to_str if a_sep_string
-        end
-
-        return read(number_of_bytes) if a_sep_string.nil?
-        a_sep_string = "#{$/}#{$/}" if a_sep_string.empty?
-
-        buffer_index = 0
-        over_limit   = (number_of_bytes && @output_buffer.bytesize >= number_of_bytes)
-        while (match_index = @output_buffer.index(a_sep_string, buffer_index)).nil? && !over_limit
-          buffer_index = [buffer_index, @output_buffer.bytesize - a_sep_string.bytesize].max
-          if input_finished?
-            return @output_buffer.empty? ? nil : flush
-          end
-          @output_buffer << produce_input
-          over_limit = (number_of_bytes && @output_buffer.bytesize >= number_of_bytes)
-        end
-        sep_index = [match_index + a_sep_string.bytesize, number_of_bytes || @output_buffer.bytesize].min
-        @pos     += sep_index
-        return @output_buffer.slice!(0...sep_index)
-      end
-
-      def ungetc(byte)
-        @output_buffer = byte.chr + @output_buffer
-      end
-
-      def flush
-        ret_val        = @output_buffer
-        @output_buffer = ''
-        ret_val
-      end
-
-      def readline(a_sep_string = $/)
-        ret_val = gets(a_sep_string)
-        raise EOFError unless ret_val
-        ret_val
-      end
-
-      def each_line(a_sep_string = $/)
-        while true
-          yield readline(a_sep_string)
-        end
-      rescue EOFError
-      end
-
-      alias_method :each, :each_line
-    end
-  end
-end

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/ioextras/abstract_output_stream.rb

@@ -1,45 +0,0 @@
-module Zip
-  module IOExtras
-    # 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 print(*params)
-        self << params.join($,) << $\.to_s
-      end
-
-      def printf(a_format_string, *params)
-        self << sprintf(a_format_string, *params)
-      end
-
-      def putc(an_object)
-        self << case an_object
-                when Fixnum
-                  an_object.chr
-                when String
-                  an_object
-                else
-                  raise TypeError, 'putc: Only Fixnum and String supported'
-                end
-        an_object
-      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"
-        end
-      end
-
-    end
-  end
-end

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/ioextras.rb

@@ -1,38 +0,0 @@
-module Zip
-  module IOExtras #:nodoc:
-
-    CHUNK_SIZE = 131072
-
-    RANGE_ALL = 0..-1
-
-    class << self
-      def copy_stream(ostream, istream)
-        ostream.write(istream.read(CHUNK_SIZE, '')) until istream.eof?
-      end
-
-      def copy_stream_n(ostream, istream, nbytes)
-        toread = nbytes
-        while toread > 0 && !istream.eof?
-          tr = toread > CHUNK_SIZE ? CHUNK_SIZE : toread
-          ostream.write(istream.read(tr, ''))
-          toread -= tr
-        end
-      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
-
-  end # IOExtras namespace module
-end
-
-require 'zip/ioextras/abstract_input_stream'
-require 'zip/ioextras/abstract_output_stream'
-
-# Copyright (C) 2002-2004 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/null_compressor.rb

@@ -1,15 +0,0 @@
-module Zip
-  class NullCompressor < Compressor #:nodoc:all
-    include Singleton
-
-    def <<(data)
-      raise IOError, "closed stream"
-    end
-
-    attr_reader :size, :compressed_size
-  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/hotplate/gems/rubyzip-1.1.7/lib/zip/null_decompressor.rb

@@ -1,27 +0,0 @@
-module Zip
-  module NullDecompressor #:nodoc:all
-    extend self
-
-    def sysread(numberOfBytes = nil, buf = nil)
-      nil
-    end
-
-    def produce_input
-      nil
-    end
-
-    def input_finished?
-      true
-    end
-
-    def eof
-      true
-    end
-
-    alias :eof? :eof
-  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/hotplate/gems/rubyzip-1.1.7/lib/zip/null_input_stream.rb

@@ -1,10 +0,0 @@
-module Zip
-  module NullInputStream #:nodoc:all
-    include ::Zip::NullDecompressor
-    include ::Zip::IOExtras::AbstractInputStream
-  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/hotplate/gems/rubyzip-1.1.7/lib/zip/output_stream.rb

@@ -1,190 +0,0 @@
-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(file_name, stream=false, encrypter=nil)
-      super()
-      @file_name = file_name
-      @output_stream = if stream
-                         iostream = @file_name.dup
-                         iostream.reopen(@file_name)
-                         iostream.rewind
-                         iostream
-                       else
-                         ::File.new(@file_name, "wb")
-                       end
-      @entry_set = ::Zip::EntrySet.new
-      @compressor = ::Zip::NullCompressor.instance
-      @encrypter = encrypter || ::Zip::NullEncrypter.new
-      @closed = false
-      @current_entry = 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(file_name, encrypter = nil)
-        return new(file_name) unless block_given?
-        zos = new(file_name, false, encrypter)
-        yield zos
-      ensure
-        zos.close if zos
-      end
-
-      # Same as #open but writes to a filestream instead
-      def write_buffer(io = ::StringIO.new(''), encrypter = nil)
-        zos = new(io, true, encrypter)
-        yield zos
-        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(entry_name, comment = nil, extra = nil, compression_method = Entry::DEFLATED, level = Zip.default_compression)
-      raise Error, "zip stream is closed" if @closed
-      if entry_name.kind_of?(Entry)
-        new_entry = entry_name
-      else
-        new_entry = Entry.new(@file_name, entry_name.to_s)
-      end
-      new_entry.comment = comment unless comment.nil?
-      unless extra.nil?
-        new_entry.extra = ExtraField === extra ? extra : ExtraField.new(extra.to_s)
-      end
-      new_entry.compression_method = compression_method unless compression_method.nil?
-      init_next_entry(new_entry, level)
-      @current_entry = new_entry
-    end
-
-    def copy_raw_entry(entry)
-      entry = entry.dup
-      raise Error, "zip stream is closed" if @closed
-      raise Error, "entry is not a ZipEntry" unless entry.is_a?(Entry)
-      finalize_current_entry
-      @entry_set << entry
-      src_pos = entry.local_header_offset
-      entry.write_local_entry(@output_stream)
-      @compressor = NullCompressor.instance
-      entry.get_raw_input_stream do |is|
-        is.seek(src_pos, IO::SEEK_SET)
-        ::Zip::Entry.read_local_entry(is)
-        IOExtras.copy_stream_n(@output_stream, is, entry.compressed_size)
-      end
-      @compressor = NullCompressor.instance
-      @current_entry = nil
-    end
-
-    private
-
-    def finalize_current_entry
-      return unless @current_entry
-      @output_stream << @encrypter.header(@current_entry.mtime)
-      finish
-      @current_entry.compressed_size = @output_stream.tell - @current_entry.local_header_offset - @current_entry.calculate_local_header_size
-      @current_entry.size = @compressor.size
-      @current_entry.crc = @compressor.crc
-      @output_stream << @encrypter.data_descriptor(@current_entry.crc, @current_entry.compressed_size, @current_entry.size)
-      @current_entry.gp_flags |= @encrypter.gp_flags
-      @current_entry = nil
-      @compressor = ::Zip::NullCompressor.instance
-    end
-
-    def init_next_entry(entry, level = Zip.default_compression)
-      finalize_current_entry
-      @entry_set << entry
-      entry.write_local_entry(@output_stream)
-      @encrypter.reset!
-      @compressor = get_compressor(entry, level)
-    end
-
-    def get_compressor(entry, level)
-      case entry.compression_method
-      when Entry::DEFLATED then
-        ::Zip::Deflater.new(@output_stream, level, @encrypter)
-      when Entry::STORED then
-        ::Zip::PassThruCompressor.new(@output_stream)
-      else
-        raise ::Zip::CompressionMethodError,
-              "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, true)
-      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
-      self
-    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/hotplate/gems/rubyzip-1.1.7/lib/zip/pass_thru_compressor.rb

@@ -1,23 +0,0 @@
-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/hotplate/gems/rubyzip-1.1.7/lib/zip/pass_thru_decompressor.rb

@@ -1,41 +0,0 @@
-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 = '')
-      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/hotplate/gems/rubyzip-1.1.7/lib/zip/streamable_directory.rb

@@ -1,15 +0,0 @@
-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.