robodog 0.0.1

data/lib/robo_dog/paddock.rb

@@ -0,0 +1,31 @@
+module RoboDog
+  class Paddock
+
+    DataError = Class.new(StandardError)
+
+    def self.build(string)
+      raise DataError unless validate(string)
+
+      x, y = string.split(' ').map(&:to_i)
+
+      new(x, y)
+    end
+
+    def initialize(x_size = 1, y_size = 1)
+      @x_size = x_size
+      @y_size = y_size
+    end
+
+    def valid_coordinates?(coordinates)
+      coordinates && (0..x_size).include?(coordinates[:x]) && (0..y_size).include?(coordinates[:y])
+    end
+
+    private
+
+    attr_reader :x_size, :y_size
+
+    def self.validate(string)
+      string =~ /\A\d+ \d+\z/
+    end
+  end
+end

data/lib/robo_dog/parser.rb

@@ -0,0 +1,53 @@
+require_relative 'paddock'
+require_relative 'robot'
+
+module RoboDog
+  module Parser
+    DataError = Class.new(StandardError)
+
+    @paddock_factory = Paddock
+    @robot_factory = Robot
+
+    @extractor = -> (input) { e = input.gets and e.chomp }
+
+    @paddock_parser = lambda do |input|
+      paddock_attrs = @extractor.call(input)
+
+      raise DataError unless paddock_attrs
+
+      paddock = @paddock_factory.build(paddock_attrs)
+    end
+
+    @robot_extractor = lambda do |input|
+      pose = @extractor.call(input)
+      commands = @extractor.call(input)
+
+      if pose && commands
+        {
+          pose: pose,
+          commands: commands
+        }
+      else
+        raise DataError unless pose.nil? && commands.nil?
+        nil
+      end
+    end
+
+    module_function
+
+    def parse(input)
+      paddock = @paddock_parser.call(input)
+      robots = []
+      loop do
+        robot_attrs = @robot_extractor.call(input)
+        break unless robot_attrs
+        robots << @robot_factory.build(robot_attrs)
+      end
+
+      {
+        paddock: paddock,
+        robots: robots
+      }
+    end
+  end
+end

data/lib/robo_dog/pose.rb

@@ -0,0 +1,97 @@
+require_relative 'pose/orientation'
+
+module RoboDog
+  class Pose
+    DataError = Class.new(StandardError)
+
+    def self.build(string)
+      raise DataError unless validate(string)
+
+      new(parse(string))
+    end
+
+    def initialize(args = {})
+      @x = args[:x] || 0
+      @y = args[:y] || 0
+      @orientation = args[:orientation] || Orientation::NORTH
+    end
+
+    def report
+      coordinates.merge(
+        orientation: Orientation.stringify(orientation)
+      )
+    end
+
+    def coordinates
+      {x: x, y: y}
+    end
+
+    def adjacent
+      dup.send(:adjacent!)
+    end
+
+    def rotate!(direction = :clockwise)
+      self.orientation = next_orientation(direction)
+      self
+    end
+
+    private
+
+    attr_accessor :x, :y, :orientation
+
+    def self.validate(string)
+      string =~ /\A\d+ \d+ [NSWE]\z/
+    end
+
+    def self.parse(string)
+      x_str, y_str, orientation_str = string.split(' ')
+      x, y = x_str.to_i, y_str.to_i
+      orientation = Orientation.constantize(orientation_str)
+
+      {
+        x: x,
+        y: y,
+        orientation: orientation
+      }
+    end
+
+    def next_orientation(direction)
+      by = direction == :clockwise ? 1 : -1
+
+      orientations = [
+        Orientation::NORTH,
+        Orientation::EAST,
+        Orientation::SOUTH,
+        Orientation::WEST
+      ]
+
+      orientations[(orientations.index(orientation) + by) % 4]
+    end
+
+    def adjacent!
+      case orientation
+      when Orientation::EAST
+        increment!(:x)
+      when Orientation::NORTH
+        increment!(:y)
+      when Orientation::WEST
+        decrement!(:x)
+      when Orientation::SOUTH
+        decrement!(:y)
+      end
+      self
+    end
+
+    def increment!(coordinate)
+      update_coordinate!(coordinate, 1)
+    end
+
+    def decrement!(coordinate)
+      update_coordinate!(coordinate, -1)
+    end
+
+    def update_coordinate!(coordinate, by = 1)
+      self.send("#{coordinate}=", self.send(coordinate) + by)
+    end
+  end
+end

data/lib/robo_dog/pose/orientation.rb

@@ -0,0 +1,38 @@
+module RoboDog
+  class Pose
+    module Orientation
+      NORTH = :north
+      EAST = :east
+      SOUTH = :south
+      WEST = :west
+
+      module_function
+
+      def constantize(string)
+        case string
+        when 'N'
+          NORTH
+        when 'E'
+          EAST
+        when 'S'
+          SOUTH
+        when 'W'
+          WEST
+        end
+      end
+
+      def stringify(orientation)
+        case orientation
+        when NORTH
+          'N'
+        when EAST
+          'E'
+        when SOUTH
+          'S'
+        when WEST
+          'W'
+        end
+      end
+    end
+  end
+end

data/lib/robo_dog/robot.rb

@@ -0,0 +1,88 @@
+require_relative 'pose'
+require 'forwardable'
+
+module RoboDog
+  class Robot
+    extend Forwardable
+
+    DataError = Class.new(StandardError)
+
+    def_delegators :@pose, :report, :coordinates
+
+    def self.build(attrs)
+      raise DataError unless validate(attrs[:commands])
+
+      pose = Pose.build(attrs[:pose])
+      commands = lex(attrs[:commands])
+
+      new(pose: pose, commands: commands)
+    end
+
+    def initialize(args = {})
+      @pose = args[:pose]
+      @commands = args[:commands] || []
+      @coordinators = args[:coordinators] || []
+    end
+
+    def add_coordinator(coordinator)
+      coordinators << coordinator
+    end
+
+    def execute(mode)
+      case mode
+      when :all
+        commands.map! do |command|
+          self.send(command)
+          nil
+        end
+        commands.compact!
+      when :next
+        command = commands.shift
+        if command
+          self.send(command)
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def move
+      adj_pose = pose.adjacent
+      self.pose = adj_pose if coordinators.all? { |c| c.valid_coordinates?(adj_pose.coordinates) }
+      nil
+    end
+
+    def right
+      pose.rotate!(:clockwise)
+      nil
+    end
+
+    def left
+      pose.rotate!(:counter)
+      nil
+    end
+
+    private
+
+    attr_reader :commands, :coordinators
+    attr_accessor :pose
+
+    def self.validate(string)
+      string =~ /\A[MLR]*\z/
+    end
+
+    def self.lex(commands_string)
+      commands_string.chars.map do |char|
+        case char
+        when 'M'
+          :move
+        when 'R'
+          :right
+        when 'L'
+          :left
+        end
+      end
+    end
+  end
+end

data/lib/robo_dog/simulation.rb

@@ -0,0 +1,60 @@
+module RoboDog
+  class Simulation
+    def initialize(args = {})
+      @paddock = args[:paddock]
+      @robots = args[:robots] || []
+    end
+
+    def run(mode = :sequential)
+      mode ||= :sequential
+      warm_up
+      case mode
+      when :sequential
+        robots.each { |r| r.execute(:all) }
+      when :turns
+        run_in_turns
+      end
+    end
+
+    def report
+      {
+        robots: robots.map { |r| r.report }
+      }
+    end
+
+    def valid_coordinates?(coordinates)
+      coordinates &&
+      paddock.valid_coordinates?(coordinates) &&
+      robots.all? { |r| r.coordinates != coordinates } ||
+      fail_appropriately
+    end
+
+    private
+
+    attr_reader :robots, :paddock
+
+    def warm_up
+      fail_appropriately if robots.dup.uniq! { |r| r.coordinates }
+      robots.each { |r| r.add_coordinator(self) }
+    end
+
+    def fail_appropriately
+      fail(
+        'Invalid coordinates. This means two '\
+        'robots collided or a robot hit '\
+        'the border of the paddock.'
+      )
+    end
+
+    def run_in_turns
+      loop do
+        executed = false
+        robots.each do |r|
+          _ = r.execute(:next)
+          executed ||= _
+        end
+        break unless executed
+      end
+    end
+  end
+end

data/robodog.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'robodog'
+  spec.version       = '0.0.1'
+  spec.authors       = ['Matias Anaya']
+  spec.email         = ['matiasanaya@gmail.com']
+  spec.summary       = %q{Fredwina the Farmer's robotic sheep dog simulator}
+  spec.description   = %q{Fredwina the Farmer's robotic sheep dog simulator, used for the shock and awe showcase.}
+  spec.homepage      = 'https://github.com/matiasanaya/robo-dog'
+  spec.license       = 'UNLICENSE'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ['robodog']
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '~> 2.1'
+
+  spec.add_development_dependency 'rspec', '~> 3.1'
+end

data/spec/application_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../lib/robo_dog/application'
+
+RSpec.describe RoboDog::Application do
+  describe 'the public interface' do
+    it { expect(described_class).to respond_to :build }
+    subject{ described_class.new }
+    it { is_expected.to respond_to :run }
+  end
+
+  describe '.build' do
+    it 'returns a instance of self' do
+      expect(described_class.build).to be_instance_of described_class
+    end
+    it 'builds with default Parser' do
+      expect(described_class.build.instance_variable_get(:@parser)).to eql RoboDog::Parser
+    end
+    it 'builds with default Simulation Class' do
+      expect(described_class.build.instance_variable_get(:@simulation_class)).to eql RoboDog::Simulation
+    end
+    it 'builds with correct input' do
+      expect(described_class.build('Hello World').instance_variable_get(:@input)).to eql 'Hello World'
+    end
+  end
+end

data/spec/features/robo_dog_spec.rb

@@ -0,0 +1,107 @@
+require_relative '../../lib/robo_dog/application'
+require 'stringio'
+
+RSpec.describe RoboDog::Application do
+
+  let(:app) { lambda { |input_stream| RoboDog::Application.build(input_stream).run(mode) } }
+  let(:mode) { :sequential }
+
+  shared_examples 'a correct application' do |input_string, correct_output|
+    it 'prints the correct output' do
+      expect { app.call(StringIO.new(input_string)) }.to output(correct_output).to_stdout
+    end
+  end
+
+  shared_examples 'a complaining application' do |input_string, error|
+    it 'screams at the user' do
+      expect { app.call(StringIO.new(input_string)) }.to raise_exception error
+    end
+  end
+
+  context 'when valid input is provided' do
+    context 'when each robot executes all at once' do
+      context 'when robots do not run over each other' do
+        it_behaves_like 'a correct application',
+                        <<-END.gsub(/^\s+\|/, '') ,
+                          |5 5
+                          |1 2 N
+                          |LMLMLMLMM
+                          |3 3 E
+                          |MMRMMRMRRM
+                        END
+                        <<-END.gsub(/^\s+\|/, '')
+                          |1 3 N
+                          |5 1 E
+                        END
+      end
+      context 'when robots run over each other' do
+        it_behaves_like 'a complaining application',
+                        <<-END.gsub(/^\s+\|/, '') ,
+                          |5 5
+                          |0 0 E
+                          |M
+                          |1 0 N
+                          |L
+                        END
+                        RuntimeError
+
+        it_behaves_like 'a complaining application',
+                        <<-END.gsub(/^\s+\|/, '') ,
+                          |5 5
+                          |0 0 E
+                          |M
+                          |1 0 N
+                          |L
+                        END
+                        RuntimeError
+      end
+
+      context 'when robots run over then end of the paddock' do
+        it_behaves_like 'a complaining application',
+                        <<-END.gsub(/^\s+\|/, '') ,
+                          |5 5
+                          |5 5 N
+                          |M
+                        END
+                        RuntimeError
+
+        it_behaves_like 'a complaining application',
+                        <<-END.gsub(/^\s+\|/, '') ,
+                          |5 5
+                          |0 0 N
+                          |RMM
+                          |1 0 E
+                          |MMMM
+                        END
+                        RuntimeError
+      end
+
+      context 'when robots are placed over each other' do
+        it_behaves_like 'a complaining application',
+                        <<-END.gsub(/^\s+\|/, '') ,
+                          |5 5
+                          |0 0 E
+                          |M
+                          |0 0 N
+                          |M
+                        END
+                        RuntimeError
+      end
+    end
+    context 'when robots take turns' do
+      let(:mode) { :turns }
+      it_behaves_like 'a correct application',
+                        <<-END.gsub(/^\s+\|/, '') ,
+                          |5 5
+                          |0 0 N
+                          |RMM
+                          |1 0 E
+                          |MMMM
+                        END
+                        <<-END.gsub(/^\s+\|/, '')
+                          |2 0 E
+                          |5 0 E
+                        END
+    end
+  end
+end