toy-robot-simulator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2b4b3c0db1ec9db67b04a8c7956260295a9184f566d58226882d889034c27760
+  data.tar.gz: 5ed46e5643fec38a6114029cf43ce63d862c9a94b3c2f221ce3c7c41f8b67916
+SHA512:
+  metadata.gz: 70e4ed4c2e4972bb367fa02e6b4469f1b15393c5250fee6999c1975b18e5f9984ce9c9e63840a581f1738a517e0992a803d612ac5f9101d42041197aab35900d
+  data.tar.gz: 48d8a2823e3c988416442f09f87b3adb14726c7cef432be4ab11e6edd07fa44c6e36916d5d9012829c9f6103f0333f7cafe97426c47b282f876430149fffdf4a

data/lib/constants/application_constants.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+DIRECTIONS = %w[NORTH EAST SOUTH WEST].freeze
+COMMANDS = %w[MOVE LEFT RIGHT REPORT PLACE].freeze
+PLACE = COMMANDS.last.freeze
+PLACE_COMMAND_PATTERN = Regexp.new(/#{PLACE}\s*(\d+)\s*,\s*(\d+)\s*,\s*(#{DIRECTIONS.join('|')})\s*$/)

data/lib/errors/command.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Command
+  class InvalidOrEmptyCommands < StandardError; end
+  class InvalidCommandStreamType < StandardError; end
+  class InvalidCommandType < StandardError; end
+  class NoValidCommandsFound < StandardError; end
+  class PlaceCommandNotFound < StandardError; end
+  class EmptyLocationProvided < StandardError; end
+  class FormatNotSupported < StandardError; end
+  class SourceNotSupported < StandardError; end
+end

data/lib/errors/robot.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ToyRobot
+  class InvalidFacing < StandardError; end
+  class RobotIsNotPlaced < StandardError; end
+end

data/lib/errors/table.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Surface
+  class TableOutOfBound < StandardError; end
+  class TableIsNotSet < StandardError; end
+end

data/lib/helpers/command_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../constants/application_constants'
+# CommandHelper module
+module CommandHelper
+  def a_valid_place_command?(command)
+    return false if command.match(PLACE_COMMAND_PATTERN).nil?
+
+    true
+  end
+
+  def split_place_command(place_command)
+    result = place_command.match(PLACE_COMMAND_PATTERN)
+    result&.captures
+  end
+
+  def command_type(command)
+    return if command.nil?
+    return PLACE if command.include? PLACE
+    return command if COMMANDS.include? command
+  end
+
+  def directions
+    DIRECTIONS
+  end
+
+  def commands
+    COMMANDS
+  end
+end

data/lib/helpers/command_parser_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../constants/application_constants'
+require_relative 'command_helper'
+# CommandParserHelper module
+module CommandParserHelper
+  include CommandHelper
+
+  def parse_command(command)
+    type_of_command = command_type(command)
+    return if type_of_command.nil?
+    return if type_of_command == PLACE && a_valid_place_command?(command) == false
+
+    command_object(type_of_command, command_value(command))
+  end
+
+  private
+
+  def command_value(command)
+    return split_place_command(command) if place_command_and_valid?(command)
+
+    command
+  end
+
+  def command_object(type, value, status = '', error = '')
+    Struct.new(:type, :value, :status, :error).new(type, value, status, error)
+  end
+
+  def place_command_and_valid?(command)
+    command_type(command) == PLACE && a_valid_place_command?(command)
+  end
+end

data/lib/helpers/command_set_loader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../errors/command'
+# CommandSetLoader module
+module CommandSetLoader
+  def read_commands(location = '', source = 'file', format = 'text')
+    raise Command::FormatNotSupported, 'Only text format is supported' unless format == 'text'
+    raise Command::SourceNotSupported, 'Only file as a source is supported' unless source == 'file'
+    raise Command::EmptyLocationProvided if location.strip == ''
+
+    @location = location
+    read_from_file
+  end
+
+  private
+
+  def read_from_file
+    commands = []
+    File.readlines(@location).each { |line| commands << line.strip }
+    commands
+  end
+end

data/lib/surface/table.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'table_interface'
+require_relative '../errors/table'
+module Surface
+  # Table class
+  class Table
+    include TableInterface
+    attr_accessor :rows, :columns, :grid
+
+    def initialize(rows = 5, columns = 5)
+      @grid = Array.new(rows) { Array.new(columns) { 0 } }
+      @rows = rows
+      @columns = columns
+    end
+
+    def can_be_placed?(x, y)
+      return false unless (0..(rows - 1)).include?(x)
+      return false unless (0..(columns - 1)).include?(y)
+
+      true
+    end
+  end
+end

data/lib/surface/table_interface.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# module Surface
+module Surface
+  # TableInterface to valid can_be_placed?(_x, _y) implemented by Table
+  module TableInterface
+    def can_be_placed?(_x, _y)
+      raise 'Not implemented'
+    end
+  end
+end

data/lib/toy_robot/robot.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../errors/command'
+require_relative '../errors/robot'
+module ToyRobot
+  # Robot class
+  class Robot
+    attr_accessor :x, :y, :facing, :placed, :table
+
+    def initialize(table = nil)
+      @placed = false
+      @table = table
+      @x = nil
+      @y = nil
+      @facing = nil
+    end
+
+    def place(x, y, facing)
+      return if @placed
+      raise Surface::TableIsNotSet if @table.nil?
+      raise Surface::TableOutOfBound unless @table.can_be_placed?(x, y)
+      raise ToyRobot::InvalidFacing unless DIRECTIONS.include?(facing)
+
+      @x = x
+      @y = y
+      @facing = facing
+      @placed = true
+    end
+
+    def left
+      check_pre_conditions
+      @facing = next_facing('left')
+    end
+
+    def right
+      check_pre_conditions
+      @facing = next_facing('right')
+    end
+
+    def move
+      check_pre_conditions
+      result = calculate_potential_movement(facing)
+
+      x_should_be = result[:x].nil? ? @x : (@x + result[:x])
+      y_should_be = result[:y].nil? ? @y : (@y + result[:y])
+
+      raise Surface::TableOutOfBound unless @table.can_be_placed?(x_should_be, y_should_be)
+
+      @x = x_should_be
+      @y = y_should_be
+    end
+
+    def report(format = 'console')
+      raise ToyRobot::RobotIsNotPlaced unless @placed
+
+      case format
+      when 'console'
+        to_s
+      else
+        { x: @x, y: @y, facing: @facing }
+      end
+    end
+
+    def calculate_potential_movement(facing)
+      case facing
+      when 'NORTH'
+        { x: nil, y: 1 }
+      when 'WEST'
+        { x: -1, y: nil }
+      when 'SOUTH'
+        { x: nil, y: -1 }
+      when 'EAST'
+        { x: 1, y: nil }
+      end
+    end
+
+    private
+
+    def to_s
+      "#{@x},#{@y},#{@facing}"
+    end
+
+    def next_facing(arrow)
+      return DIRECTIONS.last if @facing == DIRECTIONS.first && arrow == 'left'
+      return DIRECTIONS.first if @facing == DIRECTIONS.last && arrow == 'right'
+
+      increment_factor = arrow == 'left' ? -1 : 1
+      new_index = DIRECTIONS.index(@facing) + increment_factor
+      DIRECTIONS[new_index]
+    end
+
+    def check_pre_conditions
+      raise Surface::TableIsNotSet if @table.nil?
+      raise ToyRobot::RobotIsNotPlaced unless @placed
+    end
+  end
+end

data/lib/toy_robot_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'toy_robot/robot'
+require_relative 'surface/table'
+require_relative 'helpers/command_parser_helper'
+require_relative 'errors/command'
+# ToyRobotController module and main entry of the program
+module ToyRobotController
+  class << self
+    attr_accessor :robot, :commands
+    include CommandParserHelper
+
+    def init(commands_stream, table_size = 5)
+      validate_command_stream(commands_stream)
+
+      @commands_stream = commands_stream
+      @table = Surface::Table.new(table_size, table_size)
+      @robot = ToyRobot::Robot.new(@table)
+      @commands = []
+      populate_commands
+    end
+
+    def report(format = 'console')
+      @robot.report(format)
+    end
+
+    def execute_commands
+      raise Command::NoValidCommandsFound if @commands.size.zero?
+      raise Command::PlaceCommandNotFound if @commands.select { |c| c.type == 'PLACE' }.size.zero?
+
+      @commands.each { |command| send_command_to_robot(command) }
+    end
+
+    private
+
+    def send_command_to_robot(command)
+      case command.type
+      when 'PLACE'
+        @robot.place(command.value[0].to_i, command.value[1].to_i, command.value[2])
+      when 'MOVE', 'RIGHT', 'LEFT', 'REPORT'
+        @robot.send(command.type.downcase)
+      end
+    rescue ToyRobot::RobotIsNotPlaced, Surface::TableOutOfBound => e
+      command.status = 'ignored'
+      command.error = e.to_s
+    end
+
+    def validate_command_stream(commands_stream)
+      raise Command::InvalidCommandStreamType unless commands_stream.is_a?(Array)
+      raise Command::InvalidOrEmptyCommands if commands_stream.size.zero?
+      raise Command::InvalidCommandType unless commands_stream.all? { |i| i.is_a? String }
+    end
+
+    def populate_commands
+      @commands_stream.each do |command|
+        current_command = parse_command(command)
+        @commands << current_command unless current_command.nil?
+      end
+    end
+  end
+end

data/spec/command_helper_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+describe CommandHelper do
+  include CommandHelper
+
+  describe '#command_type' do
+    it { expect(command_type('MOVE')).to eq('MOVE') }
+    it { expect(command_type('LEFT')).to eq('LEFT') }
+    it { expect(command_type('RIGHT')).to eq('RIGHT') }
+    it { expect(command_type('REPORT')).to eq('REPORT') }
+    it { expect(command_type('SOMETHING')).to eq(nil) }
+    it { expect(command_type('PLACE 0, 0, NORTH')).to eq('PLACE') }
+    it { expect(command_type('PLACE')).to eq('PLACE') }
+    it { expect(command_type(nil)).to eq(nil) }
+  end
+
+  describe '#valid_place_command?' do
+    context 'when PLACE command is invalid' do
+      it { expect(a_valid_place_command?('RANDOM')).to eq(false) }
+      it { expect(a_valid_place_command?('A, B, PLACE, Y')).to eq(false) }
+      it { expect(a_valid_place_command?('A, PLACE,B, Y')).to eq(false) }
+      it { expect(a_valid_place_command?('A, B, PLACE, Y')).to eq(false) }
+      it { expect(a_valid_place_command?('PLACE')).to eq(false) }
+      it { expect(a_valid_place_command?('PLACE A, B')).to eq(false) }
+      it { expect(a_valid_place_command?('PLACE A, B, F, G')).to eq(false) }
+      it { expect(a_valid_place_command?('PLACE A, B, Y')).to eq(false) }
+      it { expect(a_valid_place_command?('PLACE A, 0, Y')).to eq(false) }
+      it { expect(a_valid_place_command?('PLACE 0, B, Y')).to eq(false) }
+      it { expect(a_valid_place_command?('PLACE 0, 0, Y')).to eq(false) }
+    end
+  end
+
+  describe '#split_place_command' do
+    context 'when the PLACE command is valid as per PLACE_COMMAND_PATTERN' do
+      it { expect(split_place_command('PLACE 0, 0, NORTH')).to match_array(%w[0 0 NORTH]) }
+      it { expect(split_place_command('PLACE 20, 0, NORTH')).to match_array(%w[20 0 NORTH]) }
+      it { expect(split_place_command('PLACE 0, 0, WEST')).to match_array(%w[0 0 WEST]) }
+      it { expect(split_place_command('PLACE 0, 0, SOUTH')).to match_array(%w[0 0 SOUTH]) }
+      it { expect(split_place_command('PLACE 100, 0, EAST')).to match_array(%w[100 0 EAST]) }
+    end
+
+    context 'when the PLACE command is not according to the PLACE_COMMAND_PATTERN' do
+      it { expect(split_place_command('PLACE 0, 0, Y')).to eq(nil) }
+      it { expect(split_place_command('PLACE A, 0, NORTH')).to eq(nil) }
+      it { expect(split_place_command('PLACE B, 0, SOUTH')).to eq(nil) }
+    end
+  end
+end

data/spec/command_parser_helper_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+describe CommandParserHelper do
+  include CommandParserHelper
+
+  describe '#parse_command' do
+    let(:struct_blue_print) { { type: 'PLACE', value: %w[0 0 NORTH], status: '', error: '' } }
+
+    context 'when the command is a valid PLACE command' do
+      it 'will return an onject containing type, value, status and error' do
+        expect(parse_command('PLACE 0, 0, NORTH')).to have_attributes(struct_blue_print)
+      end
+
+      it { expect(parse_command('PLACE 0, 0, NORTH').type).to eq('PLACE') }
+      it { expect(parse_command('PLACE 0, 1, NORTH').value).to match_array(%w[0 1 NORTH]) }
+      it { expect(parse_command('PLACE 0, 0, NORTH').status).to eq('') }
+      it { expect(parse_command('PLACE 0, 0, NORTH').error).to eq('') }
+    end
+
+    context 'when any other valid command is provided' do
+      it { expect(parse_command('RIGHT').type).to eq('RIGHT') }
+      it { expect(parse_command('RIGHT').value).to eq('RIGHT') }
+      it { expect(parse_command('LEFT').type).to eq('LEFT') }
+      it { expect(parse_command('MOVE').type).to eq('MOVE') }
+      it { expect(parse_command('REPORT').type).to eq('REPORT') }
+    end
+
+    context 'when an invalid command is provided' do
+      it { expect(parse_command('REPORTME')).to eq(nil) }
+      it { expect(parse_command('RIGHTT')).to eq(nil) }
+      it { expect(parse_command('right')).to eq(nil) }
+    end
+
+    context 'when an invalid PLACE command is provided' do
+      it { expect(parse_command('PLACE')).to eq(nil) }
+      it { expect(parse_command('PLACE A, B')).to eq(nil) }
+      it { expect(parse_command('PLACE A, B, F, G')).to eq(nil) }
+      it { expect(parse_command('PLACE A, B, Y')).to eq(nil) }
+      it { expect(parse_command('PLACE A, 0, Y')).to eq(nil) }
+      it { expect(parse_command('PLACE 0, B, Y')).to eq(nil) }
+      it { expect(parse_command('PLACE 0, 0, Y')).to eq(nil) }
+    end
+  end
+end

data/spec/command_set_loader_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+describe CommandSetLoader do
+  include CommandSetLoader
+
+  describe '#read_commands' do
+    it 'will load the commands from test1.txt file and return array of commands' do
+      commands = read_commands('./test_data/test1.txt')
+      expect(commands).to match_array(['PLACE 0,0,NORTH', 'MOVE', 'REPORT'])
+    end
+
+    it 'will load the commands from test2.txt file and return array of commands' do
+      commands = read_commands('./test_data/test2.txt')
+      expect(commands).to match_array(['PLACE 0,0,NORTH', 'LEFT', 'REPORT'])
+    end
+
+    it 'will load the commands from test3.txt file and return array of commands' do
+      commands = read_commands('./test_data/test3.txt')
+      expect(commands).to match_array(['PLACE 1,2,EAST', 'MOVE', 'MOVE', 'LEFT', 'MOVE', 'REPORT'])
+    end
+
+    it 'will return SourceNotSupported exception if source is not file' do
+      expect do
+        read_commands('./test_data/test3.txt', 'remote')
+      end.to raise_error(Command::SourceNotSupported)
+    end
+
+    it 'will return FormatNotSupported exception if source is not text' do
+      expect do
+        read_commands('./test_data/test3.txt', 'file', 'json')
+      end.to raise_error(Command::FormatNotSupported)
+    end
+  end
+end

data/spec/robot_spec.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+describe ToyRobot::Robot do
+  let(:robot) { described_class.new }
+  let(:table) { Surface::Table.new }
+  let(:robot_with_table) { described_class.new(table) }
+
+  it 'should initialize and set the instance variables' do
+    expect(robot.placed).to eq(false)
+  end
+
+  describe '#place' do
+    context 'when table size is 5x5 and x, y are within the table bounds along with valid facing position' do
+      it 'will successfully place the robot onto the table' do
+        robot_with_table.place(0, 0, 'SOUTH')
+        expect(robot_with_table.placed).to eq(true)
+      end
+    end
+
+    context 'when facing value is not valid' do
+      it 'will raise InvalidFacing Exception' do
+        expect { robot_with_table.place(0, 0, 'RANDOM') }.to raise_error(ToyRobot::InvalidFacing)
+      end
+    end
+
+    context 'robot is already place' do
+      it 'will ignore any other place commands' do
+        robot_with_table.place(0, 0, 'SOUTH')
+        robot_with_table.place(1, 1, 'NORTH')
+        robot_with_table.place(1, 1, 'WEST')
+        robot_with_table.place(1, 1, 'EAST')
+        expect(robot_with_table.x).to eq(0)
+        expect(robot_with_table.y).to eq(0)
+        expect(robot_with_table.facing).to eq('SOUTH')
+      end
+    end
+
+    context 'when coordinates are out of bounds' do
+      it 'will raise TableOutOfBound Exception' do
+        expect { robot_with_table.place(0, 50, 'SOUTH') }.to raise_error(Surface::TableOutOfBound)
+      end
+    end
+
+    context 'when table is nil' do
+      it 'will raise TableIsNotSet Exception' do
+        robot_with_table.table = nil
+        expect { robot_with_table.place(0, 0, 'SOUTH') }.to raise_error(Surface::TableIsNotSet)
+      end
+    end
+  end
+
+  describe '#left' do
+    context 'when robot is not placed on the table yet' do
+      it 'raises RobotIsNotPlaced exception' do
+        expect { robot_with_table.left }.to raise_error(ToyRobot::RobotIsNotPlaced)
+      end
+    end
+
+    context 'when table is not set' do
+      it 'raises TableIsNotSet exception' do
+        expect { robot.left }.to raise_error(Surface::TableIsNotSet)
+      end
+    end
+
+    context 'when robot is facing NORTH' do
+      it 'will rotate the robot towards WEST' do
+        robot_with_table.place(0, 0, 'NORTH')
+        robot_with_table.left
+        expect(robot_with_table.facing).to eq('WEST')
+      end
+    end
+
+    context 'when robot is facing WEST' do
+      it 'will rotate the robot towards SOUTH' do
+        robot_with_table.place(0, 0, 'WEST')
+        robot_with_table.left
+        expect(robot_with_table.facing).to eq('SOUTH')
+      end
+    end
+
+    context 'when robot is facing SOUTH' do
+      it 'will rotate the robot towards EAST' do
+        robot_with_table.place(0, 0, 'SOUTH')
+        robot_with_table.left
+        expect(robot_with_table.facing).to eq('EAST')
+      end
+    end
+
+    context 'when robot is facing EAST' do
+      it 'will rotate the robot towards NORTH' do
+        robot_with_table.place(0, 0, 'EAST')
+        robot_with_table.left
+        expect(robot_with_table.facing).to eq('NORTH')
+      end
+    end
+  end
+
+  describe '#right' do
+    context 'when robot is not placed on the table yet' do
+      it 'raises RobotIsNotPlaced exception' do
+        expect { robot_with_table.right }.to raise_error(ToyRobot::RobotIsNotPlaced)
+      end
+    end
+
+    context 'when table is not set' do
+      it 'raises TableIsNotSet exception' do
+        expect { robot.right }.to raise_error(Surface::TableIsNotSet)
+      end
+    end
+
+    context 'when robot is facing WEST' do
+      it 'will rotate the robot towards NORTH' do
+        robot_with_table.place(0, 0, 'WEST')
+        robot_with_table.right
+        expect(robot_with_table.facing).to eq('NORTH')
+      end
+    end
+
+    context 'when robot is facing NORTH' do
+      it 'will rotate the robot towards EAST' do
+        robot_with_table.place(0, 0, 'NORTH')
+        robot_with_table.right
+        expect(robot_with_table.facing).to eq('EAST')
+      end
+    end
+
+    context 'when robot is facing EAST' do
+      it 'will rotate the robot towards SOUTH' do
+        robot_with_table.place(0, 0, 'EAST')
+        robot_with_table.right
+        expect(robot_with_table.facing).to eq('SOUTH')
+      end
+    end
+
+    context 'when robot is facing SOUTH' do
+      it 'will rotate the robot towards WEST' do
+        robot_with_table.place(0, 0, 'SOUTH')
+        robot_with_table.right
+        expect(robot_with_table.facing).to eq('WEST')
+      end
+    end
+  end
+
+  describe '#move' do
+    context 'when the table is not set' do
+      it 'raises TableIsNotSet exception' do
+        expect { robot.move }.to raise_error(Surface::TableIsNotSet)
+      end
+    end
+
+    context 'when the robot is not placed' do
+      it 'raises TableIsNotSet exception' do
+        expect { robot_with_table.move }.to raise_error(ToyRobot::RobotIsNotPlaced)
+      end
+    end
+
+    context 'when robot is placed at 0,0 NORTH' do
+      it 'will result in 0, 1 NORTH' do
+        robot_with_table.place(0, 0, 'NORTH')
+        robot_with_table.move
+        expect(robot_with_table.x).to eq(0)
+        expect(robot_with_table.y).to eq(1)
+        expect(robot_with_table.facing).to eq('NORTH')
+      end
+    end
+
+    context 'when robot is placed at 0,4 NORTH' do
+      it 'raises TableOutOfBound exception' do
+        robot_with_table.place(0, 4, 'NORTH')
+        expect { robot_with_table.move }.to raise_error(Surface::TableOutOfBound)
+      end
+    end
+  end
+
+  describe '#report' do
+    it 'will report the current coordinates and facing of robot wherever it is placed' do
+      robot_with_table.place(0, 4, 'NORTH')
+      expect(robot_with_table.report).to eq('0,4,NORTH')
+    end
+
+    context 'When the robot is not placed onto the table' do
+      it 'will rais RobotIsNotPlaced exception' do
+        expect { robot_with_table.report }.to raise_error(ToyRobot::RobotIsNotPlaced)
+      end
+    end
+  end
+
+  describe '#calculate_potential_movement' do
+    context 'when facing NORTH' do
+      it 'should do one step positive in y direction' do
+        result = robot_with_table.calculate_potential_movement('NORTH')
+        expect(result[:y]).to eq(1)
+      end
+    end
+
+    context 'when facing WEST' do
+      it 'should do one step positive in y direction' do
+        result = robot_with_table.calculate_potential_movement('WEST')
+        expect(result[:x]).to eq(-1)
+      end
+    end
+
+    context 'when facing SOUTH' do
+      it 'should do one step positive in y direction' do
+        result = robot_with_table.calculate_potential_movement('SOUTH')
+        expect(result[:y]).to eq(-1)
+      end
+    end
+
+    context 'when facing EAST' do
+      it 'should do one step positive in y direction' do
+        result = robot_with_table.calculate_potential_movement('EAST')
+        expect(result[:x]).to eq(1)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require_relative '../lib/toy_robot/robot'
+require_relative '../lib/surface/table'
+require_relative '../lib/toy_robot_controller'
+require_relative '../lib/helpers/command_helper'
+require_relative '../lib/helpers/command_parser_helper'
+require_relative '../lib/helpers/command_set_loader'
+require 'byebug'
+# require 'byebug'
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # This allows you to limit a spec run to individual examples or groups
+  #   # you care about by tagging them with `:focus` metadata. When nothing
+  #   # is tagged with `:focus`, all examples get run. RSpec also provides
+  #   # aliases for `it`, `describe`, and `context` that include `:focus`
+  #   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  #   config.filter_run_when_matching :focus
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  #   config.example_status_persistence_file_path = "spec/examples.txt"
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = "doc"
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+end

data/spec/table_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+describe Surface::Table do
+  let(:table) { described_class.new }
+
+  it 'should initialize and set the instance variables' do
+    expect(table.rows).to eq(5)
+    expect(table.columns).to eq(5)
+  end
+
+  describe '#can_be_placed?' do
+    context 'when table is 5x5' do
+      it { expect(table.can_be_placed?(4, 4)).to eq(true) }
+      it { expect(table.can_be_placed?(0, 0)).to eq(true) }
+      it { expect(table.can_be_placed?(4, 5)).to eq(false) }
+      it { expect(table.can_be_placed?(5, 5)).to eq(false) }
+      it { expect(table.can_be_placed?(-5, 5)).to eq(false) }
+    end
+  end
+end

data/spec/toy_robot_controller_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+describe ToyRobotController do
+  let(:controller) { described_class }
+
+  describe '.init' do
+    it 'will instanciate the robot' do
+      comamnds_stream = ['PLACE 0,0,NORTH', 'MOVE', 'REPORT']
+      controller.init(comamnds_stream)
+      expect(controller.robot).to be_an_instance_of(ToyRobot::Robot)
+    end
+
+    it 'will populate the commands with valid commands only' do
+      comamnds_stream = ['PLACE 0,0,NORTH', 'MOVE', 'REPORT', 'RANDOM Command']
+      controller.init(comamnds_stream)
+      expect(controller.commands.map(&:value)).to match_array([%w[0 0 NORTH], 'MOVE', 'REPORT'])
+    end
+    context 'when command steams type is not Array' do
+      it 'will raise InvalidCommandStreamType exception' do
+        expect { controller.init('') }.to raise_error(Command::InvalidCommandStreamType)
+      end
+    end
+
+    context 'when command steams is empty' do
+      it 'will raise InvalidOrEmptyCommands exception' do
+        expect { controller.init([]) }.to raise_error(Command::InvalidOrEmptyCommands)
+      end
+    end
+
+    context 'when command steams Array contains non String types' do
+      it 'will raise InvalidOrEmptyCommands exception' do
+        comamnds_stream = [1, 'PLACE 0,0,NORTH', 'REPORT']
+        expect { controller.init(comamnds_stream) }.to raise_error(Command::InvalidCommandType)
+      end
+    end
+  end
+
+  describe '.execute_commands' do
+    context 'when all commands are invalid' do
+      it 'will raise NoValidCommandsFound exception' do
+        comamnds_stream = ['RANDOM Command', 'adfadfadf', 'adfrtrett']
+        controller.init(comamnds_stream)
+        expect { controller.execute_commands }.to raise_error(Command::NoValidCommandsFound)
+      end
+    end
+
+    it 'will ignore all commands before PLACE' do
+      controller.init(['MOVE', 'REPORT', 'PLACE 1,1,NORTH', 'MOVE', 'REPORT'])
+      controller.execute_commands
+      expect(controller.commands.select { |c| c.status == 'ignored' }.size).to eq(2)
+    end
+
+    context 'when PLACE command is not provided' do
+      it 'will raise PlaceCommandNotFound exception' do
+        controller.init(%w[MOVE MOVE LEFT MOVE REPORT])
+        expect { controller.execute_commands }.to raise_error(Command::PlaceCommandNotFound)
+      end
+      it 'will raise PlaceCommandNotFound exception with a PLACE command without X,Y,Facing' do
+        controller.init(%w[PLACE MOVE MOVE LEFT MOVE REPORT])
+        expect { controller.execute_commands }.to raise_error(Command::PlaceCommandNotFound)
+      end
+    end
+  end
+
+  describe '.report' do
+    context 'when command sequence is PLACE 0,0,NORTH MOVE REPORT ' do
+      it 'will move the robot to 0,1,NORTH' do
+        controller.init(['PLACE 0,0,NORTH', 'MOVE', 'REPORT'])
+        controller.execute_commands
+        expect(controller.report).to eq('0,1,NORTH')
+      end
+    end
+
+    context 'when command sequence is PLACE 1,2,EAST MOVE MOVE LEFT MOVE REPORT' do
+      it 'will move the robot to 3,3,NORTH' do
+        controller.init(['PLACE 1,2,EAST', 'MOVE', 'MOVE', 'LEFT', 'MOVE', 'REPORT'])
+        controller.execute_commands
+        expect(controller.report).to eq('3,3,NORTH')
+      end
+    end
+    context 'when command sequence is PLACE 1,2,WEST MOVE MOVE LEFT MOVE REPORT' do
+      it 'will move the robot to 0,1,SOUTH' do
+        controller.init(['PLACE 1,2,WEST', 'MOVE', 'MOVE', 'LEFT', 'MOVE', 'REPORT'])
+        controller.execute_commands
+        expect(controller.report).to eq('0,1,SOUTH')
+      end
+    end
+
+    context 'when command sequence contains only PLACE command' do
+      it 'will report where the robot was PLACED' do
+        controller.init(['PLACE 0,0,SOUTH'])
+        controller.execute_commands
+        expect(controller.report).to eq('0,0,SOUTH')
+      end
+    end
+    context 'when PLACE command is not provided' do
+      it 'will raise RobotIsNotPlaced exception' do
+        controller.init(%w[MOVE MOVE LEFT MOVE REPORT])
+        expect { controller.report }.to raise_error(ToyRobot::RobotIsNotPlaced)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: toy-robot-simulator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Salman Sohail
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-08-27 00:00:00.000000000 Z
+dependencies: []
+description: Let the Toy Robot move onto the table without dying.
+email: salmansohail@agilis-lab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/constants/application_constants.rb
+- lib/errors/command.rb
+- lib/errors/robot.rb
+- lib/errors/table.rb
+- lib/helpers/command_helper.rb
+- lib/helpers/command_parser_helper.rb
+- lib/helpers/command_set_loader.rb
+- lib/surface/table.rb
+- lib/surface/table_interface.rb
+- lib/toy_robot/robot.rb
+- lib/toy_robot_controller.rb
+- spec/command_helper_spec.rb
+- spec/command_parser_helper_spec.rb
+- spec/command_set_loader_spec.rb
+- spec/robot_spec.rb
+- spec/spec_helper.rb
+- spec/table_spec.rb
+- spec/toy_robot_controller_spec.rb
+homepage: https://github.com/saluminati/toy-robot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby gem for Toy Robot test
+test_files:
+- spec/robot_spec.rb
+- spec/spec_helper.rb
+- spec/command_set_loader_spec.rb
+- spec/toy_robot_controller_spec.rb
+- spec/command_parser_helper_spec.rb
+- spec/table_spec.rb
+- spec/command_helper_spec.rb