maux_robot 0.0.2

data/README.md

@@ -0,0 +1,104 @@
+# maux_robot
+
+Maux version of a Toy Robot Simulator in Ruby
+
+## Description
+
+* The application is a simulation of a toy robot moving
+on a square tabletop, of dimensions 5 units x 5 units.
+* There are no other obstructions on the table surface.
+* The robot is free to roam around the surface of the table,
+but must be prevented from falling to destruction.
+Any movement that would result in the robot falling
+from the table must be prevented, however further
+valid movement commands must still be allowed.
+
+## Task
+
+This is an application that can read in commands of the following form:
+
+```
+PLACE X,Y,F
+MOVE
+LEFT
+RIGHT
+REPORT
+```
+
+* `PLACE` will put the toy robot on the table in position X,Y
+and facing `NORTH`, `SOUTH`, `EAST` or `WEST`.
+* The origin (0,0) can be considered to be the `SOUTH WEST` most corner.
+* The first valid command to the robot is a `PLACE` command,
+after that, any sequence of commands may be issued, in any order,
+including another `PLACE` command.
+The application should discard all commands in the sequence
+until a valid `PLACE `command has been executed.
+* `MOVE` will move the toy robot one unit forward
+in the direction it is currently facing.
+* `LEFT` and `RIGHT` will rotate the robot 90 degrees
+in the specified direction
+without changing the position of the robot.
+* `REPORT` will announce the X,Y and F of the robot.
+
+* A robot that is not on the table ignores the `MOVE`, `LEFT`, `RIGHT` and `REPORT` commands.
+
+## Constraints
+
+The toy robot does not fall off the table during movement.
+This also includes the initial placement of the toy robot.
+Any move that would cause the robot to fall is ignored.
+
+## Installation
+
+```
+gem install maux_robot
+```
+
+## Execution
+
+Example Input and Output:
+
+```
+# Example a
+echo "PLACE 0,0,NORTH
+MOVE
+REPORT" | maux_robot
+# Output: 0,1,NORTH
+```
+
+
+```
+# Example b
+echo "PLACE 0,0,NORTH
+LEFT
+REPORT" | maux_robot
+# Output: 0,0,WEST
+```
+
+
+```
+# Example c
+echo "PLACE 1,2,EAST
+MOVE
+MOVE
+LEFT
+MOVE
+REPORT" | maux_robot
+# Output: 3,3,NORTH
+```
+
+```
+# Example d
+cat script_file | maux_robot
+```
+
+## Acknowledgement
+
+The Toy Robot Challenge was originally formulated by [Jon Eaves](https://twitter.com/joneaves)
+
+## Author
+
+**Mauricio Vieira (mauriciovieira)**
++ <http://mauriciovieira.net>
++ <https://twitter.com/mauriciovieira>
++ <https://github.com/mauriciovieira>

data/bin/maux_robot

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require 'maux_robot'
+
+cli = MauxRobot::CLI.new
+cli.run

data/lib/maux_robot.rb

@@ -0,0 +1,5 @@
+require 'maux_robot/version'
+require 'maux_robot/cli'
+require 'maux_robot/position'
+require 'maux_robot/table'
+require 'maux_robot/robot'

data/lib/maux_robot/cli.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module MauxRobot
+
+  # The CLI is a class responsible of handling command line interface
+  class CLI
+    ALLOWED_ORDERS = %i[left right move place report].freeze
+
+    attr_reader :robot
+    def initialize
+      @robot = Robot.new
+    end
+
+    # Receives everything from standard input and executes
+    def run
+      run_script(STDIN.read)
+    end
+
+    def run_script(all_input)
+      all_input.split("\n").each do |line_input|
+        command = parse(line_input)
+        execute(command) if command
+      end
+    end
+
+    def parse(line_input)
+      clean_input = line_input.strip.squeeze(' ').split(' ')
+      order = sanitize_order(clean_input.shift)
+      return unless order
+
+      command = { order: order }
+
+      if clean_input.any?
+        arguments = sanitize_arguments(clean_input.join(''))
+        command[:arguments] = arguments
+      end
+
+      command
+    end
+
+    def execute(command)
+      if command[:arguments].nil?
+        @robot.send(command[:order])
+      else
+        @robot.send(command[:order], command[:arguments])
+      end
+    end
+
+    private
+
+    def sanitize_order(input_string)
+      order = input_string.downcase.to_sym
+      order if ALLOWED_ORDERS.include?(order)
+    end
+
+    def sanitize_arguments(arguments)
+      arguments = arguments.delete(' ').split(',')
+      { x: arguments[0], y: arguments[1], face: arguments[2] }
+    end
+  end
+end

data/lib/maux_robot/position.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'maux_robot'
+
+module MauxRobot
+
+  # This class represents the Robot position on the table
+  class Position
+    attr_reader :x, :y, :face
+
+    POSSIBLE_DIRECTIONS = [:north, :west, :south, :east]
+    POSSIBLE_MOVEMENTS = {
+      north: { x:  0, y:  1 },
+      west:  { x: -1, y:  0 },
+      south: { x:  0, y: -1 },
+      east:  { x:  1, y:  0 },
+    }
+
+    def initialize(x, y, face)
+      @x = x.to_i
+      @y = y.to_i
+      @face = face&.downcase&.to_sym || :invalid
+    end
+
+    def valid_direction?
+      POSSIBLE_DIRECTIONS.include?(@face)
+    end
+
+    def turn_left
+      next_direction_index = ( POSSIBLE_DIRECTIONS.index(@face) + 1 ) % 4
+      @face = POSSIBLE_DIRECTIONS[next_direction_index]
+    end
+
+    def turn_right
+      next_direction_index = ( POSSIBLE_DIRECTIONS.index(@face) - 1 )
+      @face = POSSIBLE_DIRECTIONS[next_direction_index]
+    end
+
+    def forward_position
+      x = @x + POSSIBLE_MOVEMENTS[@face][:x]
+      y = @y + POSSIBLE_MOVEMENTS[@face][:y]
+      Position.new(x, y, @face)
+    end
+
+    def to_s
+      "#{@x},#{@y},#{@face.upcase.to_s}"
+    end
+  end
+end

data/lib/maux_robot/robot.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MauxRobot
+
+  # The main class. It executes the actions using its table and position
+  class Robot
+    attr_reader :position
+
+    def initialize(table=MauxRobot::Table.new)
+      @table = table
+    end
+
+    def place(x:, y:, face:)
+      position = MauxRobot::Position.new(x, y, face)
+
+      if position.valid_direction? and @table.contains?(position)
+        @position = position
+      end
+    end
+
+    def left
+      @position&.turn_left
+    end
+
+    def right
+      @position&.turn_right
+    end
+
+    def move
+      next_position = @position.forward_position
+
+      if @table.contains?(next_position)
+        @position = next_position
+      end
+    end
+
+    def report
+      puts @position if @position
+    end
+  end
+end

data/lib/maux_robot/table.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MauxRobot
+
+  # This class represents a table according to simulation rules
+  class Table
+    def initialize(x: [0, 4], y: [0, 4])
+      @x = x
+      @y = y
+    end
+
+    def contains?(position)
+      position.x.between?(@x[0], @x[1]) &&
+        position.y.between?(@y[0], @y[1])
+    end
+  end
+end

data/lib/maux_robot/version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MauxRobot
+  # This module holds the MauxRobot version information.
+  module Version
+    STRING = '0.0.2'.freeze
+
+    MSG = '%s (using Parser %s, running on %s %s %s)'.freeze
+
+    def self.version(debug = false)
+      if debug
+        format(MSG, STRING, Parser::VERSION,
+               RUBY_ENGINE, RUBY_VERSION, RUBY_PLATFORM)
+      else
+        STRING
+      end
+    end
+  end
+end

data/spec/maux_robot/cli_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'maux_robot'
+
+describe MauxRobot::CLI do
+  describe '#parse' do
+    context 'valid orders' do
+      it '#report' do
+        expect(subject.parse('REPORT')).to eq(order: :report)
+      end
+
+      it '#move' do
+        expect(subject.parse('MOVE')).to eq(order: :move)
+      end
+
+      it '#left' do
+        expect(subject.parse('LEFT')).to eq(order: :left)
+      end
+
+      it '#right' do
+        expect(subject.parse('RIGHT')).to eq(order: :right)
+      end
+
+      it '#place' do
+        expect(subject.parse('PLACE 0,3,WEST')).to eq(order: :place, arguments: { x: '0', y: '3', face: 'WEST' })
+      end
+    end
+
+    context 'orders with spaces and downcase' do
+      it '#report' do
+        expect(subject.parse('    repoRT')).to eq(order: :report)
+      end
+
+      it '#move' do
+        expect(subject.parse('move      ')).to eq(order: :move)
+      end
+
+      it '#left' do
+        expect(subject.parse('   LefT ')).to eq(order: :left)
+      end
+
+      it '#right' do
+        expect(subject.parse('   rigHt')).to eq(order: :right)
+      end
+
+      it '#place' do
+        expect(subject.parse('PLACE 2 ,  1 ,  NOrth')).to eq(order: :place, arguments: { x: '2', y: '1', face: 'NOrth' })
+      end
+    end
+
+    it 'ignores anything else' do
+      expect(subject.parse('blablabla balbla')).to eq(order: nil)
+    end
+  end
+
+  describe '#execute' do
+    context 'commands without arguments' do
+      it 'sends proper message to robot' do
+        expect(subject.robot).to receive(:move)
+        subject.execute(order: :move)
+      end
+    end
+
+    context 'place' do
+      it 'send place command along with arguments' do
+        expect(subject.robot).to receive(:place).with(x: '0', y: '2', face: 'EAST')
+        subject.execute(order: :place, arguments: { x: '0', y: '2', face: 'EAST' })
+      end
+    end
+  end
+end

data/spec/maux_robot/position_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'maux_robot'
+
+describe MauxRobot::Position do
+  describe '#initialize' do
+    context 'given text input' do
+      it 'should normalize arguments' do
+        position = MauxRobot::Position.new('0', '1', 'SOUTH')
+
+        expect(position.x).to eq(0)
+        expect(position.y).to eq(1)
+        expect(position.face).to eq(:south)
+      end
+    end
+  end
+
+  describe '#valid_direction?' do
+    context 'given a possible diretion' do
+      it 'should be valid' do
+        position = MauxRobot::Position.new(5, 0, :south)
+
+        expect(position.valid_direction?).to eq(true)
+      end
+    end
+
+    context 'given a not possible direction' do
+      it 'should not be valid ' do
+        position = MauxRobot::Position.new(1, 1, :south_west)
+
+        expect(position.valid_direction?).to eq(false)
+      end
+    end
+  end
+
+  describe 'rotation' do
+    let(:position) { MauxRobot::Position.new(2, 2, :north) }
+
+    context '#turn_left' do
+      it 'should rotate counter-clockwise' do
+        position.turn_left
+        expect(position.face).to eq(:west)
+
+        position.turn_left
+        expect(position.face).to eq(:south)
+
+        position.turn_left
+        expect(position.face).to eq(:east)
+
+        position.turn_left
+        expect(position.face).to eq(:north)
+      end
+    end
+
+    context '#turn_right' do
+      it 'should rotate clockwise' do
+        position.turn_right
+        expect(position.face).to eq(:east)
+
+        position.turn_right
+        expect(position.face).to eq(:south)
+
+        position.turn_right
+        expect(position.face).to eq(:west)
+
+        position.turn_right
+        expect(position.face).to eq(:north)
+      end
+    end
+  end
+
+  describe '#forward_position' do
+    context 'facing north' do
+      let(:position) { MauxRobot::Position.new(5, 0, :north) }
+
+      it 'should return a new position 1 step upwards' do
+        new_position = position.forward_position
+        expect(position.x).to eq(5)
+        expect(position.y).to eq(0)
+        expect(new_position.x).to eq(5)
+        expect(new_position.y).to eq(1)
+      end
+    end
+
+    context 'facing west' do
+      let(:position) { MauxRobot::Position.new(2, 1, :west) }
+
+      it 'should return a new position 1 step leftwards' do
+        new_position = position.forward_position
+        expect(position.x).to eq(2)
+        expect(position.y).to eq(1)
+        expect(new_position.x).to eq(1)
+        expect(new_position.y).to eq(1)
+      end
+    end
+
+    context 'facing south' do
+      let(:position) { MauxRobot::Position.new(1, 3, :south) }
+
+      it 'should return a new position 1 step downwards' do
+        new_position = position.forward_position
+        expect(position.x).to eq(1)
+        expect(position.y).to eq(3)
+        expect(new_position.x).to eq(1)
+        expect(new_position.y).to eq(2)
+      end
+    end
+
+    context 'facing east' do
+      let(:position) { MauxRobot::Position.new(2, 0, :east) }
+
+      it 'should return a new position 1 step rightwards' do
+        new_position = position.forward_position
+        expect(position.x).to eq(2)
+        expect(position.y).to eq(0)
+        expect(new_position.x).to eq(3)
+        expect(new_position.y).to eq(0)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'if x, y and face are defined' do
+      let(:position) { MauxRobot::Position.new(5, 0, :north) }
+      it 'returns X,Y,FACE' do
+        expect(position.to_s).to eq('5,0,NORTH')
+      end
+    end
+
+    context 'if only face is defined' do
+      let(:position) { MauxRobot::Position.new(nil, nil, 'SOUTH') }
+      it 'returns 0,0,FACE' do
+        expect(position.to_s).to eq('0,0,SOUTH')
+      end
+    end
+
+    context 'if face is not defined' do
+      let(:position) { MauxRobot::Position.new(5, 0, nil) }
+      it 'returns X,Y,INVALID' do
+        expect(position.to_s).to eq('5,0,INVALID')
+      end
+    end
+  end
+end