rubyzip 0.5.12 → 0.9.1

data/lib/quiz1/t/solutions/Moses Hohman/test_util.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'util'
+
+class TestArray < Test::Unit::TestCase
+	def test_peel_all_arrays_same_length
+		tuples = []
+		a1 = [1,3,5]
+		a2 = [2,4,6]
+		a3 = [1,4,9]
+		[a1, a2, a3].peel { |x,y,z| tuples << [x,y,z] }
+		assert_equal([[1,2,1],[3,4,4],[5,6,9]], tuples)
+	end
+
+	def test_peel_one_array_shorter
+		tuples = []
+		a1 = [1,3,5]
+		a2 = [2,4]
+		a3 = [1,4,9]
+		[a1, a2, a3].peel { |x,y,z| tuples << [x,y,z] }
+		assert_equal([[1,2,1],[3,4,4]], tuples)
+	end
+
+	def test_collect_peel
+		a1 = [1,3,5]
+		a2 = [2,4,6]
+		assert_equal([3,7,11], [a1, a2].collect_peel { |a,b| a+b })
+	end
+end
+
+class TestFixnum < Test::Unit::TestCase
+	def test_offset_mod
+		assert_equal(1, 27.offset_mod(26), "27 wrong")
+		assert_equal(26, 26.offset_mod(26), "26 wrong")
+		assert_equal(26, 0.offset_mod(26), "0 wrong")
+		assert_equal(25, -1.offset_mod(26), "-1 wrong")
+	end
+end

data/lib/quiz1/t/solutions/Moses Hohman/testsuite.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'test_cipher'
+require 'test_deck'
+require 'test_util'

data/lib/quiz1/t/solutions/Moses Hohman/util.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+class Array
+	# "Peels" off a tuple of the elements at each successive index across multiple arrays.
+	# Assumes self is an array of these multiple arrays. Stops when any of the arrays is 
+	# exhausted. I stole this from a ruby mailing list somewhere. I also considered calling this each_tuple
+    def peel(&p)
+        collect { |a|
+            a.length
+        }.min.times { |i|
+            yield collect { |a| a[i] }
+        }
+    end
+
+	# syntactic sugar for Cipher
+	def collect_peel(&p)
+		collected = []
+		peel { |a,b| collected << p.call(a,b) }
+		collected
+	end
+end
+
+class Fixnum
+	def offset_mod(base)
+		((self-1)%base)+1
+	end
+end

data/lib/quiz1/t/solutions/Niklas Frykholm/solitaire.rb

@@ -0,0 +1,151 @@
+def succ?(*a)
+  begin
+    (0..(a.size-2)).each {|i| return false if a[i].succ != a[i+1]}
+    return true
+  rescue
+    return false
+  end
+end
+
+class Deck
+  def initialize
+    @deck = (1..52).to_a + [:A, :B]
+  end
+
+  def move_a
+    move_down(@deck.index(:A))
+  end
+
+  def move_b
+    move_down(move_down(@deck.index(:B)))
+  end
+
+  def move_down(index)
+    if index < 53
+      new = index + 1
+      @deck[new], @deck[index] = @deck[index], @deck[new]
+    else
+      @deck = @deck[0,1] + @deck[-1,1] + @deck[1..-2]
+      new = 1
+    end
+    return new
+  end
+
+  def triple_cut
+    jokers = [@deck.index(:A), @deck.index(:B)]
+    top, bottom = jokers.min, jokers.max
+    @deck = @deck[(bottom+1)..-1] + @deck[top..bottom] + @deck[0...top]
+  end
+
+  def number_value(x)
+    return 53 if x == :A or x == :B
+    return x
+  end
+
+  def count_cut
+    count = number_value( @deck[-1] )
+    @deck = @deck[count..-2] + @deck[0,count] + @deck[-1,1]
+  end
+
+  def output
+    return @deck[ number_value(@deck[0]) ]
+  end
+
+  def update
+    move_a
+    move_b
+    triple_cut
+    count_cut
+  end
+
+  def get
+    while true
+      update
+      c = output
+      if c != :A and c != :B
+        letter = ( ((c-1) % 26) + 65 ).chr
+        return letter
+      end
+    end
+  end
+
+  def to_s
+    a = []
+    @deck.each_index {|i|
+      if  succ?(a[-1], @deck[i], @deck[i+1])
+        a << "..."
+      elsif a[-1] == "..." and succ?(@deck[i-1], @deck[i], @deck[i+1])
+        # nop
+      else
+        a << @deck[i]
+      end
+    }
+    return a.join(" ")
+  end
+end
+
+class Encrypter
+  def initialize(keystream)
+    @keystream = keystream
+  end
+
+  def sanitize(s)
+    s = s.upcase
+    s = s.gsub(/[^A-Z]/, "")
+    s = s + "X" * ((5 - s.size % 5) % 5)
+    out = ""
+    (s.size / 5).times {|i| out << s[i*5,5] << " "}
+    return out
+  end
+
+  def mod(c)
+    return c - 26 if c > 26
+    return c + 26 if c < 1
+    return c
+  end
+
+  def process(s, &combiner)
+    s = sanitize(s)
+    out = ""
+    s.each_byte { |c|
+      if c >= ?A and c <= ?Z
+        key = @keystream.get
+        res = combiner.call(c, key[0])
+        out << res.chr
+      else
+        out << c.chr
+      end
+    }
+    return out
+  end
+
+  def encrypt(s)
+    return process(s) {|c, key| 64 + mod(c + key - 128)}
+  end
+
+  def decrypt(s)
+    return process(s) {|c, key| 64 + mod(c -key)}
+  end
+end
+
+
+def test
+  d = Deck.new()
+  d.update
+  puts d
+
+  e = Encrypter.new( Deck.new() )
+  cipher =  e.encrypt('Code in Ruby, live longer!')
+  puts cipher
+
+  e = Encrypter.new( Deck.new() )
+  puts e.decrypt(cipher)
+
+  e = Encrypter.new( Deck.new() )
+  puts e.decrypt("CLEPK HHNIY CFPWH FDFEH")
+
+  e = Encrypter.new( Deck.new() )
+  puts e.decrypt("ABVAW LWZSY OORYK DUPVH")
+end
+
+test()

data/lib/quiz1/t/solutions/Thomas Leitner/solitaire.rb

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ostruct'
+
+# Handles the deck
+class Deck
+
+  # Initializes the deck with the default values
+  def initialize
+    @deck = (1..52).to_a << 'A' << 'B'
+  end
+
+  # Operation "move a" (step 2)
+  def move_A
+    move_down( @deck.index( 'A' ) )
+  end
+
+  # Operation "move b" (step 3)
+  def move_B
+    2.times { move_down( @deck.index( 'B' ) ) }
+  end
+
+  # Operation "triple cut" (step 4)
+  def triple_cut
+    a = @deck.index( 'A' )
+    b = @deck.index( 'B' )
+    a, b = b, a if a > b
+    @deck.replace( [@deck[(b + 1)..-1], @deck[a..b], @deck[0...a]].flatten )
+  end
+
+  # Operation "count cut" (step 5)
+  def count_cut
+    temp = @deck[0..(@deck[-1] - 1)]
+    @deck[0..(@deck[-1] - 1)] = []
+    @deck[-1..-1] = [temp, @deck[-1]].flatten
+  end
+
+  # Operation "output the found letter" (step 6)
+  def output_letter
+    a = @deck.first
+    a = 53 if a.instance_of? String
+    output = @deck[a]
+    if output.instance_of? String
+      nil
+    else
+      output -= 26 if output > 26
+      (output + 64).chr
+    end
+  end
+
+  # Shuffle the deck using the initialization number +init+ and the method +method+.
+  # Currently there are only two methods: <tt>:fisher_yates</tt> and <tt>naive</tt>.
+  def shuffle( init, method = :fisher_yates )
+    srand( init )
+    self.send( method.id2name + "_shuffle", @deck )
+  end
+
+  private
+
+  # From pleac.sf.net
+  def fisher_yates_shuffle( a )
+    (a.size-1).downto(0) { |i|
+      j = rand(i+1)
+      a[i], a[j] = a[j], a[i] if i != j
+    }
+  end
+
+  # From pleac.sf.net
+  def naive_shuffle( a )
+    for i in 0...a.size
+      j = rand(a.size)
+      a[i], a[j] = a[j], a[i]
+    end
+  end
+
+  # Moves the index one place down while treating the used array as circular list.
+  def move_down( index )
+    if index == @deck.length - 1
+      @deck[1..1] = @deck[index], @deck[1]
+      @deck.pop
+    else
+      @deck[index], @deck[index + 1] = @deck[index + 1], @deck[index]
+    end
+  end
+
+end
+
+
+# Implements the Solitaire Cipher algorithm
+class SolitaireCipher
+
+  # Initialize the deck
+  def initialize( init = -1, method = :fisher_yates )
+    @deck = Deck.new
+    @deck.shuffle( init, method ) unless init == -1
+  end
+
+  # Decodes the given +msg+ using the internal deck
+  def decode( msg )
+    msgNumbers = to_numbers( msg )
+    cipherNumbers = to_numbers( generate_keystream( msg.length ) )
+
+    resultNumbers = []
+    msgNumbers.each_with_index do |item, index|
+      item += 26 if item <= cipherNumbers[index]
+      temp = item - cipherNumbers[index]
+      resultNumbers << temp
+    end
+
+    return to_chars( resultNumbers )
+  end
+
+  # Encodes the given +msg+ using the internal deck
+  def encode( msg )
+    msg = msg.gsub(/[^A-Za-z]/, '').upcase
+    msg += "X"*(5 - (msg.length % 5)) unless msg.length % 5 == 0
+
+    msgNumbers = to_numbers( msg )
+    cipherNumbers = to_numbers( generate_keystream( msg.length ) )
+
+    resultNumbers = []
+    msgNumbers.each_with_index do |item, index|
+      temp = item + cipherNumbers[index]
+      temp = temp - 26 if temp > 26
+      resultNumbers << temp
+    end
+
+    return to_chars( resultNumbers )
+  end
+
+  private
+
+  # Converts the string of uppercase letters into numbers (A=1, B=2, ...)
+  def to_numbers( chars )
+    chars.unpack("C*").collect {|x| x - 64}
+  end
+
+  # Converts the array of numbers to a string (1=A, 2=B, ...)
+  def to_chars( numbers )
+    numbers.collect {|x| x + 64}.pack("C*")
+  end
+
+  # Generates a keystream for the given +length+.
+  def generate_keystream( length )
+    deck = @deck.dup
+    result = []
+    while result.length != length
+      deck.move_A
+      deck.move_B
+      deck.triple_cut
+      deck.count_cut
+      letter = deck.output_letter
+      result << letter unless letter.nil?
+    end
+    result.join
+  end
+
+end
+
+
+options = OpenStruct.new
+options.key = -1
+options.shuffle = :fisher_yates
+options.call_method = :decode
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0, '.*')} [options] message"
+  opts.separator ""
+  opts.separator "Options:"
+  opts.on( "-d", "--decode", "Decode the message" ) do
+    options.call_method = :decode
+  end
+  opts.on( "-e", "--encode", "Encode the message" ) do
+    options.call_method = :encode
+  end
+  opts.on( "-k", "--key KEY", Integer, "Key for shuffling the deck" ) do |key|
+    options.key = key
+  end
+  opts.on( "-m", "--method METHOD", [:fisher_yates, :naive],
+           "Select the shuffling method (fisher_yates, naive" ) do |method|
+    options.shuffle = method
+  end
+  opts.on( "-h", "--help", "Show help" ) do
+    puts opts
+    exit
+  end
+end
+
+
+if ARGV.length == 0
+  puts opts
+  exit
+end
+
+message = opts.permute!( ARGV )[0]
+cipher = SolitaireCipher.new( options.key, options.shuffle )
+puts cipher.send( options.call_method, message )

data/lib/zip/ioextras.rb

@@ -33,26 +33,28 @@ module IOExtras  #:nodoc:
     attr_accessor :lineno
 
     def read(numberOfBytes = nil, buf = nil)
-      buf = "" unless (buf)
+      tbuf = nil
 
-      if numberOfBytes
+      if @outputBuffer.length > 0
         if numberOfBytes <= @outputBuffer.length
-          buf[RANGE_ALL] = @outputBuffer.slice!(0, numberOfBytes)
+          tbuf = @outputBuffer.slice!(0, numberOfBytes)
         else
-          if @outputBuffer.length > 0
-            buf[RANGE_ALL] = @outputBuffer + sysread(numberOfBytes - @outputBuffer.length, buf)
-            @outputBuffer.slice!(RANGE_ALL)
-          else
-            buf[RANGE_ALL] = sysread(nil, buf)
-          end
+          numberOfBytes -= @outputBuffer.length if (numberOfBytes)
+          rbuf = sysread(numberOfBytes, buf)
+          tbuf = @outputBuffer
+          tbuf << rbuf if (rbuf)
+          @outputBuffer = ""
         end
       else
-        if @outputBuffer.length > 0
-          buf[RANGE_ALL] = @outputBuffer + sysread(nil, buf)
-          @outputBuffer.slice!(RANGE_ALL)
-        else
-          buf[RANGE_ALL] = sysread(nil, buf)
-        end
+        tbuf = sysread(numberOfBytes, buf)
+      end
+
+      return nil unless (tbuf)
+
+      if buf
+        buf.replace(tbuf)
+      else
+        buf = tbuf
       end
 
       buf