rotor_machine 1.0.9 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53a47ea917f9a4bc9c40c87c09a9c768d5481ab93eb185132453b982efcfd4c8
-  data.tar.gz: 6d21d443a973ac550b2e3e191b5394dd5f5ea1a94ea765c2753a787fda1ea3dd
+  metadata.gz: 33525b02fa9c5e61d56bb3067a51ae60ce50fd412d1836786fa30e940c9e9950
+  data.tar.gz: 98e386fcbf3d6bca1a1a69c9e362f14239358c899082f826fc11abec0a1275a1
 SHA512:
-  metadata.gz: 4527027053efa3f730f3704538bc26f84211206e0a68abab1180b0dd97ae1b6586b75ba550da59f721f35cdf014c3dc9fa7f186d753b7f87098ee4440a6e5579
-  data.tar.gz: 280fb74f5667d05b3d4142d89b80b065bcc54e7a23c31260c9c4ea2499a5ae8bdcfb1d15e1f75066398eb11ab64829965946b9899b874e3d50ed615402e7406d
+  metadata.gz: 82cc734ccd263bd2c337852db5cd7ab89bef8f684da390689940875714187c81fc5de77d357fa4484368eae4a7c4819ba40d12e98aff239c310cf9e61297b4e0
+  data.tar.gz: d0f5dcecf48866ff9f0d903ae7c849f7b5cb0dd9dbb6cf18c832cee1db99aea8a7caa225b95cc561ddd897440493b59573a07db24fdfed94e3d3344b0dae5a05

data/Guardfile

@@ -0,0 +1,40 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/lib/rotor_machine/factory.rb

@@ -0,0 +1,195 @@
+module RotorMachine
+  ##
+  # The {RotorMachine::Factory} provides Factory-pattern helpers to build
+  # various parts of the {RotorMachine} - rotors, reflectors, plugboards,
+  # and fully-configured machines.
+  module Factory
+    extend self
+
+    ##
+    # Build a new {Rotor} and return it.
+    #
+    # The options hash for this method can accept the following named 
+    # arguments:
+    #
+    # `:rotor_kind` - The type of rotor to create. Should be a symbol matching
+    #                 a rotor type constant in the {RotorMachine::Rotor} class,
+    #                 or a 26-character string giving the letter sequence for 
+    #                 the rotor. Defaults to `:ROTOR_1` if not specified.
+    #
+    # `:initial_position` - The initial position of the rotor (0-based
+    #                       numeric position, or a letter on the rotor.) Defaults
+    #                       to 0 if not specified.
+    #
+    # `:step_size` - How many positions the rotor should advance with each
+    #                step. Defaults to 1 if not specified.
+    #
+    # @param options [Hash] The options hash containing the options for the
+    #                       rotor.
+    # @return The newly-built rotor.
+    def build_rotor(options={})
+      rotor_kind         = options.fetch(:rotor_kind,         :ROTOR_I)
+      initial_position   = options.fetch(:initial_position,   0)
+      step_size          = options.fetch(:step_size,          1)
+
+      rotor_alphabet = nil
+
+      if (rotor_kind.class.name == "Symbol")
+        raise ArgumentError, "Invalid rotor kind (symbol #{rotor_kind} not found)" unless RotorMachine::Rotor.constants.include?(rotor_kind)
+        rotor_alphabet = RotorMachine::Rotor.const_get(rotor_kind)
+      elsif (rotor_kind.class.name == "String")
+        raise ArgumentError, "Invalid rotor kind (invalid length)" unless rotor_kind.length == 26
+        rotor_alphabet = rotor_kind.upcase
+      else
+        raise ArgumentError, "Invalid rotor kind (invalid type #{rotor_kind.class.name})"
+      end
+
+      if initial_position.is_a? Numeric
+        raise ArgumentError, "Invalid position (#{initial_position} out of range)" unless ((0..25).include?(initial_position))
+      elsif initial_position.is_a? String
+        unless RotorMachine::Rotor::ALPHABET.include?(initial_position)
+          raise ArgumentError, "Invalid position (invalid letter '#{initial_position}')"
+        end
+      else
+        raise ArgumentError, "Invalid position (invalid type #{initial_position.class.name})"
+      end
+
+      if  step_size.is_a? Numeric
+        raise ArgumentError, "Invalid step size (#{step_size} out of range)" unless ((1..25).include?(step_size))
+      else
+        raise ArgumentError, "Invalid step size (invalid type #{step_size.class.name})"
+      end
+
+      return RotorMachine::Rotor.new(rotor_alphabet, initial_position, step_size)
+    end
+
+    ##
+    # Build a new {Reflector} and return it.
+    #
+    # The options hash for this method can accept the following named 
+    # arguments:
+    #
+    # `:reflector_kind` - The type of reflector to create. Should be a symbol matching
+    #                 a reflector type constant in the {RotorMachine::Reflector} class,
+    #                 or a 26-character string giving the letter sequence for 
+    #                 the reflector. Defaults to `:REFLECTOR_A` if not specified.
+    #
+    # `:initial_position` - The initial position of the reflector (0-based
+    #                       numeric position, or a letter on the rotor.) Defaults
+    #                       to 0 if not specified.
+    #
+    # @param options [Hash] The options hash containing the options for the
+    #                       reflector.
+    # @return The newly-built reflector.
+    def build_reflector(options={})
+      reflector_kind     = options.fetch(:reflector_kind,   :REFLECTOR_A)
+      initial_position   = options.fetch(:initial_position, 0)
+
+      reflector_alphabet = nil
+
+      if (reflector_kind.class.name == "Symbol")
+        unless RotorMachine::Reflector.constants.include?(reflector_kind)
+          raise ArgumentError, "Invalid reflector kind (symbol #{reflector_kind} not found)" 
+        end
+        reflector_alphabet = RotorMachine::Reflector.const_get(reflector_kind)
+      elsif (reflector_kind.class.name == "String")
+        raise ArgumentError, "Invalid reflector kind (invalid length)" unless reflector_kind.length == 26
+        reflector_alphabet = reflector_kind.upcase
+      else
+        raise ArgumentError, "Invalid reflector kind (invalid type #{reflector_kind.class.name})"
+      end
+
+      if initial_position.is_a? Numeric
+        raise ArgumentError, "Invalid position (#{initial_position} out of range)" unless ((0..25).include?(initial_position))
+      elsif initial_position.is_a? String
+        unless RotorMachine::Reflector::ALPHABET.include?(initial_position)
+          raise ArgumentError, "Invalid position (invalid letter '#{initial_position}')"
+        end
+        initial_position = reflector_alphabet.index(initial_position)
+      else
+        raise ArgumentError, "Invalid position (invalid type #{initial_position.class.name})"
+      end
+
+      return RotorMachine::Reflector.new(reflector_alphabet, initial_position)
+    end
+
+    ##
+    # Build a new {Plugboard} object and return it.
+    #
+    # @return The newly built plugboard.
+    def build_plugboard(options={})
+      return RotorMachine::Plugboard.new()
+    end
+
+    ##
+    # Build a set of {Rotor}s and return them.
+    #
+    # @param rotors [Array] A list of rotor types. Each type should be either
+    # a symbol corresponding to a constant in the {Rotor} class, or a 26 
+    # character string providing the sequence of letters for the rotor.
+    # @param initial_positions [String] The starting letter to set each rotor
+    # to.
+    # @return [Array] An array of {Rotor} objects.
+    def build_rotor_set(rotors=[], initial_positions=nil)
+      ra = rotors.each.collect { |r| build_rotor(rotor_kind: r) }
+      unless initial_positions.nil?
+        ra.each_with_index do |r, i|
+          unless initial_positions[i].nil?
+            r.position = initial_positions[i] 
+          end
+        end
+      end
+      return ra
+    end
+
+    ##
+    # Build a {Machine} and return it.
+    #
+    # The options hash can provide the following options:
+    #
+    # - `:rotors` - An array of {Rotor} objects. This can be constructed
+    # manually, through multiple calls to {#build_rotor}, or through a single
+    # call to {#build_rotor_set}.
+    # - `:reflector` - A {Reflector object.
+    # - `:connections` - A {Hash} of connections to make on the new {Machine}'s
+    #   {Plugboard}.
+    #
+    # @param options The options for the newly built {Machine}.
+    # @return The newly constructed {Machine}.
+    def build_machine(options={})
+      rotors    = options.fetch(:rotors,        [])
+      reflector = options.fetch(:reflector,     nil)
+      connections = options.fetch(:connections, {})
+
+      m = RotorMachine::Machine.new()
+      rotors.each { |r| m.rotors << r }
+      m.reflector = reflector
+      m.plugboard = RotorMachine::Plugboard.new()
+      unless connections.empty?
+        connections.each { |from, to| m.plugboard.connect(from, to) }
+      end
+
+      return m
+    end
+
+    ##
+    # {make_rotor} is an alias for {build_rotor}
+    alias :make_rotor :build_rotor
+
+    ##
+    # {make_reflector} is an alias for {build_reflector}
+    alias :make_reflector :build_reflector
+
+    ##
+    # {make_plugboard} is an alias for {build_plugboard}
+    alias :make_plugboard :build_plugboard
+
+    ##
+    # {make_machine} is an alias for {build_machine}
+    alias :make_machine :build_machine
+
+    ##
+    # {make_rotor_set} is an alias for {build_rotor_set}
+    alias :make_rotor_set :build_rotor_set
+  end
+end

data/lib/rotor_machine/machine.rb

@@ -88,12 +88,10 @@ module RotorMachine
     # - Reflector A
     # - An empty plugboard with no connections
     def self.default_machine
-       machine = self.empty_machine
-       machine.rotors << RotorMachine::Rotor.new(RotorMachine::Rotor::ROTOR_I, "A", 1)
-       machine.rotors << RotorMachine::Rotor.new(RotorMachine::Rotor::ROTOR_II, "A", 1)
-       machine.rotors << RotorMachine::Rotor.new(RotorMachine::Rotor::ROTOR_III, "A", 1)
-       machine.reflector = RotorMachine::Reflector.new(RotorMachine::Reflector::REFLECTOR_A)
-       machine
+      RotorMachine::Factory.build_machine(
+        rotors: RotorMachine::Factory::build_rotor_set([:ROTOR_I, :ROTOR_II, :ROTOR_III], "AAA"),
+        reflector: RotorMachine::Factory::build_reflector(reflector_kind: :REFLECTOR_A)
+      )
     end
 
     ##
@@ -107,11 +105,7 @@ module RotorMachine
     # A RotorMachine in this state will raise an {ArgumentError} until you
     # outfit it with at least one rotor and a reflector.
     def self.empty_machine
-       machine = RotorMachine::Machine.new()
-       machine.rotors = []
-       machine.reflector = nil
-       machine.plugboard = RotorMachine::Plugboard.new()
-       machine
+      RotorMachine::Factory.build_machine()
     end
 
     ##

data/lib/rotor_machine/plugboard.rb

@@ -40,14 +40,12 @@ module RotorMachine
     # @param to [String] A single-character string designating the end
     #        of the connection.
     def connect(from, to)
-      from.upcase!
-      to.upcase!
-      raise ArgumentError, "#{from} is already connected" if (connected?(from))
-      raise ArgumentError, "#{to} is already connected" if (connected?(to))
-      raise ArgumentError, "#{from} cannot be connected to itself" if (to == from)
+      raise ArgumentError, "#{from.upcase} is already connected" if (connected?(from.upcase))
+      raise ArgumentError, "#{to.upcase} is already connected" if (connected?(to.upcase))
+      raise ArgumentError, "#{from.upcase} cannot be connected to itself" if (to.upcase == from.upcase)
 
-      @connections[from] = to
-      @connections[to] = from
+      @connections[from.upcase] = to.upcase
+      @connections[to.upcase] = from.upcase
     end
 
     ##

data/lib/rotor_machine/reflector.rb

@@ -14,6 +14,11 @@ module RotorMachine
   # be broken.
   class Reflector
 
+    ##
+    # Allow querying the numeric position (ie, the initial position) of the
+    # reflector.
+    attr_reader :position
+
     ##
     # The letter mapping for the German "A" reflector.
     REFLECTOR_A      = "EJMZALYXVBWFCRQUONTSPIKHGD".freeze
@@ -38,6 +43,10 @@ module RotorMachine
     # The letter mapping for the German "ETW" reflector.
     REFLECTOR_ETW    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
 
+    ##
+    # A letter mapping for a passthrough reflector; also used by the RSpec tests
+    ALPHABET        = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
+
     ##
     # Initialize a new {Reflector}.
     #
@@ -50,10 +59,31 @@ module RotorMachine
     #        an additional permutation factor for the encipherment.
     def initialize(selected_reflector, start_position = 0)
       @letters = selected_reflector.chars.freeze
-      @alphabet = REFLECTOR_ETW.chars.freeze
+      @alphabet = ALPHABET.chars.freeze
       @position = start_position
     end
 
+    ##
+    # Set the position of the {Rotor}.
+    #
+    # If a numeric position is provided, an {ArgumentError} will be raised if
+    # the position is outside the bounds of the rotor. If an alphabetic position
+    # is provided, an {ArgumentError} will be raised if the supplied character
+    # is not a character represented on the rotor.
+    #
+    # @param pos [Numeric, String] The position of the rotor.
+    def position=(pos)
+      if pos.class.to_s == "String"
+        raise ArgumentError, "#{pos[0]} is not a character on the rotor" unless @letters.include?(pos[0])
+        @position = @letters.index(pos[0])
+      elsif pos.class.to_s == "Integer"
+        raise ArgumentError, "Position #{pos} is invalid" if (pos < 0 or pos > @letters.length)
+        @position = pos
+      else
+        raise ArgumentError, "Invalid argument to position= (#{pos.class.to_s})"
+      end
+    end
+
     ##
     # Feed a sequence of characters through the reflector, and return the
     # results.
@@ -65,11 +95,11 @@ module RotorMachine
     # @return [String] The results of passing the input string through the
     #         {Reflector}.
     def reflect(input)
-      input.upcase.chars.each.collect { |c| 
-        if @alphabet.include?(c) then 
-          @letters[(@alphabet.index(c) + @position) % @alphabet.length] 
-        else 
-          c 
+      input.upcase.chars.each.collect { |c|
+        if @alphabet.include?(c) then
+          @letters[(@alphabet.index(c) + @position) % @alphabet.length]
+        else
+          c
         end }.join("")
     end
 
@@ -86,6 +116,14 @@ module RotorMachine
       return :CUSTOM
     end
 
+    ##
+    # Get the current letter position of the rotor.
+    #
+    # @return [String] The current letter position of the rotor.
+    def current_letter
+      @letters[self.position]
+    end
+
     ##
     # Return a human-readable representation of the {Reflector}
     #

data/lib/rotor_machine/version.rb

@@ -1,4 +1,4 @@
 module RotorMachine
-	VERSION_DATA = [1, 0, 9]
+	VERSION_DATA = [1, 0, 10]
 	VERSION = VERSION_DATA.join(".")
 end

data/rotor_machine.gemspec

@@ -26,4 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rotor_machine
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.0.10
 platform: ruby
 authors:
 - Tammy Cravit
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-09 00:00:00.000000000 Z
+date: 2018-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tcravit_ruby_lib
@@ -80,6 +80,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - tammycravit@me.com
@@ -94,6 +122,7 @@ files:
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -103,6 +132,7 @@ files:
 - images/Bundesarchiv_Enigma.jpg
 - images/File:Enigma_wiring_kleur.png
 - lib/rotor_machine.rb
+- lib/rotor_machine/factory.rb
 - lib/rotor_machine/machine.rb
 - lib/rotor_machine/plugboard.rb
 - lib/rotor_machine/reflector.rb