rubyzip 0.9.1 → 0.9.4

data/test/ziptest.rb

@@ -5,6 +5,7 @@ $VERBOSE = true
 $: << "../lib"
 
 require 'test/unit'
+require 'fileutils'
 require 'zip/zip'
 require 'gentestfiles'
 
@@ -631,6 +632,23 @@ class ZipOutputStreamTest < Test::Unit::TestCase
     end
   end
 
+  def test_put_next_entry
+    stored_text = "hello world in stored text"
+    entry_name = "file1"
+    comment = "my comment"
+    ZipOutputStream.open(TEST_ZIP.zip_name) do
+      |zos|
+      zos.put_next_entry(entry_name, comment, nil, ZipEntry::STORED)
+      zos << stored_text
+    end
+
+    assert(File.read(TEST_ZIP.zip_name).grep(stored_text))
+    ZipFile.open(TEST_ZIP.zip_name) do
+      |zf|
+      assert_equal(stored_text, zf.read(entry_name))
+    end
+  end
+
   def assert_i_o_error_in_closed_stream
     assert_raise(IOError) {
       zos = ZipOutputStream.new("test_putOnClosedStream.zip")
@@ -1016,7 +1034,7 @@ module CommonZipFileFixture
 
   def setup
     File.delete(EMPTY_FILENAME) if File.exists?(EMPTY_FILENAME)
-    File.copy(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
+    FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
   end
 end
 
@@ -1126,7 +1144,7 @@ class ZipFileTest < Test::Unit::TestCase
   def test_remove
     entryToRemove, *remainingEntries = TEST_ZIP.entry_names
 
-    File.copy(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
+    FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
 
     zf = ZipFile.new(TEST_ZIP.zip_name)
     assert(zf.entries.map { |e| e.name }.include?(entryToRemove))
@@ -1141,24 +1159,27 @@ class ZipFileTest < Test::Unit::TestCase
     zfRead.close
   end
 
-
   def test_rename
     entryToRename, *remainingEntries = TEST_ZIP.entry_names
-    
+
     zf = ZipFile.new(TEST_ZIP.zip_name)
     assert(zf.entries.map { |e| e.name }.include?(entryToRename))
-    
-    newName = "changed name"
+
+    contents = zf.read(entryToRename)
+    newName = "changed entry name"
     assert(! zf.entries.map { |e| e.name }.include?(newName))
 
     zf.rename(entryToRename, newName)
     assert(zf.entries.map { |e| e.name }.include?(newName))
 
+    assert_equal(contents, zf.read(newName))
+
     zf.close
 
     zfRead = ZipFile.new(TEST_ZIP.zip_name)
     assert(zfRead.entries.map { |e| e.name }.include?(newName))
-    zfRead.close
+    assert_equal(contents, zf.read(newName))
+    zfRead.close    
   end
 
   def test_renameToExistingEntry
@@ -1271,12 +1292,12 @@ class ZipFileTest < Test::Unit::TestCase
   # can delete the file you used to add the entry to the zip file
   # with
   def test_commitUseZipEntry
-    File.copy(TestFiles::RANDOM_ASCII_FILE1, "okToDelete.txt")
+    FileUtils.cp(TestFiles::RANDOM_ASCII_FILE1, "okToDelete.txt")
     zf = ZipFile.open(TEST_ZIP.zip_name)
     zf.add("okToDelete.txt", "okToDelete.txt")
     assert_contains(zf, "okToDelete.txt")
     zf.commit
-    File.move("okToDelete.txt", "okToDeleteMoved.txt")
+    File.rename("okToDelete.txt", "okToDeleteMoved.txt")
     assert_contains(zf, "okToDelete.txt", "okToDeleteMoved.txt")
   end
 

metadata

@@ -1,97 +1,85 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.6
-specification_version: 1
 name: rubyzip
 version: !ruby/object:Gem::Version 
-  version: 0.9.1
-date: 2006-07-29
-summary: rubyzip is a ruby module for reading and writing zip files
-require_paths: 
-  - lib
-email: thomas(at)sondergaard.cc
-homepage: http://rubyzip.sourceforge.net/
-rubyforge_project: 
-description: 
+  version: 0.9.4
+platform: ruby
+authors: 
+- Thomas Sondergaard
 autorequire: 
-default_executable: 
 bindir: bin
+cert_chain: []
+
+date: 2010-01-01 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: thomas(at)sondergaard.cc
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- NEWS
+- TODO
+- ChangeLog
+- install.rb
+- Rakefile
+- samples/example.rb
+- samples/gtkRubyzip.rb
+- samples/write_simple.rb
+- samples/zipfind.rb
+- samples/example_filesystem.rb
+- samples/qtzip.rb
+- test/stdrubyexttest.rb
+- test/alltests.rb
+- test/ziptest.rb
+- test/ioextrastest.rb
+- test/ziprequiretest.rb
+- test/zipfilesystemtest.rb
+- test/gentestfiles.rb
+- test/data/rubycode2.zip
+- test/data/file1.txt
+- test/data/testDirectory.bin
+- test/data/zipWithDirs.zip
+- test/data/file2.txt
+- test/data/file1.txt.deflatedData
+- test/data/notzippedruby.rb
+- test/data/rubycode.zip
+- lib/zip/zipfilesystem.rb
+- lib/zip/stdrubyext.rb
+- lib/zip/tempfile_bugfixed.rb
+- lib/zip/ioextras.rb
+- lib/zip/zip.rb
+- lib/zip/ziprequire.rb
 has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
+homepage: http://rubyzip.sourceforge.net/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
   version: 
-platform: ruby
-authors: 
-  - Thomas Sondergaard
-files: 
-  - README
-  - NEWS
-  - TODO
-  - ChangeLog
-  - install.rb
-  - Rakefile
-  - samples/example.rb
-  - samples/example_filesystem.rb
-  - samples/gtkRubyzip.rb
-  - samples/qtzip.rb
-  - samples/write_simple.rb
-  - samples/zipfind.rb
-  - test/alltests.rb
-  - test/gentestfiles.rb
-  - test/ioextrastest.rb
-  - test/stdrubyexttest.rb
-  - test/zipfilesystemtest.rb
-  - test/ziprequiretest.rb
-  - test/ziptest.rb
-  - test/data/file1.txt
-  - test/data/file1.txt.deflatedData
-  - test/data/file2.txt
-  - test/data/notzippedruby.rb
-  - test/data/rubycode.zip
-  - test/data/rubycode2.zip
-  - test/data/testDirectory.bin
-  - test/data/zipWithDirs.zip
-  - lib/download_quizzes.rb
-  - lib/zip/ioextras.rb
-  - lib/zip/stdrubyext.rb
-  - lib/zip/tempfile_bugfixed.rb
-  - lib/zip/zip.rb
-  - lib/zip/zipfilesystem.rb
-  - lib/zip/ziprequire.rb
-  - lib/quiz1/t/solutions/Bill Guindon/solitaire.rb
-  - lib/quiz1/t/solutions/Carlos/solitaire.rb
-  - lib/quiz1/t/solutions/Dennis Ranke/solitaire.rb
-  - lib/quiz1/t/solutions/Florian Gross/solitaire.rb
-  - lib/quiz1/t/solutions/Glen M. Lewis/solitaire.rb
-  - lib/quiz1/t/solutions/James Edward Gray II/solitaire.rb
-  - lib/quiz1/t/solutions/Jamis Buck/bin/main.rb
-  - lib/quiz1/t/solutions/Jamis Buck/lib/cipher.rb
-  - lib/quiz1/t/solutions/Jamis Buck/lib/cli.rb
-  - lib/quiz1/t/solutions/Jamis Buck/test/tc_deck.rb
-  - lib/quiz1/t/solutions/Jamis Buck/test/tc_key-stream.rb
-  - lib/quiz1/t/solutions/Jamis Buck/test/tc_keying-algorithms.rb
-  - lib/quiz1/t/solutions/Jamis Buck/test/tc_solitaire-cipher.rb
-  - lib/quiz1/t/solutions/Jamis Buck/test/tc_unkeyed-algorithm.rb
-  - lib/quiz1/t/solutions/Jamis Buck/test/tests.rb
-  - lib/quiz1/t/solutions/Jim Menard/solitaire_cypher.rb
-  - lib/quiz1/t/solutions/Jim Menard/test.rb
-  - lib/quiz1/t/solutions/Moses Hohman/cipher.rb
-  - lib/quiz1/t/solutions/Moses Hohman/deck.rb
-  - lib/quiz1/t/solutions/Moses Hohman/solitaire.rb
-  - lib/quiz1/t/solutions/Moses Hohman/test_cipher.rb
-  - lib/quiz1/t/solutions/Moses Hohman/test_deck.rb
-  - lib/quiz1/t/solutions/Moses Hohman/test_util.rb
-  - lib/quiz1/t/solutions/Moses Hohman/testsuite.rb
-  - lib/quiz1/t/solutions/Moses Hohman/util.rb
-  - lib/quiz1/t/solutions/Niklas Frykholm/solitaire.rb
-  - lib/quiz1/t/solutions/Thomas Leitner/solitaire.rb
-test_files: []
-rdoc_options: []
-extra_rdoc_files: []
-executables: []
-extensions: []
 requirements: []
-dependencies: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: rubyzip is a ruby module for reading and writing zip files
+test_files: []
+

data/lib/download_quizzes.rb

@@ -1,119 +0,0 @@
-#!/bin/env ruby
-
-rubygems = false
-begin
-  require 'rubygems'
-  rubygems = true
-rescue LoadError
-end
-
-require 'open-uri'
-require 'fileutils'
-
-rubyzip = false
-begin
-  require 'zip/zipfilesystem'
-  rubyzip = true
-rescue LoadError
-end
-
-
-@address = "www.rubyquiz.com"
-first = last = nil
-
-first = ARGV[0].to_i if ARGV.size > 1
-last  = ARGV[1].to_i if ARGV.size > 2
-
-
-
-#
-# Download a binary file from the rubyquiz url
-#
-def download(file, todir = '.')
-  begin
-    puts "Downloading file #{file} from #{@address}"
-    c = open("http://#{@address}/#{file}").read
-    Dir.mkdir(todir) if not File.directory?(todir)
-    f = open("#{todir}/#{file}", 'wb')
-    f.puts c
-    f.close
-  rescue => e
-    if not File.exists?(fullfile)
-      $stderr.puts "Could not download file #{file} form #{@address}."
-      $stderr.puts e.to_s
-    end
-  end
-end
-
-
-#
-# Unzip the file using GNU's stand-alone unzip utility. 
-#
-def unzip_gnu(file)
-  puts `unzip -o #{file}`
-end
-
-
-#
-# Unzip the file using rubyzip library.
-#
-def unzip(x)
-  outdir = x.sub(/.*\//, '')
-  outdir = '.' if outdir == ""
-  Zip::ZipFile::open(x) { |zf|
-    zf.each { |e|
-      fpath = File.join(outdir, e.name)
-      FileUtils.mkdir_p(File.dirname(fpath))
-      zf.extract(e, fpath)
-    }
-  }
-end
-
-
-
-def get_index
-  c = open("http://#{@address}/").read
-  quizzes = c.scan /quiz(\d+).html/
-  return [ quizzes[0][0], quizzes[-1][0] ]
-end
-
-if not first or not last
-  f, l = get_index()
-  last = l  unless last
-  first = f unless first
-end
-
-first = first.to_i
-last  = last.to_i
-
-
-puts "Downloading quizzess #{first} to #{last}"
-quizzes = (first..last)
-quizzes.each { |q|
-  dir      = "quiz#{q}"
-
-  #### Download HTML description
-  file     = "quiz#{q}.html"
-  fullfile = "#{dir}/#{file}"
-  if not File.exists?(fullfile)
-    download( file, dir )
-  end
-
-  #### Download zip file
-  file     = "quiz#{q}_sols.zip"
-  fullfile = "#{dir}/#{file}"
-
-  if not File.exists?(fullfile)
-    download( file, dir )
-  end
-
-  # Unzip and remove .zip file
-  Dir.chdir dir
-  if rubyzip
-    unzip file
-  else
-    unzip_gnu file
-  end
-  FileUtils.rm file
-  Dir.chdir '..'
-}

data/lib/quiz1/t/solutions/Bill Guindon/solitaire.rb

@@ -1,205 +0,0 @@
-# bail if you have nothing to do.
-unless ARGV[0]
-  print <<-STOP_PRINT
-    Encrypts/decrypts a string of text.
-    Usage:  Give it some text!
-  STOP_PRINT
-  exit
-end
-
-# the obligatory deck of cards.
-###############################################################################
-class Deck
-  attr_reader :cards, :order
-
-  def initialize
-    @cards = []
-    @order = []
-    build_deck
-  end
-
-  def to_s
-    return @cards.to_s
-  end
-
-  def build_deck
-    [:Clubs, :Diamonds, :Hearts, :Spades].each do |suit|
-      rank = 0
-      'A23456789TJQK'.each_byte do |name|
-        # 'real' cards have a rank value
-        rank += 1
-        add_card(name.chr, suit, rank)
-      end
-    end
-
-    # Jokers have no rank value
-    'AB'.each_byte {|name| add_card(name.chr, :Joker, 0)}
-  end
-
-  # build order while adding.
-  def add_card(name, suit, rank)
-    card = Card.new(name, suit, rank)
-    @cards << card
-    @order << card.to_s
-  end
-
-  # Uses order to hunt for cards (Joker searches).
-  def find_card(name, suit)
-    return @order.index(Card.to_s(name, suit))
-  end
-
-  # does as many cuts as you give it.
-  def cut_cards(cuts)
-    cards = []
-    loc = 0
-    [cuts].flatten.each_with_index do |cut, idx|
-      cards[idx] = @cards[loc...cut]
-      loc = cut
-    end
-    cards << @cards[loc...@cards.length]
-  end
-
-  def cards=(cards)
-    # flatten to handle cut results.
-    @cards = cards.flatten
-    # rebuild @order each time the deck changes.
-    update_order
-  end
-
-  # simple, but not very efficient.
-  def update_order
-    @order = @cards.collect {|card| card.to_s}
-  end
-
-end
-
-# the above deck is made up of...
-###############################################################################
-class Card
-  @@SUITS = {
-    :Clubs    =>  0,
-    :Diamonds => 13,
-    :Hearts   => 26,
-    :Spades   => 39,
-    :Joker    => 53
-  }
-
-  def self.to_s(name, suit)
-    return name + ' ' + suit.to_s + "\n"
-  end
-
-  attr_reader :name, :suit, :rank
-
-  def initialize(name, suit, rank)
-    @name = name
-    @suit = suit
-    @rank = rank + @@SUITS[suit]
-  end
-
-  def to_s
-    Card.to_s(@name, @suit)
-  end
-end
-
-###############################################################################
-class Solitaire
-
-  attr_reader :deck
-
-  def initialize(text)
-    @deck = Deck.new
-    @text = text.to_s
-  end
-
-  def process
-    # does it look encrypted?  5 letter blocks all uppercase?
-    looks_encrypted = @text.gsub(/[A-Z]{5}\s?/, '').empty?
-    results = ''
-
-    # prep the text for parsing.
-    if looks_encrypted
-      # strip off the blanks for consistency
-      text = @text.gsub(/\s/, '')
-    else
-      # Discard any non A to Z characters, and uppercase all remaining
-      text = @text.upcase.gsub!(/[^A-Z]/, '')
-      # Split the message into five character groups,
-      words, padding = word_count(text, 5)
-      # using Xs to pad the last group
-      text += padding
-    end
-
-    # parse it, and build up results.
-    text.each_byte do |char|
-      if looks_encrypted
-        char -= next_key
-        char += 26 if char < 65
-      else
-        char += next_key
-        char -= 26 if char > 90
-      end
-      results += char.chr
-    end
-
-    return space_text(results, 5)
-  end
-
-  # counts words as 5 char blocks
-  def word_count(text, len)
-    words, strays = text.length.divmod(len)
-    words += 1 if strays > 0
-    pad = "X" * (len - strays)
-    return [words, pad]
-  end
-
-  def space_text(text, len)
-    # adds a space every 5 letters.
-    # not sure how efficient this is.
-    return text.unpack(('A' + len.to_s) * word_count(text, len)[0]).join(' ')
-  end
-
-  def shift_card(name, suit, count)
-    # find the card
-    idx = @deck.find_card(name, suit)
-    # remove it from the deck.
-    card = @deck.cards.slice!(idx)
-    # calculate new placement.
-    idx += count
-    # the slice above makes length 'look' zero-based
-    idx -= @deck.cards.length if idx > @deck.cards.length
-
-    # glue the deck together as cards before, card, cards after.
-    @deck.cards = @deck.cards[0...idx] + [card] +
-@deck.cards[idx...@deck.cards.length]
-  end
-
-  def next_key
-    shift_card('A', :Joker, 1)
-    shift_card('B', :Joker, 2)
-
-    # find the 2 jokers, and sort them for the cut.
-    jokers = [@deck.find_card('A', :Joker), @deck.find_card('B', :Joker)].sort
-    # increment the 2nd joker pos -- cut uses 'up to, but not including'
-    jokers[1] += 1
-    # reverse works nicely for the triple cut.
-    @deck.cards = @deck.cut_cards(jokers).reverse
-
-    # get the value from the last card, and cut up to it.
-    cuts = @deck.cut_cards([@deck.cards.last.rank, @deck.cards.length - 1])
-    @deck.cards = cuts[1] + cuts[0] + cuts[2]
-
-    # read top card value, count down that many cards + 1
-    key = @deck.cards[@deck.cards[0].rank].rank
-    # convert it to a letter, adjust if needed.
-    key -= 26 if key > 26
-
-    # if key is still > 26, then it's a joker!
-    return (key) unless key > 26
-    # try again if it's a joker!
-    next_key
-  end
-end
-
-test = Solitaire.new(ARGV[0])
-puts test.process
-puts test.deck