rubyzip 0.9.1 → 2.3.2

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

@@ -1,38 +0,0 @@
-#!/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

@@ -1,5 +0,0 @@
-#!/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

@@ -1,27 +0,0 @@
-#!/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

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

@@ -1,198 +0,0 @@
-#!/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/stdrubyext.rb

@@ -1,111 +0,0 @@
-unless Enumerable.method_defined?(:inject)
-  module Enumerable  #:nodoc:all
-    def inject(n = 0)
-      each { |value| n = yield(n, value) }
-      n
-    end
-  end
-end
-
-module Enumerable #:nodoc:all
-  # returns a new array of all the return values not equal to nil
-  # This implementation could be faster
-  def select_map(&aProc)
-    map(&aProc).reject { |e| e.nil? }
-  end
-end
-
-unless Object.method_defined?(:object_id)
-  class Object  #:nodoc:all
-    # Using object_id which is the new thing, so we need
-    # to make that work in versions prior to 1.8.0
-    alias object_id id
-  end
-end
-
-unless File.respond_to?(:read)
-  class File # :nodoc:all
-    # singleton method read does not exist in 1.6.x
-    def self.read(fileName)
-      open(fileName) { |f| f.read }
-    end
-  end
-end
-
-class String  #:nodoc:all
-  def starts_with(aString)
-    rindex(aString, 0) == 0
-  end
-
-  def ends_with(aString)
-    index(aString, -aString.size)
-  end
-
-  def ensure_end(aString)
-    ends_with(aString) ? self : self + aString
-  end
-
-  def lchop
-    slice(1, length)
-  end
-end
-
-class Time  #:nodoc:all
-  
-  #MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
-  # 
-  # Register CX, the Time:
-  # Bits 0-4  2 second increments (0-29)
-  # Bits 5-10 minutes (0-59)
-  # bits 11-15 hours (0-24)
-  # 
-  # Register DX, the Date:
-  # Bits 0-4 day (1-31)
-  # bits 5-8 month (1-12)
-  # bits 9-15 year (four digit year minus 1980)
-  
-  
-  def to_binary_dos_time
-    (sec/2) +
-      (min  << 5) +
-      (hour << 11)
-  end
-
-  def to_binary_dos_date
-    (day) +
-      (month << 5) +
-      ((year - 1980) << 9)
-  end
-
-  # Dos time is only stored with two seconds accuracy
-  def dos_equals(other)
-    to_i/2 == other.to_i/2
-  end
-
-  def self.parse_binary_dos_format(binaryDosDate, binaryDosTime)
-    second = 2 * (       0b11111 & binaryDosTime)
-    minute = (     0b11111100000 & binaryDosTime) >> 5 
-    hour   = (0b1111100000000000 & binaryDosTime) >> 11
-    day    = (           0b11111 & binaryDosDate) 
-    month  = (       0b111100000 & binaryDosDate) >> 5
-    year   = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980
-    begin
-      return Time.local(year, month, day, hour, minute, second)
-    end
-  end
-end
-
-class Module  #:nodoc:all
-  def forward_message(forwarder, *messagesToForward)
-    methodDefs = messagesToForward.map { 
-      |msg| 
-      "def #{msg}; #{forwarder}(:#{msg}); end"
-    }
-    module_eval(methodDefs.join("\n"))
-  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.