maux_robot 0.0.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3c587b90116be51790d2d74c04781ddf0aa1f29a
-  data.tar.gz: 3d0d0a2f00d422c6a0eed9a789068623d5678428
+SHA256:
+  metadata.gz: 9c718637133d2a7b8dfb7d42fdcd754ce4eff6ec1fba93f7fe5ddaaa612d1cc1
+  data.tar.gz: 064f6ebc5ceefaa8dc44a2ff1f577178675cf362ffb77c3726c6e2ae6f62f1f1
 SHA512:
-  metadata.gz: 05ee766bbf7c5917d43f1310d8f9bfce858303810bbab6695760e154854c6af3232ff57b1d0575d446e46cfed32e1979c92e596ff1fd4a758444ff329d098c66
-  data.tar.gz: 9fe5dd5b8edc18ad12864df9c08a41c58c75c59c6b4b875e7a33e8baea9bed0474a8fa43d8815fd16ab1653cc09ef07cc24c6b18a012ffcf5f32645a4d2c3e38
+  metadata.gz: 8cd5c5b6adfccdda316a95ac5f88cefbef598239ed2e981c47f10a70b63a0133af84b70b1effafa04dc0643efafa22bb183d8779d43630310e6068a6a854c370
+  data.tar.gz: 51e46cca8fc6e0239ae9c286611fc11e4589959d5338fac2317107fd2703e3112c201ca63e50bdda96aade74e1c2d71a78c02ff7d93f83b40009d9c41c4bed29

data/README.md

@@ -1,3 +1,7 @@
+[![Build Status](https://travis-ci.org/mauriciovieira/maux_robot.svg?branch=master)](https://travis-ci.org/mauriciovieira/maux_robot)
+[![Maintainability](https://api.codeclimate.com/v1/badges/b45a7baf1130fb9aa8f6/maintainability)](https://codeclimate.com/github/mauriciovieira/maux_robot/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/b45a7baf1130fb9aa8f6/test_coverage)](https://codeclimate.com/github/mauriciovieira/maux_robot/test_coverage)
+
 # maux_robot
 
 Maux version of a Toy Robot Simulator in Ruby
@@ -22,7 +26,8 @@ PLACE X,Y,F
 MOVE
 LEFT
 RIGHT
-REPORT
+REPORT [csv|json]
+VERBOSE
 ```
 
 * `PLACE` will put the toy robot on the table in position X,Y
@@ -38,7 +43,8 @@ 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.
+* `REPORT` will announce the X,Y and F of the robot. If `csv` or `json` is passed, it formats the whereabouts accordingly. The default format is `csv`.
+* `VERBOSE` will turn the error messages (talkative mode) on or off. The robot starts with talkative mode set to off.
 
 * A robot that is not on the table ignores the `MOVE`, `LEFT`, `RIGHT` and `REPORT` commands.
 
@@ -101,4 +107,4 @@ The Toy Robot Challenge was originally formulated by [Jon Eaves](https://twitter
 **Mauricio Vieira (mauriciovieira)**
 + <http://mauriciovieira.net>
 + <https://twitter.com/mauriciovieira>
-+ <https://github.com/mauriciovieira>
++ <https://github.com/mauriciovieira>

data/bin/maux_robot

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH.unshift("#{__dir__}/../lib")
 

data/lib/maux_robot.rb

@@ -1,5 +1,14 @@
-require 'maux_robot/version'
-require 'maux_robot/cli'
-require 'maux_robot/position'
-require 'maux_robot/table'
-require 'maux_robot/robot'
+# frozen_string_literal: true
+
+require "maux_robot/version"
+require "maux_robot/cli"
+require "maux_robot/formatter"
+require "maux_robot/formatter/csv"
+require "maux_robot/formatter/json"
+require "maux_robot/parser"
+require "maux_robot/position"
+require "maux_robot/table"
+require "maux_robot/robot"
+
+module MauxRobot
+end

data/lib/maux_robot/cli.rb

@@ -1,11 +1,8 @@
 # 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
@@ -19,43 +16,24 @@ module MauxRobot
     def run_script(all_input)
       all_input.split("\n").each do |line_input|
         command = parse(line_input)
-        execute(command) if command
+        begin
+          execute(command) if command
+        rescue MauxRobot::RobotError => e
+          puts e if @robot.talkative
+        end
       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
+      Parser.new.parse(line_input)
     end
 
     def execute(command)
-      if command[:arguments].nil?
-        @robot.send(command[:order])
-      else
+      if command.key?(:arguments)
         @robot.send(command[:order], command[:arguments])
+      else
+        @robot.send(command[:order])
       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
+end

data/lib/maux_robot/formatter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MauxRobot
+  module Formatter
+    def self.from(format_type)
+      case format_type
+      when :json
+        Formatter::Json.new
+      else
+        Formatter::Csv.new
+      end
+    end
+  end
+end

data/lib/maux_robot/formatter/csv.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MauxRobot
+  module Formatter
+    class Csv
+      def generate(position)
+        "#{position.x},#{position.y},#{position.face.upcase}"
+      end
+    end
+  end
+end

data/lib/maux_robot/formatter/json.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "json"
+
+module MauxRobot
+  module Formatter
+    class Json
+      def generate(position)
+        JSON.generate(
+          x: position.x,
+          y: position.y,
+          face: position.face.upcase.to_s
+        )
+      end
+    end
+  end
+end

data/lib/maux_robot/parser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MauxRobot
+  class Parser
+    ALLOWED_ORDERS = %i[left right move place report verbose].freeze
+
+    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(order, clean_input.join(""))
+        command[:arguments] = arguments
+      end
+
+      command
+    end
+
+    private
+
+    def sanitize_order(input_string)
+      order = input_string.downcase.to_sym
+      order if ALLOWED_ORDERS.include?(order)
+    end
+
+    def sanitize_arguments(order, arguments)
+      case order
+      when :place
+        arguments = arguments.delete(" ").split(",")
+        {x: arguments[0], y: arguments[1], face: arguments[2]}
+      when :report
+        {format_type: arguments.downcase.to_sym}
+      end
+    end
+  end
+end

data/lib/maux_robot/position.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
-require 'maux_robot'
+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_DIRECTIONS = %i[north west south east].freeze
     POSSIBLE_MOVEMENTS = {
-      north: { x:  0, y:  1 },
-      west:  { x: -1, y:  0 },
-      south: { x:  0, y: -1 },
-      east:  { x:  1, y:  0 },
-    }
+      north: {x: 0, y: 1},
+      west: {x: -1, y: 0},
+      south: {x: 0, y: -1},
+      east: {x: 1, y: 0}
+    }.freeze
 
-    def initialize(x, y, face)
+    def initialize(x, y, face) # rubocop:disable Naming/UncommunicativeMethodParamName
       @x = x.to_i
       @y = y.to_i
       @face = face&.downcase&.to_sym || :invalid
@@ -26,24 +25,41 @@ module MauxRobot
       POSSIBLE_DIRECTIONS.include?(@face)
     end
 
-    def turn_left
-      next_direction_index = ( POSSIBLE_DIRECTIONS.index(@face) + 1 ) % 4
+    def left
+      return self unless valid_direction?
+
+      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 )
+    def right
+      return self unless valid_direction?
+
+      next_direction_index = (POSSIBLE_DIRECTIONS.index(@face) - 1)
       @face = POSSIBLE_DIRECTIONS[next_direction_index]
     end
 
     def forward_position
+      return self unless valid_direction?
+
       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}"
+    def report(format_type = :csv)
+      formatter = MauxRobot::Formatter.from(format_type)
+      puts formatter.generate(self)
+    end
+
+    def ==(other)
+      other.x == x && other.y == y && other.face == face
+    end
+  end
+
+  class NullPosition < Position
+    def initialize
+      super(nil, nil, nil)
     end
   end
-end
+end

data/lib/maux_robot/robot.rb

@@ -1,41 +1,91 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module MauxRobot
+  class RobotError < StandardError; end
+
+  # Error to notify that the robot was not placed yet
+  class RobotNotPlacedYet < RobotError
+    def initialize
+      super("The robot was not placed yet!")
+    end
+  end
+
+  # Error to notify that the position is/would be outside the table
+  class NotOkToGo < RobotError
+    def initialize(position)
+      super("It's not ok to go to #{position.x},#{position.y}")
+    end
+  end
 
   # The main class. It executes the actions using its table and position
   class Robot
-    attr_reader :position
+    attr_reader :position, :talkative
 
-    def initialize(table=MauxRobot::Table.new)
+    def initialize(table = MauxRobot::Table.new)
       @table = table
+      @position = MauxRobot::NullPosition.new
+      @talkative = false
     end
 
-    def place(x:, y:, face:)
+    def place(x:, y:, face:) # rubocop:disable Naming/UncommunicativeMethodParamName
       position = MauxRobot::Position.new(x, y, face)
 
-      if position.valid_direction? and @table.contains?(position)
+      ok_to_go?(position) do
         @position = position
       end
+      @position
+    end
+
+    def move
+      robot_placed? do
+        next_position = @position.forward_position
+
+        ok_to_go?(next_position) do
+          @position = next_position
+        end
+
+        @position
+      end
     end
 
     def left
-      @position&.turn_left
+      robot_placed? do
+        @position.left
+      end
     end
 
     def right
-      @position&.turn_right
+      robot_placed? do
+        @position.right
+      end
     end
 
-    def move
-      next_position = @position.forward_position
-
-      if @table.contains?(next_position)
-        @position = next_position
+    def report(format_type: :csv)
+      robot_placed? do
+        @position.report(format_type)
       end
     end
 
-    def report
-      puts @position if @position
+    def verbose
+      @talkative = !@talkative
+      is_not = @talkative ? "is" : "is not"
+      puts "Robot #{is_not} talkative now."
+    end
+
+    private
+
+    def ok_to_go?(position)
+      raise NotOkToGo, position unless @table.contains?(position)
+
+      yield
+    end
+
+    def robot_placed?
+      raise RobotNotPlacedYet if @position.class == MauxRobot::NullPosition
+
+      yield
     end
   end
-end
+end

data/lib/maux_robot/table.rb

@@ -1,16 +1,16 @@
 # 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])
+    def initialize(x: [0, 4], y: [0, 4]) # rubocop:disable Naming/UncommunicativeMethodParamName
       @x = x
       @y = y
     end
 
     def contains?(position)
-      position.x.between?(@x[0], @x[1]) &&
+      position.valid_direction? &&
+        position.x.between?(@x[0], @x[1]) &&
         position.y.between?(@y[0], @y[1])
     end
   end

data/lib/maux_robot/version.rb

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

data/spec/maux_robot/cli_spec.rb

@@ -1,71 +1,24 @@
 # frozen_string_literal: true
 
-require 'maux_robot'
+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
+  subject(:cli) { described_class.new }
 
-      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
+    let(:position) { MauxRobot::Position.new(0, 2, :east) }
 
-  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)
+    context "when input is parsed without arguments" do
+      it "sends proper message to robot" do
+        allow(cli.robot).to receive(:move).and_return(position)
+        expect(cli.execute(order: :move)).to eq(position)
       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' })
+    context "when place is parsed command with arguments" do
+      it "sends proper message to robot" do
+        expect(cli.execute(order: :place, arguments: {x: "0", y: "2", face: "EAST"})).to eq(position)
       end
     end
   end
-end
+end

data/spec/maux_robot/formatter/csv_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+describe MauxRobot::Formatter::Csv do
+  let(:position) { MauxRobot::Position.new(1, 2, :west) }
+
+  describe "#generate" do
+    subject(:csv_formatter) { described_class.new }
+
+    it "Formats a position as CSV" do
+      expect(csv_formatter.generate(position)).to eq("1,2,WEST")
+    end
+  end
+end

data/spec/maux_robot/formatter/json_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+describe MauxRobot::Formatter::Json do
+  let(:position) { MauxRobot::Position.new(1, 2, :west) }
+
+  describe "#generate" do
+    subject(:json_formatter) { described_class.new }
+
+    it "Formats a position as JSON" do
+      expect(json_formatter.generate(position)).to eq('{"x":1,"y":2,"face":"WEST"}')
+    end
+  end
+end

data/spec/maux_robot/formatter_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe MauxRobot::Formatter do
+  subject(:formatter) { described_class }
+
+  describe "#from" do
+    describe "valid format_types" do
+      it "returns csv formatter" do
+        expect(formatter.from(:csv).class).to eq(MauxRobot::Formatter::Csv)
+      end
+
+      it "returns json formatter" do
+        expect(formatter.from(:json).class).to eq(MauxRobot::Formatter::Json)
+      end
+    end
+
+    describe "invalid format_types" do
+      it "defaults to csv formatter" do
+        expect(formatter.from(:anything).class).to eq(MauxRobot::Formatter::Csv)
+      end
+    end
+  end
+end

data/spec/maux_robot/parser_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+describe MauxRobot::Parser do
+  subject(:parser) { described_class.new }
+
+  describe "#parse" do
+    context "with valid orders" do
+      it "#report" do
+        expect(parser.parse("REPORT")).to eq(order: :report)
+      end
+
+      it "#report csv" do
+        expect(parser.parse("REPORT CSV")).to eq(order: :report, arguments: {format_type: :csv})
+      end
+
+      it "#report json" do
+        expect(parser.parse("REPORT JSON")).to eq(order: :report, arguments: {format_type: :json})
+      end
+
+      it "#move" do
+        expect(parser.parse("MOVE")).to eq(order: :move)
+      end
+
+      it "#left" do
+        expect(parser.parse("LEFT")).to eq(order: :left)
+      end
+
+      it "#right" do
+        expect(parser.parse("RIGHT")).to eq(order: :right)
+      end
+
+      it "#verbose" do
+        expect(parser.parse("VERBOSE")).to eq(order: :verbose)
+      end
+
+      it "#place" do
+        expect(parser.parse("PLACE 0,3,WEST")).to eq(order: :place, arguments: {x: "0", y: "3", face: "WEST"})
+      end
+    end
+
+    context "with orders with spaces and downcase" do
+      it "#report" do
+        expect(parser.parse("    repoRT")).to eq(order: :report)
+      end
+
+      it "#move" do
+        expect(parser.parse("move      ")).to eq(order: :move)
+      end
+
+      it "#left" do
+        expect(parser.parse("   LefT ")).to eq(order: :left)
+      end
+
+      it "#right" do
+        expect(parser.parse("   rigHt")).to eq(order: :right)
+      end
+
+      it "#place" do
+        expect(parser.parse("PLACE 2 ,  1 ,  NOrth")).to eq(
+          order: :place, arguments: {x: "2", y: "1", face: "NOrth"}
+        )
+      end
+    end
+
+    context "with invalid orders" do
+      it "ignores anything else" do
+        expect(parser.parse("blablabla balbla")).to be_nil
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/spec/maux_robot/position_spec.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require 'maux_robot'
-
+# rubocop:disable Metrics/BlockLength:
 describe MauxRobot::Position do
-  describe '#initialize' do
-    context 'given text input' do
-      it 'should normalize arguments' do
-        position = MauxRobot::Position.new('0', '1', 'SOUTH')
+  describe "#initialize" do
+    context "when text input is given" do
+      it "normalizes arguments" do
+        position = described_class.new("0", "1", "SOUTH")
 
         expect(position.x).to eq(0)
         expect(position.y).to eq(1)
@@ -15,65 +14,65 @@ describe MauxRobot::Position do
     end
   end
 
-  describe '#valid_direction?' do
-    context 'given a possible diretion' do
-      it 'should be valid' do
-        position = MauxRobot::Position.new(5, 0, :south)
+  describe "#valid_direction?" do
+    context "when a possible diretion is given" do
+      it "is valid" do
+        position = described_class.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)
+    context "when a not possible direction is given" do
+      it "is not valid " do
+        position = described_class.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) }
+  describe "rotation" do
+    let(:position) { described_class.new(2, 2, :north) }
 
-    context '#turn_left' do
-      it 'should rotate counter-clockwise' do
-        position.turn_left
+    describe "#left" do
+      it "rotates counter-clockwise" do
+        position.left
         expect(position.face).to eq(:west)
 
-        position.turn_left
+        position.left
         expect(position.face).to eq(:south)
 
-        position.turn_left
+        position.left
         expect(position.face).to eq(:east)
 
-        position.turn_left
+        position.left
         expect(position.face).to eq(:north)
       end
     end
 
-    context '#turn_right' do
-      it 'should rotate clockwise' do
-        position.turn_right
+    describe "#right" do
+      it "rotates clockwise" do
+        position.right
         expect(position.face).to eq(:east)
 
-        position.turn_right
+        position.right
         expect(position.face).to eq(:south)
 
-        position.turn_right
+        position.right
         expect(position.face).to eq(:west)
 
-        position.turn_right
+        position.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) }
+  describe "#forward_position" do # rubocop:disable Metrics/BlockLength
+    context "when facing north" do
+      let(:position) { described_class.new(5, 0, :north) }
 
-      it 'should return a new position 1 step upwards' do
+      it "returns a new position 1 step upwards" do
         new_position = position.forward_position
         expect(position.x).to eq(5)
         expect(position.y).to eq(0)
@@ -82,10 +81,10 @@ describe MauxRobot::Position do
       end
     end
 
-    context 'facing west' do
-      let(:position) { MauxRobot::Position.new(2, 1, :west) }
+    context "when facing west" do
+      let(:position) { described_class.new(2, 1, :west) }
 
-      it 'should return a new position 1 step leftwards' do
+      it "returns a new position 1 step leftwards" do
         new_position = position.forward_position
         expect(position.x).to eq(2)
         expect(position.y).to eq(1)
@@ -94,10 +93,10 @@ describe MauxRobot::Position do
       end
     end
 
-    context 'facing south' do
-      let(:position) { MauxRobot::Position.new(1, 3, :south) }
+    context "when facing south" do
+      let(:position) { described_class.new(1, 3, :south) }
 
-      it 'should return a new position 1 step downwards' do
+      it "returns a new position 1 step downwards" do
         new_position = position.forward_position
         expect(position.x).to eq(1)
         expect(position.y).to eq(3)
@@ -106,10 +105,10 @@ describe MauxRobot::Position do
       end
     end
 
-    context 'facing east' do
-      let(:position) { MauxRobot::Position.new(2, 0, :east) }
+    context "when facing east" do
+      let(:position) { described_class.new(2, 0, :east) }
 
-      it 'should return a new position 1 step rightwards' do
+      it "returns a new position 1 step rightwards" do
         new_position = position.forward_position
         expect(position.x).to eq(2)
         expect(position.y).to eq(0)
@@ -119,26 +118,30 @@ describe MauxRobot::Position do
     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')
+  describe "#report" do
+    context "when x, y and face are defined" do
+      let(:position) { described_class.new(5, 0, :north) }
+
+      it "prints X,Y,FACE" do
+        expect { position.report }.to output("5,0,NORTH\n").to_stdout
       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')
+    context "when only face is defined" do
+      let(:position) { described_class.new(nil, nil, "SOUTH") }
+
+      it "prints 0,0,FACE" do
+        expect { position.report }.to output("0,0,SOUTH\n").to_stdout
       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')
+    context "when face is not defined" do
+      let(:position) { described_class.new(5, 0, nil) }
+
+      it "prints X,Y,INVALID" do
+        expect { position.report }.to output("5,0,INVALID\n").to_stdout
       end
     end
   end
 end
+# rubocop:enable Metrics/BlockLength:

data/spec/maux_robot/robot_spec.rb

@@ -1,48 +1,42 @@
 # frozen_string_literal: true
 
-require 'maux_robot'
-
-describe MauxRobot::Robot do
+describe MauxRobot::Robot do # rubocop:disable Metrics/BlockLength
   subject(:robot) { described_class.new }
 
-  describe '#place' do
-    context 'given a valid place' do
-      it 'should have a position' do
+  let(:null_position) { MauxRobot::NullPosition.new }
+
+  describe "#place" do
+    context "when given a valid place" do
+      it "has a position" do
         robot.place(x: 0, y: 0, face: :north)
 
-        expect(robot.position).not_to be_nil
+        expect(robot.position).not_to eq null_position
       end
     end
 
-    context 'given an invalid place' do
-      it 'should not have a position' do
-        robot.place(x: 5, y: 0, face: :south)
-
-        expect(robot.position).to be_nil
+    context "when given an invalid place" do
+      it "raises NotOkToGo error" do
+        expect { robot.place(x: 5, y: 0, face: :south) }.to raise_error MauxRobot::NotOkToGo
       end
     end
 
-    context 'given an invalid direction' do
-      it 'should not have a position' do
-        robot.place(x: 0, y: 2, face: :south_east)
-
-        expect(robot.position).to be_nil
+    context "when given an invalid direction" do
+      it "raises NotOkToGo error" do
+        expect { robot.place(x: 0, y: 2, face: :south_east) }.to raise_error MauxRobot::NotOkToGo
       end
     end
   end
 
-  describe '#left' do
-    context 'robot not placed' do
-      it 'should silently ignore' do
-        robot.place(x: 0, y: 2, face: :south_east)
-        robot.left
-
-        expect(robot.position).to be_nil
+  describe "#left" do
+    context "when robot is not placed" do
+      it "raises RobotNotPlacedYet error" do
+        expect { robot.left }.to raise_error MauxRobot::RobotNotPlacedYet
+        expect(robot.position).to eq null_position
       end
     end
 
-    context 'robot placed' do
-      it 'should rotate accordingly' do
+    context "when robot is placed" do
+      it "rotates accordingly" do
         robot.place(x: 1, y: 2, face: :south)
         robot.left
 
@@ -51,18 +45,17 @@ describe MauxRobot::Robot do
     end
   end
 
-  describe '#right' do
-    context 'robot not placed' do
-      it 'should silently ignore' do
-        robot.place(x: 0, y: 2, face: :north_west)
-        robot.right
+  describe "#right" do
+    context "when robot is not placed" do
+      it "raises RobotNotPlacedYet error" do
+        expect { robot.right }.to raise_error MauxRobot::RobotNotPlacedYet
 
-        expect(robot.position).to be_nil
+        expect(robot.position).to eq null_position
       end
     end
 
-    context 'robot placed' do
-      it 'should rotate accordingly' do
+    context "with robot placed" do
+      it "rotates accordingly" do
         robot.place(x: 3, y: 2, face: :north)
         robot.right
 
@@ -71,9 +64,16 @@ describe MauxRobot::Robot do
     end
   end
 
-  describe '#move' do
-    context 'to a place on the table' do
-      it 'should update its position' do
+  describe "#move" do
+    context "with robot not placed" do
+      it "raises RobotNotPlacedYet error" do
+        expect { robot.right }.to raise_error MauxRobot::RobotNotPlacedYet
+        expect(robot.position).to eq null_position
+      end
+    end
+
+    context "when placing on the table" do
+      it "updates its position" do
         robot.place(x: 3, y: 2, face: :north)
         robot.move
 
@@ -83,10 +83,11 @@ describe MauxRobot::Robot do
       end
     end
 
-    context 'to outside the table' do
-      it 'should stay where it is' do
+    context "when outside the table" do
+      it "stays where it is" do
         robot.place(x: 0, y: 0, face: :south)
-        robot.move
+
+        expect { robot.move }.to raise_error MauxRobot::NotOkToGo
 
         expect(robot.position.x).to eq(0)
         expect(robot.position.y).to eq(0)

data/spec/maux_robot/table_spec.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-require 'maux_robot'
-
 describe MauxRobot::Table do
   subject(:table) { described_class.new(x: [-1, 2], y: [3, 6]) }
 
-  context '#contains?' do
-    it 'should contain a position inside boundaries' do
+  describe "#contains?" do
+    it "contains a position inside boundaries" do
       position = MauxRobot::Position.new(0, 4, :north)
       expect(table.contains?(position)).to be true
     end
 
-    it 'should not contain a position outside boundaries' do
+    it "does not contain a position outside boundaries" do
       position = MauxRobot::Position.new(3, 2, :east)
       expect(table.contains?(position)).to be false
     end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require "maux_robot"

metadata

@@ -1,35 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: maux_robot
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Mauricio Vieira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-18 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.6.0
+        version: 0.4.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.6.0
+        version: 0.4.7
 description: "    Maux version of a Toy Robot Simulator.\n"
 email: maux_robot@mauriciovieira.net
 executables:
@@ -44,19 +38,28 @@ files:
 - bin/maux_robot
 - lib/maux_robot.rb
 - lib/maux_robot/cli.rb
+- lib/maux_robot/formatter.rb
+- lib/maux_robot/formatter/csv.rb
+- lib/maux_robot/formatter/json.rb
+- lib/maux_robot/parser.rb
 - lib/maux_robot/position.rb
 - lib/maux_robot/robot.rb
 - lib/maux_robot/table.rb
 - lib/maux_robot/version.rb
 - spec/maux_robot/cli_spec.rb
+- spec/maux_robot/formatter/csv_spec.rb
+- spec/maux_robot/formatter/json_spec.rb
+- spec/maux_robot/formatter_spec.rb
+- spec/maux_robot/parser_spec.rb
 - spec/maux_robot/position_spec.rb
 - spec/maux_robot/robot_spec.rb
 - spec/maux_robot/table_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/mauriciovieira/maux_robot
 licenses:
 - GPL-3.0
 metadata:
-  homepage_uri: https://rubocop.readthedocs.io/
+  homepage_uri: https://github.com/mauriciovieira/maux_robot/blob/master/README.md
   changelog_uri: https://github.com/mauriciovieira/maux_robot/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/mauriciovieira/maux_robot/
   documentation_uri: https://github.com/mauriciovieira/maux_robot/
@@ -69,15 +72,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Maux version of a Toy Robot Simulator.