[SOLUTION] The Solitaire Cipher (#1)

Class-oriented, but kinda long maybe. Hey, it has unit tests . . . 
Reads in a file, deck.yaml, if it exists to specify the deck order. Zip 
of the files is attached. If you run it out of the box it will use the 
non-default deck in deck.yaml.

Thanks for the quiz, it was fun!

Moses



######################################################################## 
########
# solitaire.rb
######################################################################## 
########
#!/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

######################################################################## 
########
# cipher.rb
######################################################################## 
########
#!/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

######################################################################## 
########
# deck.rb
######################################################################## 
########
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)[e-mail]] +  
@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

######################################################################## 
########
# util.rb
######################################################################## 
########
#!/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

######################################################################## 
########
# deck.yaml
######################################################################## 
########
# Array of numbers (1 through 54), ranges of those numbers,
# and "A" or "B" that describes the order of the keyed deck
---
- 25
- !ruby/range 1..24
- !ruby/range 26..54

######################################################################## 
########
# testsuite.rb
######################################################################## 
########
#!/usr/bin/env ruby
require 'test/unit'
require 'test_cipher'
require 'test_deck'
require 'test_util'

######################################################################## 
########
# test_cipher.rb
######################################################################## 
########
#!/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

######################################################################## 
########
# test_deck.rb
######################################################################## 
########
#!/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

######################################################################## 
########
# test_util.rb
######################################################################## 
########
#!/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