rubyzip 0.9.1 → 2.3.2

data/lib/quiz1/t/solutions/James Edward Gray II/solitaire.rb

@@ -1,132 +0,0 @@
-#!/usr/bin/ruby -w
-
-$deck = (1..52).to_a + ["A", "B"]		# Unkeyed deck - Keystream Step 1
-
-def encrypt(message)
-	# Step 1
-	message = message.upcase.tr("^A-Z", "")
-	i = 5
-	while i < message.size
-		message[i, 0] = " "
-		i += 6
-	end
-	message += "X" while message.rindex(" ") != message.size - 6
-	
-	# Step 2
-	key_stream = generate(message.count("^ "))
-	
-	# Step 3
-	values = message.split("").map { |letter| letter[0] - ?A + 1 }
-
-	# Step 4
-	key_values = key_stream.split("").map { |letter| letter[0] - ?A + 1 }
-	
-	# Step 5
-	values.each_with_index do |value, index|
-		next if value < 0
-		values[index] = value + key_values[index]
-		values[index] -= 26 if values[index] > 26
-	end
-	
-	# Step 6
-	message = (values.map { |number| (number - 1 + ?A).chr }).join("")
-	
-	return message
-end
-
-def decrypt(message)
-	# Step 1
-	key_stream = generate(message.size)
-	
-	# Step 2
-	values = message.split("").map { |letter| letter[0] - ?A + 1 }
-
-	# Step 3
-	key_values = key_stream.split("").map { |letter| letter[0] - ?A + 1 }
-	
-	# Step 4
-	values.each_with_index do |value, index|
-		next if value < 0
-		if value <= key_values[index]
-			values[index] = value + 26 - key_values[index]
-		else
-			values[index] = value - key_values[index]
-		end
-	end
-	
-	# Step 5
-	message = (values.map { |number| (number - 1 + ?A).chr }).join("")
-	
-	return message
-end
-
-def generate(count)		# Keystream Steps
-	key_stream = [ ]
-
-	until key_stream.size == count
-		# Step 2
-		a = $deck.index("A")
-		if a == 53
-			$deck.insert(1, $deck.pop)
-		else
-			$deck.insert(a + 1, $deck.delete_at(a))
-		end
-
-		# Step 3
-		b = $deck.index("B")
-		if b == 53
-			$deck.insert(2, $deck.pop)
-		elsif b == 52
-			$deck.insert(1, $deck.delete_at(b))
-		else
-			$deck.insert(b + 2, $deck.delete_at(b))
-		end
-
-		# Step 4
-		a = $deck.index("A")
-		b = $deck.index("B")
-		top = [a, b].min
-		bottom = [a, b].max
-		$deck = $deck.values_at((bottom + 1)..53, top..bottom, 0...top)
-
-		# Step 5
-		if $deck[53].kind_of? Integer
-			$deck = $deck.values_at($deck[53]..52, 0...$deck[53], 53)
-		end
-
-		# Step 5
-		if $deck[0].kind_of? Integer
-			if $deck[$deck[0]].kind_of? Integer
-				key_stream.push($deck[$deck[0]])
-			end
-		else
-			if $deck[53].kind_of? Integer
-				key_stream.push($deck[53])
-			end
-		end
-	end		# Step 7
-
-	key_stream.map! do |number|
-		if number > 26
-			(number - 26 - 1 + ?A).chr
-		else
-			(number - 1 + ?A).chr
-		end
-	end
-	key_stream = key_stream.join("")
-	i = 5
-	while i < key_stream.size
-		key_stream[i, 0] = " "
-		i += 6
-	end
-	return key_stream
-end
-
-# Mind reading interface
-if ARGV.size == 1 and ARGV[0] =~ /^(?:[A-Z]{5} )*[A-Z]{5}$/
-	puts decrypt(ARGV[0])
-elsif ARGV.size == 1
-	puts encrypt(ARGV[0])
-else
-	puts "Usage:  solitaire.rb MESSAGE"
-end

data/lib/quiz1/t/solutions/Jamis Buck/bin/main.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'copland'
-
-libdir = File.join( File.dirname( __FILE__ ), "..", "lib" )
-$: << libdir
-
-registry = Copland::Registry.build libdir, :log_device => STDOUT
-
-cli = registry.service( "solitaire.cipher.CLI" )
-cli.run
-
-registry.shutdown

data/lib/quiz1/t/solutions/Jamis Buck/lib/cipher.rb

@@ -1,230 +0,0 @@
-require 'optparse'
-
-class Deck
-
-  def initialize
-    @deck = (1..52).to_a + [ "A", "B" ]
-    @length = @deck.length
-  end
-
-  def cipher_shuffle!
-    # move joker A down one card, circularly
-    reposition_card( "A", 1 )
-
-    # move joker B down two cards, circularly
-    reposition_card( "B", 2 )
-
-    joker_A = @deck.index( "A" )
-    joker_B = @deck.index( "B" )
-
-    # move all cards above the top-most joker, below the bottom-most joker, and
-    # all cards below the bottom-most joker, above the top-most joker.
-    top    = ( joker_A < joker_B ? joker_A : joker_B )
-    bottom = ( joker_A > joker_B ? joker_A : joker_B )
-    @deck = @deck[bottom+1..-1] + @deck[top..bottom] + @deck[0,top]
-
-    # take value of the bottom-most card, and cut that many cards off the
-    # top, inserting them just before the bottom-most card.
-    cut = @deck.last
-    @deck = @deck[cut..-2] + @deck[0,cut] + [ @deck.last ]
-  end
-
-  def cipher_letter
-    count = @deck.first
-    count = 53 if count.is_a?( String )
-    result = @deck[ count ]
-    return nil unless result.is_a? Fixnum
-    result -= 26 while result > 26
-    return (result+64).chr
-  end
-
-  def to_a
-    @deck.dup
-  end
-
-  def cards=( deck )
-    @deck = deck
-    @length = @deck.length
-    raise "the deck must contain an 'A' joker" unless @deck.include?("A")
-    raise "the deck must contain a 'B' joker" unless @deck.include?("B")
-  end
-
-  def reposition_card( card, delta )
-    pos = @deck.index card
-    @deck.delete_at pos
-    new_pos = pos + delta
-    new_pos = 1 + new_pos % @length if new_pos >= @length
-    @deck.insert new_pos, card
-    new_pos
-  end
-  private :reposition_card
-
-end
-
-class KeyingAlgorithms
-
-  attr_writer :algorithms
-  attr_writer :registry
-
-  def get( name )
-    svc_name = @algorithms[ name ]
-    raise "No such algorithm #{name.inspect}" if svc_name.nil?
-
-    return @registry.service( svc_name )
-  end
-
-end
-
-class UnkeyedAlgorithm
-
-  def new_deck
-    Deck.new
-  end
-
-end
-
-class KeyStream
-
-  attr_writer :deck
-
-  def next
-    loop do
-      @deck.cipher_shuffle!
-      letter = @deck.cipher_letter
-      return letter if letter
-    end
-  end
-
-end
-
-class SolitaireCipher
-
-  attr_writer :algorithms
-  attr_writer :stream
-
-  def initialize( default_algorithm )
-    @algorithm = default_algorithm
-  end
-
-  def use_algorithm( keying_algorithm )
-    @algorithm = @algorithms.get( keying_algorithm )
-  end
-
-  def encrypt( message )
-    reset
-
-    chars = message.split(//).map { |c| c.upcase }. reject { |c| c !~ /[A-Z]/ }
-    chars.concat ["X"] * ( 5 - chars.length % 5 ) if chars.length % 5 > 0
-    chars.map! { |c| c[0] - 64 }
-    key = generate_key( chars.length )
-    code = chars.zip( key ).map { |c,k| ( c + k > 26 ? c + k - 26 : c + k ) }.map { |c| (c+64).chr }
-
-    msg = ""
-    (code.length/5).times do
-      msg << " " if msg.length > 0
-      5.times { msg << code.shift }
-    end
-
-    return msg
-  end
-
-  def decrypt( message )
-    raise "bad decrypt message: #{message.inspect}" if message =~ /[^A-Z ]/
-
-    reset
-    chars = message.split(//).reject { |c| c == " " }.map { |c| c[0] - 64 }
-    key = generate_key( chars.length )
-    chars.zip( key ).map { |c,k| ( k >= c ? c + 26 - k : c - k ) }.map { |c| (c+64).chr }.join
-  end
-
-  def generate_key( length )
-    key = []
-    length.times { key << @stream.next }
-    key.map { |c| c[0] - 64 }
-  end
-  private :generate_key
-
-  def reset
-    @stream.deck = @algorithm.new_deck
-  end
-  private :reset
-
-end
-
-class Options
-
-  attr_reader :strings
-  attr_reader :keying_algorithm
-
-  def initialize( argv = ARGV )
-    @named_options = Hash.new
-    @run_app = true
-    @keying_algorithm = "unkeyed"
-
-    OptionParser.new do |opts|
-      opts.banner = "Usage: #{$0} [options] [strings]"
-      opts.separator ""
-
-      opts.on( "-o", "--option NAME=VALUE",
-               "Specify a named value, for use by a component of the cipher."
-      ) do |pair|
-        name, value = pair.split( / *= */, 2 )
-        @named_options[ name ] = value
-      end
-
-      opts.on( "-k", "--key NAME", "Specify the keying algorithm to use" ) do |value|
-        @keying_algorithm = value
-      end
-
-      opts.separator ""
-
-      opts.on_tail( "-h", "--help", "This help text" ) do
-        puts opts
-        @run_app = false
-      end
-
-      opts.parse!( argv )
-    end
-
-    @strings = argv
-  end
-
-  def []( value )
-    @named_options[ value ]
-  end
-
-  def run_app?
-    @run_app
-  end
-
-end
-
-
-class BackwardsAlgorithm
-
-  def new_deck
-    deck = Deck.new
-    deck.cards = deck.to_a.reverse
-    deck
-  end
-
-end
-
-class ShuffleAlgorithm
-
-  attr_writer :options
-
-  def new_deck
-    deck = Deck.new
-    cards = deck.to_a
-
-    seed = ( @options[ "seed" ] || 0 ).to_i
-    srand seed
-
-    7.times { cards.sort! { rand(3)-1 } }
-    deck.cards = cards
-
-    return deck
-  end
-
-end

data/lib/quiz1/t/solutions/Jamis Buck/lib/cli.rb

@@ -1,24 +0,0 @@
-class CLI
-
-  ENCRYPTED = /^([A-Z]{5} )*[A-Z]{5}$/
-
-  attr_writer :cipher
-  attr_writer :options
-
-  def run
-    return unless @options.run_app?
-
-    @cipher.use_algorithm @options.keying_algorithm
-
-    @options.strings.each do |arg|
-      if arg =~ ENCRYPTED
-        puts arg.inspect
-        puts "  (decrypt)--> #{@cipher.decrypt(arg).inspect}"
-      else
-        puts arg.inspect
-        puts "  (encrypt)--> #{@cipher.encrypt(arg).inspect}"
-      end
-    end
-  end
-
-end

data/lib/quiz1/t/solutions/Jamis Buck/test/tc_deck.rb

@@ -1,30 +0,0 @@
-$: << File.join( File.dirname( __FILE__ ), "..", "lib" )
-require 'test/unit'
-require 'cipher'
-
-class TC_Deck < Test::Unit::TestCase
-
-  def setup
-    @deck = Deck.new
-  end
-
-  def test_content
-    expected = (1..52).to_a + [ "A", "B" ]
-    assert_equal expected, @deck.to_a
-  end
-
-  def test_shuffle
-    @deck.cipher_shuffle!
-    expected = (2..52).to_a + [ "A", "B", 1 ]
-    assert_equal expected, @deck.to_a
-  end
-
-  def test_letter
-    expected = %w{ D W J nil X H Y R F D G }
-    expected.each do |expected_letter|
-      @deck.cipher_shuffle!
-      assert_equal expected_letter, @deck.cipher_letter || "nil"
-    end
-  end
-
-end

data/lib/quiz1/t/solutions/Jamis Buck/test/tc_key-stream.rb

@@ -1,19 +0,0 @@
-$: << File.join( File.dirname( __FILE__ ), "..", "lib" )
-require 'test/unit'
-require 'cipher'
-
-class TC_KeyStream < Test::Unit::TestCase
-
-  def setup
-    @stream = KeyStream.new
-    @stream.deck = Deck.new
-  end
-
-  def test_next
-    expected = %w{ D W J X H Y R F D G }
-    expected.each do |expected_letter|
-      assert_equal expected_letter, @stream.next
-    end
-  end
-
-end

data/lib/quiz1/t/solutions/Jamis Buck/test/tc_keying-algorithms.rb

@@ -1,31 +0,0 @@
-$: << File.join( File.dirname( __FILE__ ), "..", "lib" )
-require 'test/unit'
-require 'cipher'
-
-class TC_KeyingAlgorithms < Test::Unit::TestCase
-
-  class MockRegistry
-    def service( name )
-      return "found" if name == "something.mock"
-      return nil
-    end
-  end
-
-  def setup
-    @algorithms = KeyingAlgorithms.new
-    @algorithms.algorithms = { "mock" => "something.mock" }
-    @algorithms.registry = MockRegistry.new
-  end
-
-  def test_get_not_found
-    assert_raise( RuntimeError ) do
-      @algorithms.get( "bogus" )
-    end
-  end
-
-  def test_get_found
-    svc = @algorithms.get( "mock" )
-    assert_equal svc, "found"
-  end
-
-end

data/lib/quiz1/t/solutions/Jamis Buck/test/tc_solitaire-cipher.rb

@@ -1,66 +0,0 @@
-$: << File.join( File.dirname( __FILE__ ), "..", "lib" )
-require 'test/unit'
-require 'cipher'
-
-class TC_SolitaireCipher < Test::Unit::TestCase
-
-  class MockAlgorithms
-    def get( name )
-      MockAlgorithm.new
-    end
-  end
-
-  class MockDeck
-    def cipher_shuffle!
-    end
-
-    def cipher_letter
-      "X"
-    end
-  end
-
-  class MockAlgorithm
-    def new_deck
-      MockDeck.new
-    end
-  end
-
-  def setup
-    @cipher = SolitaireCipher.new( UnkeyedAlgorithm.new )
-    @cipher.algorithms = MockAlgorithms.new
-    @cipher.stream = KeyStream.new
-  end
-
-  def test_use_algorithm
-    @cipher.use_algorithm "mock"
-    assert_equal "FCJJM", @cipher.encrypt( "HELLO" )
-    assert_equal "JGNNQ", @cipher.decrypt( "HELLO" )
-  end
-
-  def test_encrypt
-    msg = "Code in Ruby! Live longer."
-    expected = "GLNCQ MJAFF FVOMB JIYCB"
-    assert_equal expected, @cipher.encrypt( msg )
-  end
-
-  def test_decrypt_bad
-    assert_raise( RuntimeError ) do
-      @cipher.decrypt( "not good" )
-    end
-
-    assert_raise( RuntimeError ) do
-      @cipher.decrypt( "BOGUS 12345" )
-    end
-  end
-
-  def test_decrypt_good
-    msg = "CLEPK HHNIY CFPWH FDFEH"
-    expected = "YOURCIPHERISWORKINGX"
-    assert_equal expected, @cipher.decrypt( msg )
-
-    msg = "ABVAW LWZSY OORYK DUPVH"
-    expected = "WELCOMETORUBYQUIZXXX"
-    assert_equal expected, @cipher.decrypt( msg )
-  end
-
-end

data/lib/quiz1/t/solutions/Jamis Buck/test/tc_unkeyed-algorithm.rb

@@ -1,17 +0,0 @@
-$: << File.join( File.dirname( __FILE__ ), "..", "lib" )
-require 'test/unit'
-require 'cipher'
-
-class TC_UnkeyedAlgorithm < Test::Unit::TestCase
-
-  def setup
-    @algo = UnkeyedAlgorithm.new
-  end
-
-  def test_new_deck
-    expected = (1..52).to_a + [ "A", "B" ]
-    deck = @algo.new_deck
-    assert_equal expected, deck.to_a
-  end
-
-end

data/lib/quiz1/t/solutions/Jamis Buck/test/tests.rb

@@ -1,2 +0,0 @@
-Dir.chdir File.dirname( __FILE__ )
-Dir["tc_*.rb"].each { |test| load test }