rubyzip 0.9.1 → 0.9.4

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

@@ -1,97 +0,0 @@
-#!/usr/bin/env ruby
-require 'util'
-require 'deck'
-
-module Solitaire
-	ASCII_OFFSET = 64
-	ALPHABET_SIZE = 26
-		
-	class Chunker
-		CHUNK_SIZE = 5
-
-		def initialize(text)
-			@legal_chars_only = text.gsub(/[^A-Za-z]/, "").upcase
-			@legal_chars_only <<= "X" * (-@legal_chars_only.size % CHUNK_SIZE)
-			raise "Nothing to chunk (non-alphabet characters removed): #{text}" if @legal_chars_only.size==0
-			@chunks = []
-			@number_chunks = []
-		end
-
-		def chunks
-			@chunks if @chunks.size > 0
-			@chunks = @legal_chars_only.gsub(/(.{#{CHUNK_SIZE}})/, '\1 ').rstrip.split(" ")
-		end
-
-		def number_chunks
-			@number_chunks if @number_chunks.size > 0
-			chunks.collect { |chunk| chunk.split("").collect { |char_string| char_string[0]-ASCII_OFFSET } }
-		end
-
-		def Chunker.to_letters(number_chunks)
-			number_chunks.collect { |chunk| chunk.collect { |num| (num+ASCII_OFFSET).chr }.join }
-		end
-	end
-
-	class Keystream
-		A_JOKER = Card.joker(?A)
-		B_JOKER = Card.joker(?B)
-
-		def initialize(deck=Deck.new)
-			@deck = deck
-		end
-
-		def keystream_letters(chunks)
-			chunks.collect { |chunk| (1..chunk.size).collect { next_keystream_letter }.join }
-		end
-
-		def Keystream.card_to_letter(card)
-			return "" if card.is_joker?
-			(card.value.offset_mod(ALPHABET_SIZE)+ASCII_OFFSET).chr
-		end
-
-		private
-
-		def next_keystream_letter
-			process_deck
-			top_card = @deck[0]
-			keystream_card = @deck[top_card.value]
-			letter = Keystream.card_to_letter(keystream_card)
-			letter = next_keystream_letter if letter==""
-			letter
-		end
-
-		def process_deck
-			@deck.move_card!(A_JOKER, +1)
-			@deck.move_card!(B_JOKER, +2)
-			@deck.triple_cut!([A_JOKER, B_JOKER])
-			@deck.count_cut!
-		end
-	end
-
-	class Cipher
-		ENCRYPTED_TEXT_PATTERN = /\A[A-Z]{5}( [A-Z]{5})*\Z/
-
-		def initialize(text, deck=Deck.new)
-			@chunker = Chunker.new(text)
-			keystream = Keystream.new(deck)
-			@keystream_chunker = Chunker.new(keystream.keystream_letters(@chunker.chunks).join)
-			if text =~ ENCRYPTED_TEXT_PATTERN
-				@mode = "decrypt"
-				@calc_number = proc { |num, keystream_num| num - keystream_num }
-			else
-				@mode = "encrypt"
-				@calc_number = proc { |num, keystream_num| num + keystream_num }
-			end
-		end
-		attr_reader :mode
-
-		def crypt
-			ciphered = [@chunker.number_chunks, @keystream_chunker.number_chunks].collect_peel do |num_chunk, keystream_num_chunk|
-				[num_chunk, keystream_num_chunk].collect_peel do |num, keystream_num|
-					@calc_number.call(num,keystream_num).offset_mod(ALPHABET_SIZE)
-				end
-			end
-			Chunker.to_letters(ciphered).join(" ").rstrip
-		end
-	end
-end

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

@@ -1,140 +0,0 @@
-require 'util'
-
-module Solitaire
-	class Deck
-		NUM_CARDS = 54
-
-		def initialize(order=nil)
-			if order.nil?
-				@order = Array.new(NUM_CARDS) { |x| x+1 }
-			else
-				@order = order.collect { |val| val.instance_of?(Range) ? val.to_a : val }.flatten
-				@order.collect! { |val| Card.parse(val).code }
-			end
-		end
-		attr_reader :order
-		protected :order
-
-		def [](index)
-			Card.parse(@order[index])
-		end
-
-		def move_card!(card, offset)
-			current_index = @order.index(card.code)
-			new_index = current_index+offset
-			if new_index >= NUM_CARDS
-				new_index -= NUM_CARDS - 1
-			elsif new_index < 0
-				new_index += NUM_CARDS - 1
-			end
-			@order.delete_at(current_index)
-			@order.insert(new_index, card.code)
-		end
-
-		def triple_cut!(cards)
-			raise "exactly two cards required for triple cut: #{cards}" unless cards.size==2 
-			indices = [@order.index(cards[0].code), @order.index(cards[1].code)].sort
-			@order = @order[(indices[1]+1)..@order.size] + @order[indices[0]..indices[1]] + @order[0..(indices[0]-1)]
-		end
-
-		def count_cut!
-			num_moved = Card.parse(@order.last).value
-			if num_moved!=53
-				@order = @order[num_moved, NUM_CARDS - num_moved - 1] + @order[0..(num_moved-1)] + [@order.last]
-			end
-			self
-		end
-
-		def to_s
-			"<Deck: #{@order.inspect}>"
-		end
-		
-		def ==(val)
-			@order == val.order
-		end
-	end
-
-	class Card
-		ACE = 1
-		JACK = 11
-		QUEEN = 12
-		KING = 13
-
-		def initialize(suit, value)
-			@code = suit.value + value
-		end
-		attr_reader :code
-		alias_method :value, :code
-
-		def Card.parse(code)
-			if (1..52).member?(code)
-				Card.new(Suit.by_value(code), code.offset_mod(13)) 
-			elsif (53..54).member?(code)
-				Card.joker(code+12)
-			elsif (65..66).member?(code)
-				Card.joker(code)
-			elsif code =~ /\A[AB]\Z/
-				Card.joker(code[0])
-			else
-				raise "Illegal class or value for parameter value, #{code.class} #{code.inspect}"
-			end
-		end
-
-		def Card.joker(char)
-			JokerCard.new(char.chr)
-		end
-
-		def is_joker?
-			false
-		end
-
-		def ==(other)
-			code==other.code
-		end
-
-		def <=>(other)
-			code<=>other.code
-		end
-
-		def to_s
-			"Card: #{@code}"
-		end
-	end
-
-	class JokerCard < Card
-		JOKER_VALUE = 53
-
-		def initialize(which_one)
-			raise "No such joker: #{which_one}" unless which_one =~ /\A[AB]\Z/
-			@code = 52 + (which_one[0].to_i-64)
-		end
-
-		def is_joker?
-			true
-		end
-
-		def value
-			JOKER_VALUE
-		end
-	end
-
-	class Suit
-		@@byValue = {}
-
-		def Suit.by_value(val)
-			@@byValue[(val-1)/13*13]
-		end
-
-		def initialize(name, value)
-			@name = name
-			@value = value
-			@@byValue[value] = self
-		end
-		attr_reader :name, :value
-
-		CLUBS = Suit.new("clubs", 0)
-		DIAMONDS = Suit.new("diamonds", 13)
-		HEARTS = Suit.new("hearts", 26)
-		SPADES = Suit.new("spades", 39)
-	end
-end

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

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-require 'cipher'
-require 'yaml'
-
-module Solitaire
-	text = ARGV.join(" ")
-	if FileTest::readable?("deck.yaml")
-		deck = Deck.new(YAML::load(File.open("deck.yaml")))
-	else
-		deck = Deck.new
-	end
-	cipher = Cipher.new(text, deck)
-	puts "#{cipher.mode}ed: #{cipher.crypt}"
-end

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

@@ -1,68 +0,0 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-require 'cipher'
-
-module Solitaire
-	class TestChunker < Test::Unit::TestCase
-		def test_chunks
-			chunker = Chunker.new("Code in Ruby, live longer!")
-			assert_equal(["CODEI","NRUBY","LIVEL","ONGER"], chunker.chunks)
-		end
-
-		def test_pads_with_Xs
-			chunker = Chunker.new("sty")
-			assert_equal(["STYXX"], chunker.chunks)
-		end
-
-		def test_number_chunks
-			chunker = Chunker.new("Code in Ruby, live longer!")
-			assert_equal([[3,15,4,5,9], [14,18,21,2,25], [12,9,22,5,12], [15,14,7,5,18]], chunker.number_chunks)
-		end
-
-		def test_to_letters
-			assert_equal(["CODEI","NRUBY","LIVEL","ONGER"],
-				Chunker.to_letters([[3,15,4,5,9], [14,18,21,2,25], [12,9,22,5,12], [15,14,7,5,18]]))
-		end
-	end
-
-	class TestKeystream < Test::Unit::TestCase
-		def setup
-			@keystream = Keystream.new
-		end
-
-		def test_keystream_letters
-			chunker = Chunker.new("Code in Ruby, live longer!")
-			assert_equal(["DWJXH","YRFDG","TMSHP","UURXJ"], @keystream.keystream_letters(chunker.chunks))
-		end
-
-		def test_card_to_letter
-			assert_equal("", Keystream.card_to_letter(Card.joker(?A)), "A joker")
-			assert_equal("", Keystream.card_to_letter(Card.joker(?B)), "B joker")
-			assert_equal("A", Keystream.card_to_letter(Card.new(Suit::CLUBS, Card::ACE)), "AC")
-			assert_equal("Z", Keystream.card_to_letter(Card.new(Suit::DIAMONDS, Card::KING)), "KD")
-			assert_equal("A", Keystream.card_to_letter(Card.new(Suit::HEARTS, Card::ACE)), "AH")
-			assert_equal("Z", Keystream.card_to_letter(Card.new(Suit::SPADES, Card::KING)), "KS")
-		end
-	end
-
-	class TestCipher < Test::Unit::TestCase
-		def test_encrypt
-			cipher = Cipher.new("Code in Ruby, live longer!")
-			assert_equal("encrypt", cipher.mode)
-			assert_equal("GLNCQ MJAFF FVOMB JIYCB", cipher.crypt)
-		end
-
-		def test_decrypt
-			cipher = Cipher.new("GLNCQ MJAFF FVOMB JIYCB")
-			assert_equal("decrypt", cipher.mode)
-			assert_equal("CODEI NRUBY LIVEL ONGER", cipher.crypt)
-		end
-
-		def test_crypt_idempotent
-			cipher = Cipher.new("GLNCQ MJAFF FVOMB JIYCB")
-			assert_equal("decrypt", cipher.mode)
-			assert_equal("CODEI NRUBY LIVEL ONGER", cipher.crypt)
-			assert_equal("CODEI NRUBY LIVEL ONGER", cipher.crypt)
-		end
-	end
-end

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

@@ -1,146 +0,0 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-require 'deck'
-
-module Solitaire
-	class TestDeck < Test::Unit::TestCase
-		def test_constructor_accepts_ranges_in_array
-			assert_equal(Deck.new, Deck.new([1, 2, 3, 4..52, 53..54]))
-		end
-
-		def test_construcor_accepts_chars_for_jokers
-			assert_equal(Deck.new, Deck.new((1..52).to_a + [?A, ?B]))
-		end
-
-		def test_move_card_lower
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::DIAMONDS, 6), +5)
-			assert_equal(Deck.new([1..18,20..24,19,25..54]).to_s, deck.to_s)
-		end
-
-		def test_move_card_one_lower
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::DIAMONDS, 6), +1)
-			assert_equal(Deck.new([1..18,20,19,21..54]).to_s, deck.to_s)
-		end
-
-		def test_move_card_higher
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::DIAMONDS, 6), -5)
-			assert_equal(Deck.new([1..13,19,14..18,20..54]), deck)
-		end
-
-		def test_move_card_is_cyclic_plus_1
-			deck = Deck.new
-			deck.move_card!(Card.joker(?A), +2)
-			assert_equal(Deck.new([1,53,2..52,54]), deck)
-		end
-
-		def test_move_card_to_end
-			deck = Deck.new
-			deck.move_card!(Card.joker(?A), +1)
-			assert_equal(Deck.new([1..52,54,53]), deck)
-		end
-
-		def test_move_card_to_one_before_end
-			deck = Deck.new([2..54,1])
-			deck.move_card!(Card.joker(?A), +1)
-			assert_equal(Deck.new([2..52,54,53,1]).to_s, deck.to_s)
-		end
-
-		def test_move_card_to_beginning
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, 2), -1)
-			assert_equal(Deck.new([2,1,3..54]), deck)
-		end
-
-		def test_move_card_is_cyclic_pass_end_forward
-			deck = Deck.new
-			deck.move_card!(Card.joker(?B), +1)
-			assert_equal(Deck.new([1,54,2..53]), deck)
-		end
-
-		def test_move_card_is_cyclic_pass_end_backward
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, Card::ACE), -1)
-			assert_equal(Deck.new([2..53,1,54]), deck)
-		end
-
-		def test_move_card_cyclic_backward_five
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, 5), -5)
-			assert_equal(Deck.new([1..4,6..53,5,54]), deck)
-		end
-
-		def test_triple_cut
-			deck = Deck.new
-			deck.triple_cut!([Card.new(Suit::CLUBS, Card::JACK), Card.new(Suit::HEARTS, Card::KING)])
-			assert_equal(Deck.new([40..54,11..39,1..10]), deck)
-		end
-
-		def test_triple_cut_with_empty_side
-			deck = Deck.new([2..53,1,54])
-			deck.triple_cut!([Card.joker(?A), Card.joker(?B)])
-			assert_equal(Deck.new([53,1,54,2..52]), deck)
-		end
-
-		def test_count_cut
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, 5), 49)
-			deck.count_cut!
-			assert_equal(Deck.new([7..54,1..4,6,5]), deck)
-		end
-	end
-
-	class TestCard < Test::Unit::TestCase
-		def test_parse_joker_string
-			assert_equal(Card.joker(?A), Card.parse("A"))
-		end
-
-		def test_parse_joker_char
-			assert_equal(Card.joker(?A), Card.parse(?A))
-		end
-
-		def test_parse_normal_card
-			assert_equal(Card.new(Suit::CLUBS, 5), Card.parse(5))
-		end
-
-		def test_value
-			assert_equal(1, Card.new(Suit::CLUBS, Card::ACE).value, "AC")
-			assert_equal(7, Card.new(Suit::CLUBS, 7).value, "7C")
-			assert_equal(11, Card.new(Suit::CLUBS, Card::JACK).value, "JC")
-			assert_equal(13, Card.new(Suit::CLUBS, Card::KING).value, "KC")
-			assert_equal(14, Card.new(Suit::DIAMONDS, Card::ACE).value, "AD")
-			assert_equal(26, Card.new(Suit::DIAMONDS, Card::KING).value, "KD")
-			assert_equal(29, Card.new(Suit::HEARTS, 3).value, "3H")
-			assert_equal(39, Card.new(Suit::HEARTS, Card::KING).value, "KH")
-			assert_equal(40, Card.new(Suit::SPADES, Card::ACE).value, "AS")
-			assert_equal(52, Card.new(Suit::SPADES, Card::KING).value, "KS")
-			assert_equal(53, Card.joker(?A).value, "A Joker")
-			assert_equal(53, Card.joker(?B).value, "B Joker")
-		end
-
-		def test_is_joker_when_joker
-			assert(Card.joker(?A).is_joker?, "A joker not joker")
-			assert(Card.joker(?B).is_joker?, "B joker not joker")
-		end
-
-		def test_is_joker_when_not_joker
-			assert(!Card.new(Suit::SPADES, 7).is_joker?)
-		end
-	end
-
-	class TestSuit < Test::Unit::TestCase
-		def test_by_value_clubs
-			assert_equal("clubs", Suit.by_value(1).name)
-		end
-
-		def test_by_value_hearts
-			assert_equal("hearts", Suit.by_value(27).name)
-		end
-
-		def test_hearts
-			assert_equal("hearts", Suit::HEARTS.name)
-		end
-	end
-end