maux_robot 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 961e2b5489e001d3676b9a8f4360b212b62e677b
-  data.tar.gz: '028a03a16e37befedecb9336b8d1a5f6c3cd78e1'
+SHA256:
+  metadata.gz: 9c718637133d2a7b8dfb7d42fdcd754ce4eff6ec1fba93f7fe5ddaaa612d1cc1
+  data.tar.gz: 064f6ebc5ceefaa8dc44a2ff1f577178675cf362ffb77c3726c6e2ae6f62f1f1
 SHA512:
-  metadata.gz: 1676475a44d162ae4038dc3862e380f81527caf621e3ea74e942ce3d431553476635373cffe05e9f4e468afea18ce5035e2c7d297bbfd3d57d645bf6fb1def11
-  data.tar.gz: ff3e5c81d4c9d4d348b90d7e99e76e683fb14064c2bf4431203498b479de0e60a4d1c2da186a4e4b59f63590e2868c4c1d25e0a63d6bff37dd6abb5ebb591819
+  metadata.gz: 8cd5c5b6adfccdda316a95ac5f88cefbef598239ed2e981c47f10a70b63a0133af84b70b1effafa04dc0643efafa22bb183d8779d43630310e6068a6a854c370
+  data.tar.gz: 51e46cca8fc6e0239ae9c286611fc11e4589959d5338fac2317107fd2703e3112c201ca63e50bdda96aade74e1c2d71a78c02ff7d93f83b40009d9c41c4bed29

data/README.md

@@ -1,4 +1,6 @@
 [![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
 
@@ -105,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,12 +1,14 @@
-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'
+# 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
+end

data/lib/maux_robot/cli.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module MauxRobot
-
   # The CLI is a class responsible of handling command line interface
   class CLI
     attr_reader :robot
@@ -30,11 +29,11 @@ module MauxRobot
     end
 
     def execute(command)
-      if command.has_key?(:arguments)
+      if command.key?(:arguments)
         @robot.send(command[:order], command[:arguments])
       else
         @robot.send(command[:order])
       end
     end
   end
-end
+end

data/lib/maux_robot/formatter.rb

@@ -1,5 +1,6 @@
-module MauxRobot
+# frozen_string_literal: true
 
+module MauxRobot
   module Formatter
     def self.from(format_type)
       case format_type
@@ -10,4 +11,4 @@ module MauxRobot
       end
     end
   end
-end
+end

data/lib/maux_robot/formatter/csv.rb

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

data/lib/maux_robot/formatter/json.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
-module MauxRobot::Formatter
-
-  class Json
-    def generate(position)
-      JSON.generate({x: position.x, y: position.y, face: position.face.upcase.to_s})
+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
+end

data/lib/maux_robot/parser.rb

@@ -1,26 +1,24 @@
 # 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(' ')
+      clean_input = line_input.strip.squeeze(" ").split(" ")
       order = sanitize_order(clean_input.shift)
       return unless order
 
-      command = { order: order }
+      command = {order: order}
 
       if clean_input.any?
-        arguments = sanitize_arguments(order, clean_input.join(''))
+        arguments = sanitize_arguments(order, clean_input.join(""))
         command[:arguments] = arguments
       end
 
       command
     end
 
-
     private
 
     def sanitize_order(input_string)
@@ -31,14 +29,11 @@ module MauxRobot
     def sanitize_arguments(order, arguments)
       case order
       when :place
-        arguments = arguments.delete(' ').split(',')
-        { x: arguments[0], y: arguments[1], face: arguments[2] }
+        arguments = arguments.delete(" ").split(",")
+        {x: arguments[0], y: arguments[1], face: arguments[2]}
       when :report
-        { format_type: arguments.downcase.to_sym }
+        {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
@@ -28,13 +27,15 @@ module MauxRobot
 
     def left
       return self unless valid_direction?
-      next_direction_index = ( POSSIBLE_DIRECTIONS.index(@face) + 1 ) % 4
+
+      next_direction_index = (POSSIBLE_DIRECTIONS.index(@face) + 1) % 4
       @face = POSSIBLE_DIRECTIONS[next_direction_index]
     end
 
     def right
       return self unless valid_direction?
-      next_direction_index = ( POSSIBLE_DIRECTIONS.index(@face) - 1 )
+
+      next_direction_index = (POSSIBLE_DIRECTIONS.index(@face) - 1)
       @face = POSSIBLE_DIRECTIONS[next_direction_index]
     end
 
@@ -46,7 +47,7 @@ module MauxRobot
       Position.new(x, y, @face)
     end
 
-    def report(format_type=:csv)
+    def report(format_type = :csv)
       formatter = MauxRobot::Formatter.from(format_type)
       puts formatter.generate(self)
     end
@@ -61,4 +62,4 @@ module MauxRobot
       super(nil, nil, nil)
     end
   end
-end
+end

data/lib/maux_robot/robot.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-require 'forwardable'
+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!')
+      super("The robot was not placed yet!")
     end
   end
 
@@ -24,18 +23,19 @@ module MauxRobot
   class Robot
     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)
 
       ok_to_go?(position) do
         @position = position
       end
+      @position
     end
 
     def move
@@ -45,6 +45,8 @@ module MauxRobot
         ok_to_go?(next_position) do
           @position = next_position
         end
+
+        @position
       end
     end
 
@@ -68,26 +70,22 @@ module MauxRobot
 
     def verbose
       @talkative = !@talkative
-      is_not = @talkative ? 'is' : 'is not'
+      is_not = @talkative ? "is" : "is not"
       puts "Robot #{is_not} talkative now."
     end
 
     private
 
     def ok_to_go?(position)
-      if @table.contains?(position)
-        yield
-      else
-        raise NotOkToGo.new(position)
-      end
+      raise NotOkToGo, position unless @table.contains?(position)
+
+      yield
     end
 
     def robot_placed?
-      unless @position.class == MauxRobot::NullPosition
-         yield
-      else
-        raise RobotNotPlacedYet
-      end
+      raise RobotNotPlacedYet if @position.class == MauxRobot::NullPosition
+
+      yield
     end
   end
-end
+end

data/lib/maux_robot/table.rb

@@ -1,10 +1,9 @@
 # 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

data/lib/maux_robot/version.rb

@@ -3,14 +3,14 @@
 module MauxRobot
   # This module holds the MauxRobot version information.
   module Version
-    STRING = '0.1.0'.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,21 +1,23 @@
 # frozen_string_literal: true
 
-require 'maux_robot'
+require "maux_robot"
 
 describe MauxRobot::CLI do
+  subject(:cli) { described_class.new }
 
-  describe '#execute' do
-    context 'parsed input without arguments' do
-      it 'should send proper message to robot' do
-        expect(subject.robot).to receive(:move)
-        subject.execute(order: :move)
+  describe "#execute" do
+    let(:position) { MauxRobot::Position.new(0, 2, :east) }
+
+    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 'parsed place command with arguments' do
-      it 'should send proper message to robot' 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

data/spec/maux_robot/formatter/csv_spec.rb

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

data/spec/maux_robot/formatter/json_spec.rb

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

data/spec/maux_robot/formatter_spec.rb

@@ -1,21 +1,23 @@
- # frozen_string_literal: true
+# frozen_string_literal: true
 
 describe MauxRobot::Formatter do
-  context "#from" do
+  subject(:formatter) { described_class }
+
+  describe "#from" do
     describe "valid format_types" do
       it "returns csv formatter" do
-        expect(subject.from(:csv).class).to eq(MauxRobot::Formatter::Csv)
+        expect(formatter.from(:csv).class).to eq(MauxRobot::Formatter::Csv)
       end
 
-      it 'returns json formatter' do
-        expect(subject.from(:json).class).to eq(MauxRobot::Formatter::Json)
+      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(subject.from(:anything).class).to eq(MauxRobot::Formatter::Csv)
+    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
+end

data/spec/maux_robot/parser_spec.rb

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

data/spec/maux_robot/position_spec.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
+# 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)
@@ -13,29 +14,29 @@ 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 '#left' do
-      it 'should rotate counter-clockwise' do
+    describe "#left" do
+      it "rotates counter-clockwise" do
         position.left
         expect(position.face).to eq(:west)
 
@@ -50,8 +51,8 @@ describe MauxRobot::Position do
       end
     end
 
-    context '#right' do
-      it 'should rotate clockwise' do
+    describe "#right" do
+      it "rotates clockwise" do
         position.right
         expect(position.face).to eq(:east)
 
@@ -67,11 +68,11 @@ describe MauxRobot::Position do
     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)
@@ -80,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)
@@ -92,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)
@@ -104,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)
@@ -117,27 +118,30 @@ describe MauxRobot::Position do
     end
   end
 
-  describe '#report' do
-    context 'if x, y and face are defined' do
-      let(:position) { MauxRobot::Position.new(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
+      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 'prints 0,0,FACE' do
+    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 'prints X,Y,INVALID' do
+    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,41 +1,42 @@
 # frozen_string_literal: true
 
-describe MauxRobot::Robot do
+describe MauxRobot::Robot do # rubocop:disable Metrics/BlockLength
   subject(:robot) { described_class.new }
+
   let(:null_position) { MauxRobot::NullPosition.new }
 
-  describe '#place' do
-    context 'given a valid place' do
-      it 'should have a position' do
+  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 eq null_position
       end
     end
 
-    context 'given an invalid place' do
-      it 'should raise NotOkToGo error' do
+    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 raise NotOkToGo error' do
+    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 raise RobotNotPlacedYet error' do
+  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
 
@@ -44,17 +45,17 @@ describe MauxRobot::Robot do
     end
   end
 
-  describe '#right' do
-    context 'robot not placed' do
-      it 'should raise RobotNotPlacedYet error' do
+  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 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
 
@@ -63,16 +64,16 @@ describe MauxRobot::Robot do
     end
   end
 
-  describe '#move' do
-    context 'robot not placed' do
-      it 'should raise RobotNotPlacedYet error' 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 'to a place on the table' do
-      it 'should update its position' do
+    context "when placing on the table" do
+      it "updates its position" do
         robot.place(x: 3, y: 2, face: :north)
         robot.move
 
@@ -82,8 +83,8 @@ 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)
 
         expect { robot.move }.to raise_error MauxRobot::NotOkToGo

data/spec/maux_robot/table_spec.rb

@@ -3,13 +3,13 @@
 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

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

metadata

@@ -1,35 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: maux_robot
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mauricio Vieira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-28 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:
@@ -78,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.