hotplate 0.0.1

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

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

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

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

@@ -0,0 +1,63 @@
+require 'delegate'
+require 'singleton'
+require 'tempfile'
+require 'fileutils'
+require 'stringio'
+require 'zlib'
+require 'zip/dos_time'
+require 'zip/ioextras'
+require 'rbconfig'
+require 'zip/entry'
+require 'zip/extra_field'
+require 'zip/entry_set'
+require 'zip/central_directory'
+require 'zip/file'
+require 'zip/input_stream'
+require 'zip/output_stream'
+require 'zip/decompressor'
+require 'zip/compressor'
+require 'zip/null_decompressor'
+require 'zip/null_compressor'
+require 'zip/null_input_stream'
+require 'zip/pass_thru_compressor'
+require 'zip/pass_thru_decompressor'
+require 'zip/crypto/encryption'
+require 'zip/crypto/null_encryption'
+require 'zip/crypto/traditional_encryption'
+require 'zip/inflater'
+require 'zip/deflater'
+require 'zip/streamable_stream'
+require 'zip/streamable_directory'
+require 'zip/constants'
+require 'zip/errors'
+if defined? JRUBY_VERSION
+  require 'jruby'
+  JRuby.objectspace = true
+end
+
+module Zip
+  extend self
+  attr_accessor :unicode_names, :on_exists_proc, :continue_on_exists_proc, :sort_entries, :default_compression, :write_zip64_support, :warn_invalid_date
+
+  def reset!
+    @_ran_once = false
+    @unicode_names = false
+    @on_exists_proc = false
+    @continue_on_exists_proc = false
+    @sort_entries = false
+    @default_compression = ::Zlib::DEFAULT_COMPRESSION
+    @write_zip64_support = false
+    @warn_invalid_date = true
+  end
+
+  def setup
+    yield self unless @_ran_once
+    @_ran_once = true
+  end
+
+  reset!
+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/samples/example.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+$: << "../lib"
+system("zip example.zip example.rb gtkRubyzip.rb")
+
+require '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/lib/hotplate/gems/rubyzip-1.1.7/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/lib/hotplate/gems/rubyzip-1.1.7/samples/example_recursive.rb

@@ -0,0 +1,48 @@
+require '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

data/lib/hotplate/gems/rubyzip-1.1.7/samples/gtkRubyzip.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+$: << "../lib"
+
+$VERBOSE = true
+
+require 'gtk'
+require 'zip'
+
+class MainApp < Gtk::Window
+  def initialize
+    super()
+    set_usize(400, 256)
+    set_title("rubyzip")
+    signal_connect(Gtk::Window::SIGNAL_DESTROY) { Gtk.main_quit }
+
+    box = Gtk::VBox.new(false, 0)
+    add(box)
+
+    @zipfile = nil
+    @buttonPanel = ButtonPanel.new
+    @buttonPanel.openButton.signal_connect(Gtk::Button::SIGNAL_CLICKED) {
+      show_file_selector
+    }
+    @buttonPanel.extractButton.signal_connect(Gtk::Button::SIGNAL_CLICKED) {
+      puts "Not implemented!"
+    }
+    box.pack_start(@buttonPanel, false, false, 0)
+
+    sw = Gtk::ScrolledWindow.new
+    sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
+    box.pack_start(sw, true, true, 0)
+
+    @clist = Gtk::CList.new(["Name", "Size", "Compression"])
+    @clist.set_selection_mode(Gtk::SELECTION_BROWSE)
+    @clist.set_column_width(0, 120)
+    @clist.set_column_width(1, 120)
+    @clist.signal_connect(Gtk::CList::SIGNAL_SELECT_ROW) {
+      |w, row, column, event|
+      @selected_row = row
+    }
+    sw.add(@clist)
+  end
+
+  class ButtonPanel < Gtk::HButtonBox
+    attr_reader :openButton, :extractButton
+    def initialize
+      super
+      set_layout(Gtk::BUTTONBOX_START)
+      set_spacing(0)
+      @openButton = Gtk::Button.new("Open archive")
+      @extractButton = Gtk::Button.new("Extract entry")
+      pack_start(@openButton)
+      pack_start(@extractButton)
+    end
+  end
+
+  def show_file_selector
+    @fileSelector = Gtk::FileSelection.new("Open zip file")
+    @fileSelector.show
+    @fileSelector.ok_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) {
+      open_zip(@fileSelector.filename)
+      @fileSelector.destroy
+    }
+    @fileSelector.cancel_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) {
+      @fileSelector.destroy
+    }
+  end
+
+  def open_zip(filename)
+    @zipfile = Zip::File.open(filename)
+    @clist.clear
+    @zipfile.each {
+      |entry|
+      @clist.append([ entry.name,
+		      entry.size.to_s,
+		      (100.0*entry.compressedSize/entry.size).to_s+"%" ])
+    }
+  end
+end
+
+mainApp = MainApp.new()
+
+mainApp.show_all
+
+Gtk.main

data/lib/hotplate/gems/rubyzip-1.1.7/samples/qtzip.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+$VERBOSE=true
+
+$: << "../lib"
+
+require 'Qt'
+system('rbuic -o zipdialogui.rb zipdialogui.ui')
+require 'zipdialogui.rb'
+require 'zip'
+
+
+
+a = Qt::Application.new(ARGV)
+
+class ZipDialog < ZipDialogUI
+
+
+  def initialize()
+    super()
+    connect(child('add_button'), SIGNAL('clicked()'),
+            self, SLOT('add_files()'))
+    connect(child('extract_button'), SIGNAL('clicked()'),
+            self, SLOT('extract_files()'))
+  end
+
+  def zipfile(&proc)
+    Zip::File.open(@zip_filename, &proc)
+  end
+
+  def each(&proc)
+    Zip::File.foreach(@zip_filename, &proc)
+  end
+
+  def refresh()
+    lv = child("entry_list_view")
+    lv.clear
+    each {
+      |e|
+      lv.insert_item(Qt::ListViewItem.new(lv, e.name, e.size.to_s))
+    }
+  end
+
+
+  def load(zipfile)
+    @zip_filename = zipfile
+    refresh
+  end
+
+  def add_files
+    l = Qt::FileDialog.getOpenFileNames(nil, nil, self)
+    zipfile {
+      |zf|
+      l.each {
+        |path|
+        zf.add(File.basename(path), path)
+      }
+    }
+    refresh
+  end
+
+  def extract_files
+    selected_items = []
+    unselected_items = []
+    lv_item = entry_list_view.first_child
+    while (lv_item)
+      if entry_list_view.is_selected(lv_item)
+        selected_items << lv_item.text(0)
+      else
+        unselected_items << lv_item.text(0)
+      end
+      lv_item = lv_item.next_sibling
+    end
+    puts "selected_items.size = #{selected_items.size}"
+    puts "unselected_items.size = #{unselected_items.size}"
+    items = selected_items.size > 0 ? selected_items : unselected_items
+    puts "items.size = #{items.size}"
+
+    d = Qt::FileDialog.get_existing_directory(nil, self)
+    if (!d)
+      puts "No directory chosen"
+    else
+      zipfile { |zf| items.each { |e| zf.extract(e, File.join(d, e)) } }
+    end
+
+  end
+
+  slots 'add_files()', 'extract_files()'
+end
+
+if !ARGV[0]
+  puts "usage: #{$0} zipname"
+  exit
+end
+
+zd = ZipDialog.new
+zd.load(ARGV[0])
+
+a.mainWidget = zd
+zd.show()
+a.exec()

data/lib/hotplate/gems/rubyzip-1.1.7/samples/write_simple.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$: << "../lib"
+
+require 'zip'
+
+include Zip
+
+OutputStream.open('simple.zip') {
+  |zos|
+  ze = zos.put_next_entry 'entry.txt'
+  zos.puts "Hello world"
+}

data/lib/hotplate/gems/rubyzip-1.1.7/samples/zipfind.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+$: << "../lib"
+
+require 'zip'
+require 'find'
+
+module Zip
+  module ZipFind
+    def self.find(path, zipFilePattern = /\.zip$/i)
+      Find.find(path) {
+	|fileName|
+	yield(fileName)
+	if zipFilePattern.match(fileName)  && File.file?(fileName)
+	  begin
+	    Zip::File.foreach(fileName)  {
+	      |zipEntry|
+	      yield(fileName + File::SEPARATOR + zipEntry.to_s)
+	    }
+	  rescue Errno::EACCES => ex
+	    puts ex
+	  end
+	end
+      }
+    end
+
+    def self.find_file(path, fileNamePattern, zipFilePattern = /\.zip$/i)
+      self.find(path, zipFilePattern) {
+	|fileName|
+	yield(fileName) if fileNamePattern.match(fileName)
+      }
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  module ZipFindConsoleRunner
+
+    PATH_ARG_INDEX = 0;
+    FILENAME_PATTERN_ARG_INDEX = 1;
+    ZIPFILE_PATTERN_ARG_INDEX = 2;
+
+    def self.run(args)
+      check_args(args)
+      Zip::ZipFind.find_file(args[PATH_ARG_INDEX],
+			    args[FILENAME_PATTERN_ARG_INDEX],
+			    args[ZIPFILE_PATTERN_ARG_INDEX]) {
+	|fileName|
+	report_entry_found fileName
+      }
+    end
+
+    def self.check_args(args)
+      if (args.size != 3)
+	usage
+	exit
+      end
+    end
+
+    def self.usage
+      puts "Usage: #{$0} PATH ZIPFILENAME_PATTERN FILNAME_PATTERN"
+    end
+
+    def self.report_entry_found(fileName)
+      puts fileName
+    end
+
+  end
+
+  ZipFindConsoleRunner.run(ARGV)
+end

data/lib/hotplate/gems/rubyzip-1.1.7/test/basic_zip_file_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class BasicZipFileTest < MiniTest::Test
+  include AssertEntry
+
+  def setup
+    @zip_file = ::Zip::File.new(TestZipFile::TEST_ZIP2.zip_name)
+    @testEntryNameIndex=0
+  end
+
+  def test_entries
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.sort,
+                 @zip_file.entries.entries.sort.map { |e| e.name })
+  end
+
+  def test_each
+    count = 0
+    visited = {}
+    @zip_file.each {
+        |entry|
+      assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    }
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_foreach
+    count = 0
+    visited = {}
+    ::Zip::File.foreach(TestZipFile::TEST_ZIP2.zip_name) {
+        |entry|
+      assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    }
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_get_input_stream
+    count = 0
+    visited = {}
+    @zip_file.each do |entry|
+      assert_entry(entry.name, @zip_file.get_input_stream(entry), entry.name)
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    end
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_get_input_streamBlock
+    fileAndEntryName = @zip_file.entries.first.name
+    @zip_file.get_input_stream(fileAndEntryName) {
+        |zis|
+      assert_entryContentsForStream(fileAndEntryName,
+                                    zis,
+                                    fileAndEntryName)
+    }
+  end
+
+end