enigma_machine 0.0.1.alpha1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in enigma_machine.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/enigma_machine.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "enigma_machine/version"
+
+Gem::Specification.new do |s|
+  s.name        = "enigma_machine"
+  s.version     = EnigmaMachine::VERSION
+  s.authors     = ["Alex Tomlins"]
+  s.email       = ["alex@tomlins.org.uk"]
+  s.homepage    = "https://github.com/alext/enigma_machine"
+  s.summary     = %q{Enigma machine simulator}
+  s.description = %q{Enigma machine simulator}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+end

data/lib/enigma_machine/plugboard.rb

@@ -0,0 +1,31 @@
+class EnigmaMachine
+  class Plugboard
+    def initialize(mapping_pairs, decorated)
+      build_mapping(mapping_pairs)
+      @decorated = decorated
+    end
+
+    def translate(letter)
+      step = substitute(letter)
+      step = @decorated.translate(step)
+      substitute(step)
+    end
+
+    def substitute(letter)
+      @mapping[letter] || letter
+    end
+
+    private
+
+    def build_mapping(letter_pairs)
+      @mapping = {}
+      letter_pairs.each do |pair|
+        raise ConfigurationError unless pair =~ /\A[A-Z]{2}\z/
+        a, b = pair.split('')
+        raise ConfigurationError if @mapping[a] or @mapping[b]
+        @mapping[a] = b
+        @mapping[b] = a
+      end
+    end
+  end
+end

data/lib/enigma_machine/reflector.rb

@@ -0,0 +1,22 @@
+class EnigmaMachine
+  class Reflector < Plugboard
+    STANDARD_MAPPINGS = {
+      :A => %w(AE BJ CM DZ FL GY HX IV KW NR OQ PU ST),
+      :B => %w(AY BR CU DH EQ FS GL IP JX KN MO TZ VW),
+      :C => %w(AF BV CP DJ EI GO HY KR LZ MX NW TQ SU),
+      :Bthin => %w(AE BN CK DQ FU GY HW IJ LO MP RX SZ TV),
+      :Cthin => %w(AR BD CO EJ FN GT HK IV LM PW QZ SX UY),
+    }
+
+    def initialize(mapping)
+      if mapping.is_a?(Symbol)
+        raise ConfigurationError unless STANDARD_MAPPINGS.has_key?(mapping)
+        mapping = STANDARD_MAPPINGS[mapping]
+      end
+      raise ConfigurationError unless mapping.length == 13
+      build_mapping(mapping)
+    end
+
+    alias :translate :substitute
+  end
+end

data/lib/enigma_machine/rotor.rb

@@ -0,0 +1,70 @@
+class EnigmaMachine
+  class Rotor
+    STANDARD_ROTORS = {
+      :i      => "EKMFLGDQVZNTOWYHXUSPAIBRCJ_A",
+      :ii     => "AJDKSIRUXBLHWTMCQGZNPYFVOE_A",
+      :iii    => "BDFHJLCPRTXVZNYEIWGAKMUSQO_A",
+      :iv     => "ESOVPZJAYQUIRHXLNFTGKDCMWB_A",
+      :v      => "VZBRGITYUPSDNHLXAWMJQOFECK_A",
+      :vi     => "JPGVOUMFYQBENHZRDKASXLICTW_A",
+      :vii    => "NZJHGRCXMYSWBOUFAIVLPEKQDT_A",
+      :viii   => "FKQHTLXOCBJSPDZRAMEWNIUYGV_A",
+      :beta   => "LEYJVCNIXWPBQMDRTAKZGFUHOS_A",
+      :gamma  => "FSOKANUERHMBTIYCWLQPZXVGJD_A",
+    }
+
+    def initialize(rotor_spec, ring_setting, decorated)
+      if rotor_spec.is_a?(Symbol)
+        raise ConfigurationError unless STANDARD_ROTORS.has_key?(rotor_spec)
+        rotor_spec = STANDARD_ROTORS[rotor_spec]
+      end
+      mapping, step_points = rotor_spec.split('_', 2)
+      @mapping = mapping.each_char.map {|c| ALPHABET.index(c) }
+      @ring_offset = ring_setting - 1
+      @decorated = decorated
+      self.position = 'A'
+    end
+
+    def position=(letter)
+      @position = ALPHABET.index(letter)
+    end
+    def position
+      ALPHABET[@position]
+    end
+
+    def advance_position
+      @position = (@position + 1).modulo(26)
+    end
+
+    def forward(letter)
+      index = add_offset ALPHABET.index(letter)
+      new_index = sub_offset @mapping[index]
+      ALPHABET[new_index]
+    end
+
+    def reverse(letter)
+      index = add_offset ALPHABET.index(letter)
+      new_index = sub_offset @mapping.index(index)
+      ALPHABET[new_index]
+    end
+
+    def translate(input)
+      step = forward(input)
+      step = @decorated.translate(step)
+      reverse(step)
+    end
+
+    private
+
+    def rotor_offset
+      @position - @ring_offset
+    end
+
+    def add_offset(number)
+      (number + rotor_offset).modulo(26)
+    end
+    def sub_offset(number)
+      (number - rotor_offset).modulo(26)
+    end
+  end
+end

data/lib/enigma_machine/version.rb

@@ -0,0 +1,3 @@
+class EnigmaMachine
+  VERSION = "0.0.1.alpha1"
+end

data/lib/enigma_machine.rb

@@ -0,0 +1,48 @@
+class EnigmaMachine
+  ConfigurationError = Class.new(StandardError)
+
+  ALPHABET = ('A'..'Z').to_a
+
+  def initialize(config)
+    @reflector = Reflector.new config[:reflector]
+    @rotors = []
+    config[:rotors].inject(@reflector) do |previous, rotor_config|
+      Rotor.new(*rotor_config, previous).tap {|r| @rotors << r }
+    end
+    @plugboard = Plugboard.new(config[:plug_pairs] || [], @rotors.last)
+  end
+
+  def set_rotors(*positions)
+    positions.each_with_index do |position, i|
+      @rotors[i].position = position
+    end
+  end
+
+  def press_key(letter)
+    advance_rotors
+    @plugboard.translate(letter)
+  end
+
+  def translate(message)
+    message.upcase.each_char.map do |letter|
+      case letter
+      when /[A-Z]/
+        press_key(letter)
+      when ' '
+        ' '
+      end
+    end.join
+  end
+
+  private
+
+  def advance_rotors
+    # Temporarily only advance right rotor
+    @rotors[-1].advance_position
+  end
+end
+
+require 'enigma_machine/version'
+require 'enigma_machine/plugboard'
+require 'enigma_machine/rotor'
+require 'enigma_machine/reflector'

data/spec/enigma_machine_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe EnigmaMachine do
+
+  describe "creating an instance" do
+    it "should construct the reflector, rotors and plug_board and connect them together" do
+      EnigmaMachine::Reflector.should_receive(:new).with(:foo).and_return(:reflector)
+      EnigmaMachine::Rotor.should_receive(:new).with(:i, 1, :reflector).and_return(:left_rotor)
+      EnigmaMachine::Rotor.should_receive(:new).with(:ii, 2, :left_rotor).and_return(:middle_rotor)
+      EnigmaMachine::Rotor.should_receive(:new).with(:iii, 3, :middle_rotor).and_return(:right_rotor)
+      EnigmaMachine::Plugboard.should_receive(:new).with([1,2,3], :right_rotor).and_return(:plugboard)
+
+      EnigmaMachine.new(:reflector => :foo, :rotors => [[:i, 1], [:ii, 2], [:iii, 3]], :plug_pairs => [1,2,3])
+    end
+
+    it "should create a null plugboard if none specified" do
+      EnigmaMachine::Reflector.stub!(:new)
+      EnigmaMachine::Rotor.stub!(:new)
+      EnigmaMachine::Plugboard.should_receive(:new).with([], anything())
+
+      EnigmaMachine.new(:reflector => :foo, :rotors => [[:i, 1], [:ii, 2], [:iii, 3]])
+    end
+  end
+
+  describe "setting rotor positions" do
+    before :each do
+      @left_rotor = mock("Rotor")
+      @middle_rotor = mock("Rotor")
+      @right_rotor = mock("Rotor")
+      EnigmaMachine::Rotor.stub!(:new).with(:i, anything(), anything()).and_return(@left_rotor)
+      EnigmaMachine::Rotor.stub!(:new).with(:ii, anything(), anything()).and_return(@middle_rotor)
+      EnigmaMachine::Rotor.stub!(:new).with(:iii, anything(), anything()).and_return(@right_rotor)
+      EnigmaMachine::Reflector.stub!(:new)
+      EnigmaMachine::Plugboard.stub!(:new)
+
+      @e = EnigmaMachine.new(:rotors => [[:i,1], [:ii,2], [:iii,3]])
+    end
+
+    it "should set the position of each rotor" do
+      @left_rotor.should_receive(:position=).with('A')
+      @middle_rotor.should_receive(:position=).with('B')
+      @right_rotor.should_receive(:position=).with('C')
+
+      @e.set_rotors('A', 'B', 'C')
+    end
+  end
+
+  describe "processing a message" do
+    before :each do
+      EnigmaMachine::Reflector.stub!(:new)
+      EnigmaMachine::Rotor.stub!(:new)
+      EnigmaMachine::Plugboard.stub!(:new)
+
+      @e = EnigmaMachine.new(:rotors => [:a, :b, :c])
+      @e.stub!(:press_key).and_return('Z')
+    end
+
+    it "should call press_key for each letter in order, and return the results" do
+      @e.should_receive(:press_key).with('A').ordered.and_return('B')
+      @e.should_receive(:press_key).with('B').ordered.and_return('C')
+      @e.should_receive(:press_key).with('C').ordered.and_return('D')
+
+      @e.translate('ABC').should == 'BCD'
+    end
+
+    it "should pass through spaces unmodified" do
+      @e.should_not_receive(:press_key).with(' ')
+
+      @e.translate('ABC DEF').should == 'ZZZ ZZZ'
+    end
+
+    it "should upcase the input before passing to press_key" do
+      @e.should_receive(:press_key).with('A').ordered.and_return('B')
+      @e.should_receive(:press_key).with('B').ordered.and_return('C')
+      @e.should_receive(:press_key).with('C').ordered.and_return('D')
+
+      @e.translate('aBc').should == 'BCD'
+    end
+
+    it "should discard any other characters passed in" do
+      @e.should_not_receive(:press_key).with(/[^A-Z]/)
+
+      @e.translate('A1B3C.D+E%F123').should == 'ZZZZZZ'
+    end
+  end
+
+  describe "processing a letter" do
+    before :each do
+      EnigmaMachine::Reflector.stub!(:new)
+      EnigmaMachine::Rotor.stub!(:new)
+      @plugboard = mock("Plugboard", :translate => 'B')
+      EnigmaMachine::Plugboard.stub!(:new).and_return(@plugboard)
+
+      @e = EnigmaMachine.new(:rotors => [:a, :b, :c])
+      @e.stub!(:advance_rotors)
+    end
+
+    it "should advance the rotors" do
+      @e.should_receive(:advance_rotors)
+
+      @e.press_key('A')
+    end
+
+    it "should call translate on the plugboard, and return the result" do
+      @plugboard.should_receive(:translate).and_return('F')
+
+      @e.press_key('A').should == 'F'
+    end
+  end
+
+  describe "advancing rotors" do
+
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe "Integration tests" do
+
+  describe "basic sample tests" do
+    # taken from http://wiki.franklinheath.co.uk/index.php/Enigma/Paper_Enigma
+
+    it "should translate a message that only needs the right rotor to advance" do
+      e = EnigmaMachine.new(
+        :reflector => :B,
+        :rotors => [[:i, 1], [:ii, 1], [:iii, 1]]
+      )
+      e.set_rotors('A', 'B', 'C')
+
+      e.translate('AEFAE JXXBN XYJTY').should == 'CONGR ATULA TIONS'
+    end
+
+  end
+
+  describe "real world sample messages" do
+    describe "Enigma I/M3" do
+      # Examples taken from http://wiki.franklinheath.co.uk/index.php/Enigma/Sample_Messages
+      specify "Enigma Instruction Manual 1930" do
+        e = EnigmaMachine.new(
+          :reflector => :A,
+          :rotors => [[:ii, 24], [:i, 13], [:iii, 22]],
+          :plug_pairs => %w(AM FI NV PS TU WZ)
+        )
+
+        e.set_rotors('A', 'B', 'L')
+        result = e.translate('GCDSE AHUGW TQGRK VLFGX UCALX VYMIG MMNMF DXTGN VHVRM MEVOU YFZSL RHDRR XFJWC FHUHM UNZEF RDISI KBGPM YVXUZ')
+
+        result.should == 'FEIND LIQEI NFANT ERIEK OLONN EBEOB AQTET XANFA NGSUE DAUSG ANGBA ERWAL DEXEN DEDRE IKMOS TWAER TSNEU STADT'
+        # German: Feindliche Infanterie Kolonne beobachtet. Anfang Südausgang Bärwalde. Ende 3km ostwärts Neustadt.
+        # English: Enemy infantry column was observed. Beginning [at] southern exit [of] Baerwalde. Ending 3km east of Neustadt.
+      end
+
+      specify "Operation Barbarossa, 1941" do
+        e = EnigmaMachine.new(
+          :reflector => :B,
+          :rotors => [[:ii, 2], [:iv, 21], [:v, 12]],
+          :plug_pairs => %w(AV BS CG DL FU HZ IN KM OW RX)
+        )
+
+        e.set_rotors('B', 'L', 'A')
+        result = e.translate('EDPUD NRGYS ZRCXN UYTPO MRMBO FKTBZ REZKM LXLVE FGUEY SIOZV EQMIK UBPMM YLKLT TDEIS MDICA GYKUA CTCDO MOHWX MUUIA UBSTS LRNBZ SZWNR FXWFY SSXJZ VIJHI DISHP RKLKA YUPAD TXQSP INQMA TLPIF SVKDA SCTAC DPBOP VHJK-')
+        result.should == 'AUFKL XABTE ILUNG XVONX KURTI NOWAX KURTI NOWAX NORDW ESTLX SEBEZ XSEBE ZXUAF FLIEG ERSTR ASZER IQTUN GXDUB ROWKI XDUBR OWKIX OPOTS CHKAX OPOTS CHKAX UMXEI NSAQT DREIN ULLXU HRANG ETRET ENXAN GRIFF XINFX RGTX-'
+
+        e.set_rotors('L', 'S', 'D')
+        result = e.translate('SFBWD NJUSE GQOBH KRTAR EEZMW KPPRB XOHDR OEQGB BGTQV PGVKB VVGBI MHUSZ YDAJQ IROAX SSSNR EHYGG RPISE ZBOVM QIEMM ZCYSG QDGRE RVBIL EKXYQ IRGIR QNRDN VRXCY YTNJR')
+        result.should == 'DREIG EHTLA NGSAM ABERS IQERV ORWAE RTSXE INSSI EBENN ULLSE QSXUH RXROE MXEIN SXINF RGTXD REIXA UFFLI EGERS TRASZ EMITA NFANG XEINS SEQSX KMXKM XOSTW XKAME NECXK'
+
+        # German: Aufklärung abteilung von Kurtinowa nordwestlich Sebez [auf] Fliegerstraße in Richtung Dubrowki, Opotschka. Um 18:30 Uhr angetreten angriff. Infanterie Regiment 3 geht langsam aber sicher vorwärts. 17:06 Uhr röm eins InfanterieRegiment 3 auf Fliegerstraße mit Anfang 16km ostwärts Kamenec.
+        # English: Reconnaissance division from Kurtinowa north-west of Sebezh on the flight corridor towards Dubrowki, Opochka. Attack begun at 18:30 hours. Infantry Regiment 3 goes slowly but surely forwards. 17:06 hours [Roman numeral I?] Infantry Regiment 3 on the flight corridor starting 16 km east of Kamenec.
+      end
+
+      specify "Scharnhorst (Konteradmiral Erich Bey), 1943" do
+        e = EnigmaMachine.new(
+          :reflector => :B,
+          :rotors => [[:iii, 1], [:vi, 8], [:viii, 13]],
+          :plug_pairs => %w(AN EZ HK IJ LR MQ OT PV SW UX)
+        )
+
+        e.set_rotors('U', 'Z', 'V')
+        result = e.translate('YKAE NZAP MSCH ZBFO CUVM RMDP YCOF HADZ IZME FXTH FLOL PZLF GGBO TGOX GRET DWTJ IQHL MXVJ WKZU ASTR')
+        result.should == 'STEUE REJTA NAFJO RDJAN STAND ORTQU AAACC CVIER NEUNN EUNZW OFAHR TZWON ULSMX XSCHA RNHOR STHCO'
+
+        # German: Steuere Tanafjord an. Standort Quadrat AC4992, fahrt 20sm. Scharnhorst. [hco - padding?]
+        # English: Heading for Tanafjord. Position is square AC4992, speed 20 knots. Scharnhorst.
+      end
+    end
+
+  end
+end

data/spec/plugboard_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe EnigmaMachine::Plugboard do
+
+  describe "configuring a plugboard" do
+    it "should raise an error if passing in anything other than an array of upper case letter pairs" do
+      lambda do
+        EnigmaMachine::Plugboard.new(%w(AB CDE FG), :decorated)
+      end.should raise_error(EnigmaMachine::ConfigurationError)
+
+      lambda do
+        EnigmaMachine::Plugboard.new(%w(AB cd FG), :decorated)
+      end.should raise_error(EnigmaMachine::ConfigurationError)
+    end
+
+    it "should raise an error if attempting to connect more than one wire to a letter" do
+      lambda do
+        EnigmaMachine::Plugboard.new(%w(AB CD GC), :decorated)
+      end.should raise_error(EnigmaMachine::ConfigurationError)
+    end
+  end
+
+  describe "substituting a letter" do
+    before :each do
+      @p = EnigmaMachine::Plugboard.new(%w(AF DG EX), :decorated)
+    end
+
+    it "should substitute a letter that has a plug wire connected" do
+      @p.substitute('D').should == 'G'
+    end
+
+    it "should substitute a letter that's on the other end of the wire" do
+      @p.substitute('X').should == 'E'
+    end
+
+    it "should pass through a letter that doesn't have a plug wire connected" do
+      @p.substitute('C').should == 'C'
+    end
+  end
+
+  describe "decorating a rotor" do
+    it "should substitute the latter, pass to the rotor, then substiture the final result" do
+      rotor = stub("Rotor")
+      rotor.should_receive(:translate).with('F').and_return('H')
+
+      plugboard = EnigmaMachine::Plugboard.new(%w(AF DG EX ZH), rotor)
+      plugboard.translate('A').should == 'Z'
+    end
+  end
+end

data/spec/reflector_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe EnigmaMachine::Reflector do
+
+  describe "configuring a reflector" do
+    it "should raise an error if passing in anything other than an array of upper case letter pairs" do
+      lambda do
+        EnigmaMachine::Reflector.new(%w(AY BRC U DH EQ FS GL IP JX KN MO TZ VW))
+      end.should raise_error(EnigmaMachine::ConfigurationError)
+
+      lambda do
+        EnigmaMachine::Reflector.new(%w(AY BR cu DH EQ FS GL IP JX KN MO TZ VW))
+      end.should raise_error(EnigmaMachine::ConfigurationError)
+    end
+
+    it "should raise an error if attempting to connect more than one wire to a letter" do
+      lambda do
+        EnigmaMachine::Reflector.new(%w(AY BR CB DH EQ FS GL IP JX KN MO TZ VW))
+      end.should raise_error(EnigmaMachine::ConfigurationError)
+    end
+
+    it "should raise an error unless all 26 letters are configured" do
+      lambda do
+        EnigmaMachine::Reflector.new(%w(AY BR CU DH EQ FS GL IP JX KN MO TZ))
+      end.should raise_error(EnigmaMachine::ConfigurationError)
+    end
+
+    describe "using one of the standard configurations" do
+      it "should raise an error if using an unknown name" do
+        lambda do
+          EnigmaMachine::Reflector.new(:foo)
+        end.should raise_error(EnigmaMachine::ConfigurationError)
+      end
+
+      it "should support reflector A" do
+        r = EnigmaMachine::Reflector.new(:A)
+        r.translate('A').should == 'E'
+        r.translate('F').should == 'L'
+        r.translate('Q').should == 'O'
+      end
+
+      it "should support reflector B" do
+        r = EnigmaMachine::Reflector.new(:B)
+        r.translate('A').should == 'Y'
+        r.translate('F').should == 'S'
+        r.translate('Q').should == 'E'
+      end
+
+      it "should support reflector C" do
+        r = EnigmaMachine::Reflector.new(:C)
+        r.translate('A').should == 'F'
+        r.translate('K').should == 'R'
+        r.translate('Q').should == 'T'
+      end
+
+      it "should support reflector Bthin" do
+        r = EnigmaMachine::Reflector.new(:Bthin)
+        r.translate('A').should == 'E'
+        r.translate('F').should == 'U'
+        r.translate('P').should == 'M'
+      end
+
+      it "should support reflector Cthin" do
+        r = EnigmaMachine::Reflector.new(:Cthin)
+        r.translate('A').should == 'R'
+        r.translate('K').should == 'H'
+        r.translate('Q').should == 'Z'
+      end
+    end
+  end
+
+  describe "translating letters" do
+    before :each do
+      @reflector = EnigmaMachine::Reflector.new(%w(AY BR CU DH EQ FS GL IP JX KN MO TZ VW))
+    end
+
+    it "should substitute a letter that's first in a pair" do
+      @reflector.translate('B').should == 'R'
+    end
+
+    it "should substitute a letter that's second in a pair" do
+      @reflector.translate('L').should == 'G'
+    end
+  end
+end

data/spec/rotor_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe EnigmaMachine::Rotor do
+
+  describe "configuring a rotor" do
+    describe "using one of the standard configurations" do
+      it "should raise an error if using an unknown name" do
+        lambda do
+          EnigmaMachine::Rotor.new(:foo, 1, :next)
+        end.should raise_error(EnigmaMachine::ConfigurationError)
+      end
+
+      it "should support rotor i" do
+        r = EnigmaMachine::Rotor.new(:i, 1, :next)
+        r.forward('A').should == 'E'
+        r.forward('Q').should == 'X'
+      end
+
+      it "should support rotor ii" do
+        r = EnigmaMachine::Rotor.new(:ii, 1, :next)
+        r.forward('A').should == 'A'
+        r.forward('M').should == 'W'
+      end
+
+      it "should support rotor iii" do
+        r = EnigmaMachine::Rotor.new(:iii, 1, :next)
+        r.forward('A').should == 'B'
+        r.forward('Q').should == 'I'
+      end
+
+      it "should support rotor iv" do
+        r = EnigmaMachine::Rotor.new(:iv, 1, :next)
+        r.forward('A').should == 'E'
+        r.forward('Q').should == 'N'
+      end
+
+      it "should support rotor v" do
+        r = EnigmaMachine::Rotor.new(:v, 1, :next)
+        r.forward('A').should == 'V'
+        r.forward('Q').should == 'A'
+      end
+
+      it "should support rotor vi" do
+        r = EnigmaMachine::Rotor.new(:vi, 1, :next)
+        r.forward('A').should == 'J'
+        r.forward('Q').should == 'D'
+      end
+
+      it "should support rotor vii" do
+        r = EnigmaMachine::Rotor.new(:vii, 1, :next)
+        r.forward('A').should == 'N'
+        r.forward('Q').should == 'A'
+      end
+
+      it "should support rotor viii" do
+        r = EnigmaMachine::Rotor.new(:viii, 1, :next)
+        r.forward('A').should == 'F'
+        r.forward('Q').should == 'A'
+      end
+
+      it "should support rotor beta" do
+        r = EnigmaMachine::Rotor.new(:beta, 1, :next)
+        r.forward('A').should == 'L'
+        r.forward('Q').should == 'T'
+      end
+
+      it "should support rotor gamma" do
+        r = EnigmaMachine::Rotor.new(:gamma, 1, :next)
+        r.forward('A').should == 'F'
+        r.forward('Q').should == 'W'
+      end
+    end
+  end
+  describe "setting and manipulating rotor positions" do
+    before :each do
+      @rotor = EnigmaMachine::Rotor.new("ABCD", 1, :foo)
+    end
+
+    it "should set the position to 'A' by default" do
+      @rotor.position.should == 'A'
+    end
+
+    it "should allow setting the position" do
+      @rotor.position = 'G'
+      @rotor.position.should == 'G'
+    end
+
+    describe "advancing the position" do
+      it "should allow advancing the position" do
+        @rotor.advance_position
+        @rotor.position.should == 'B'
+      end
+
+      it "should wrap around when advancing beyond 'Z'" do
+        @rotor.position = 'Z'
+        @rotor.advance_position
+        @rotor.position.should == 'A'
+      end
+    end
+  end
+
+  describe "forward and reverse translation" do
+    context "with a ring-setting of 1 (no adjustment), and a rotor position of A (the default)" do
+      before :each do
+        @rotor = EnigmaMachine::Rotor.new("EKMFLGDQVZNTOWYHXUSPAIBRCJ_R", 1, :decorated)
+      end
+
+      it "should translate letters correctly in the forward direction" do
+        @rotor.forward("B").should == "K"
+        @rotor.forward("Y").should == "C"
+      end
+
+      it "should translate letters correctly in the reverse direction" do
+        @rotor.reverse("L").should == "E"
+        @rotor.reverse("C").should == "Y"
+      end
+    end
+
+    context "with a ring-setting of 5, and a rotor position of A (the default)" do
+      before :each do
+        @rotor = EnigmaMachine::Rotor.new("EKMFLGDQVZNTOWYHXUSPAIBRCJ_R", 5, :decorated)
+      end
+
+      it "should translate letters correctly in the forward direction" do
+        @rotor.forward("B").should == "V"
+        @rotor.forward("U").should == "B"
+      end
+
+      it "should translate letters correctly in the reverse direction" do
+        @rotor.reverse("F").should == "A"
+        @rotor.reverse("C").should == "S"
+      end
+    end
+
+    context "with a ring-setting of 1 (no adjustment), and a rotor position of L" do
+      before :each do
+        @rotor = EnigmaMachine::Rotor.new("EKMFLGDQVZNTOWYHXUSPAIBRCJ_R", 1, :decorated)
+        @rotor.position = 'L'
+      end
+
+      it "should translate letters correctly in the forward direction" do
+        @rotor.forward("B").should == "D"
+        @rotor.forward("Y").should == "O"
+      end
+
+      it "should translate letters correctly in the reverse direction" do
+        @rotor.reverse("L").should == "C"
+        @rotor.reverse("V").should == "U"
+      end
+    end
+
+    context "with a ring-setting of 5, and a rotor position of T" do
+      before :each do
+        @rotor = EnigmaMachine::Rotor.new("EKMFLGDQVZNTOWYHXUSPAIBRCJ_R", 5, :decorated)
+        @rotor.position = 'T'
+      end
+
+      it "should translate letters correctly in the forward direction" do
+        @rotor.forward("B").should == "I"
+        @rotor.forward("Y").should == "H"
+      end
+
+      it "should translate letters correctly in the reverse direction" do
+        @rotor.reverse("L").should == "F"
+        @rotor.reverse("V").should == "M"
+      end
+
+    end
+  end
+
+  describe "decorating a reflector" do
+    it "should substitute the letter, pass to the rotor, then substitute the final result" do
+      reflector = stub("Reflector")
+      reflector.should_receive(:translate).with('D').and_return('H')
+
+      rotor = EnigmaMachine::Rotor.new("EKMFLGDQVZNTOWYHXUSPAIBRCJ_R", 1, reflector)
+      rotor.translate('G').should == 'P'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end
+
+$: << '../lib'
+require 'enigma_machine'

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: enigma_machine
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha1
+  prerelease: 6
+platform: ruby
+authors:
+- Alex Tomlins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &13890560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13890560
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &13890040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13890040
+description: Enigma machine simulator
+email:
+- alex@tomlins.org.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- enigma_machine.gemspec
+- lib/enigma_machine.rb
+- lib/enigma_machine/plugboard.rb
+- lib/enigma_machine/reflector.rb
+- lib/enigma_machine/rotor.rb
+- lib/enigma_machine/version.rb
+- spec/enigma_machine_spec.rb
+- spec/integration_spec.rb
+- spec/plugboard_spec.rb
+- spec/reflector_spec.rb
+- spec/rotor_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alext/enigma_machine
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1944969372318025887
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Enigma machine simulator
+test_files: []