My solution.

----------------------------------------------------------------------

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()