loco_bot 1.0.0

data/lib/loco_bot/cli.rb

@@ -0,0 +1,67 @@
+require 'loco_bot/cli/command'
+
+module LocoBot
+  # Provides a 'command line'-like interface to interact with the API,
+  # in a limited way: only one Robot and Table instances are available.
+  class CLI
+    # The regexp used to parse input.
+    INPUT_SPLIT_REGEXP = / |,|\s/
+
+    # @!attribute [r] table
+    # @return [Robot] the Robot
+    attr_reader :robot
+
+    # @!attribute [r] table
+    # @return [Table] the Table
+    attr_reader :table
+
+    def initialize
+      @robot = Robot.new
+      @table = Table.new
+    end
+
+    # Reads input for commands.
+    # @param input [String] the input
+    # @note Available commands are:
+    #   - PLACE X,Y,F: put the robot on the table in position X,Y and facing NORTH, SOUTH, EAST or WEST.
+    #   - MOVE: move the robot one unit forward in the direction it is currently facing.
+    #   - LEFT and RIGHT rotate the robot 90 degrees in the specified direction without changing its position.
+    #   - REPORT announces the X,Y and F of the robot.
+    #   - HODOR outputs a friendly greating.
+    # @return [void]
+    def input!(input)
+      parsed_data = parse_input(input)
+
+      return if parsed_data[:command].nil?
+
+      command_class = Command.class_from_name(parsed_data[:command])
+
+      if command_class.nil?
+        puts "#{parsed_data[:command].upcase}: not a known command. Valid commands are #{CLI::Command.list.join(', ')}."
+      else
+        execute_command(command_class, parsed_data[:arguments])
+      end
+    end
+
+    private
+
+    def execute_command(command_class, arguments)
+      begin
+        command_class.new(robot, table).execute(*arguments)
+      rescue ArgumentError => exception
+        puts "#{command_class.label}: #{exception.message}"
+      end
+    end
+
+    def parse_input(input)
+      return {} if input.nil?
+
+      split_data = input.split(INPUT_SPLIT_REGEXP)
+      split_data.reject!(&:empty?)
+
+      return {} if split_data.empty?
+
+      { command: split_data[0], arguments: split_data.drop(1) }
+    end
+  end
+end

data/lib/loco_bot/robot/direction/east.rb

@@ -0,0 +1,37 @@
+module LocoBot
+  class Robot
+    module Direction
+      # East direction.
+      module East
+
+        # Returns the Direction at the left of this one.
+        # @return [Direction::North]
+        def self.left
+          Direction::North
+        end
+
+        # Returns the Direction at the right of this one.
+        # @return [Direction::South]
+        def self.right
+          Direction::South
+        end
+
+        # Returns the Direction's label.
+        # @return [String] the Direction's label
+        def self.label
+          'EAST'
+        end
+
+        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # @param x [Integer] the x-axis coordinate
+        # @param y [Integer] the y-axis coordinate
+        # @return [Hash] the modified x and y coordinates
+        # @example
+        #   Direction::East.coordinates(1, 2) # => {x: 2, y: 2}
+        def self.coordinates(x, y)
+          { x: x + 1, y: y }
+        end
+      end
+    end
+  end
+end

data/lib/loco_bot/robot/direction/north.rb

@@ -0,0 +1,37 @@
+module LocoBot
+  class Robot
+    module Direction
+      # North direction.
+      module North
+
+        # Returns the Direction at the left of this one.
+        # @return [Direction::West]
+        def self.left
+          Direction::West
+        end
+
+        # Returns the Direction at the right of this one.
+        # @return [Direction::East]
+        def self.right
+          Direction::East
+        end
+
+        # Returns the Direction's label.
+        # @return [String] the Direction's label
+        def self.label
+          'NORTH'
+        end
+
+        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # @param x [Integer] the x-axis coordinate
+        # @param y [Integer] the y-axis coordinate
+        # @return [Hash] the modified x and y coordinates
+        # @example
+        #   Direction::North.coordinates(1, 2) # => {x: 1, y: 3}
+        def self.coordinates(x, y)
+          { x: x, y: y + 1 }
+        end
+      end
+    end
+  end
+end

data/lib/loco_bot/robot/direction/south.rb

@@ -0,0 +1,37 @@
+module LocoBot
+  class Robot
+    module Direction
+      # South direction.
+      module South
+
+        # Returns the Direction at the left of this one.
+        # @return [Direction::East]
+        def self.left
+          Direction::East
+        end
+
+        # Returns the Direction at the right of this one.
+        # @return [Direction::West]
+        def self.right
+          Direction::West
+        end
+
+        # Returns the Direction's label.
+        # @return [String] the Direction's label
+        def self.label
+          'SOUTH'
+        end
+
+        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # @param x [Integer] the x-axis coordinate
+        # @param y [Integer] the y-axis coordinate
+        # @return [Hash] the modified x and y coordinates
+        # @example
+        #   Direction::South.coordinates(1, 2) # => {x: 1, y: 1}
+        def self.coordinates(x, y)
+          { x: x, y: y - 1 }
+        end
+      end
+    end
+  end
+end

data/lib/loco_bot/robot/direction/west.rb

@@ -0,0 +1,37 @@
+module LocoBot
+  class Robot
+    module Direction
+      # West direction.
+      module West
+
+        # Returns the Direction at the left of this one.
+        # @return [Direction::South]
+        def self.left
+          Direction::South
+        end
+
+        # Returns the Direction at the right of this one.
+        # @return [Direction::North]
+        def self.right
+          Direction::North
+        end
+
+        # Returns the Direction's label.
+        # @return [String] the Direction's label
+        def self.label
+          'WEST'
+        end
+
+        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # @param x [Integer] the x-axis coordinate
+        # @param y [Integer] the y-axis coordinate
+        # @return [Hash] the modified x and y coordinates
+        # @example
+        #   Direction::West.coordinates(1, 2) # => {x: 0, y: 2}
+        def self.coordinates(x, y)
+          { x: x - 1, y: y }
+        end
+      end
+    end
+  end
+end

data/lib/loco_bot/robot/direction.rb

@@ -0,0 +1,27 @@
+require 'loco_bot/robot/direction/east'
+require 'loco_bot/robot/direction/north'
+require 'loco_bot/robot/direction/south'
+require 'loco_bot/robot/direction/west'
+
+module LocoBot
+  class Robot
+    # Top-level namespace for the possible facing directions.
+    module Direction
+
+      # Returns the list of available Direction as Strings.
+      # @return [Array<String>]
+      def self.list
+        constants.map(&:to_s)
+      end
+
+      # Returns a Direction class that as the same name as the given name.
+      # @param name [String] the Direction name
+      # @return [Command] the Direction
+      def self.from_name(name)
+        if const_defined?(name.capitalize, false)
+          const_get(name.capitalize)
+        end
+      end
+    end
+  end
+end

data/lib/loco_bot/robot.rb

@@ -0,0 +1,102 @@
+require 'loco_bot/robot/direction'
+
+module LocoBot
+  # Representation of a robot, placeable on tables.
+  class Robot
+
+    # @!attribute [rw] table
+    # @return [Table] the Table the Robot is currently placed on
+    attr_accessor :table
+
+    # @!attribute [rw] x
+    # @return [Integer] the x-axis coordinate the Robot is currently at on the Table
+    attr_accessor :x
+
+    # @!attribute [rw] y
+    # @return [Integer] the y-axis coordinate the Robot is currently at on the Table
+    attr_accessor :y
+
+    # @!attribute [rw] direction
+    # @return [Direction] the Direction the Robot is currently facing on the Table
+    attr_accessor :direction
+
+    # Places the Robot on the given Table at the given coordinates, facing the given Direction.
+    # If the Robot was previously on another Table, it is removed from it before being placed on the given.
+    # @param table [Table] the Table to place the Robot at
+    # @param x [Integer] the x-axis coordinate
+    # @param y [Integer] the y-axis coordinate
+    # @param direction [Direction] the facing Direction
+    # @return [Boolean] true if placing was successful, false otherwise.
+    def place(table, x, y, direction)
+      table.place_robot(self, x, y, direction)
+    end
+
+    # Removes the Robot its current Table. Position attributes of the Robot are set to nil.
+    # @return [Boolean] true if removing was successful, false otherwise.
+    def remove
+      return false if table.nil?
+
+      table.remove_robot(self)
+    end
+
+    # Moves the robot one unit forward in the direction it is currently facing.
+    # @return [Boolean] true if moving was successful, false otherwise.
+    def move
+      return false if table.nil? or !table.position_valid?(next_position[:x], next_position[:y])
+
+      @x = next_position[:x]
+      @y = next_position[:y]
+
+      true
+    end
+
+    # Rotates the robot 90 degrees to the left without changing its position.
+    # @return [Boolean] true if turning was successful, false otherwise.
+    def turn_left
+      return false if table.nil?
+
+      @direction = direction.left
+
+      true
+    end
+
+    # Rotates the robot 90 degrees to the right without changing its position.
+    # @return [Boolean] true if turning was successful, false otherwise.
+    def turn_right
+      return false if table.nil?
+
+      @direction = direction.right
+
+      true
+    end
+
+    # Returns a Hash containing the x, y and direction of the robot.
+    # @return [Hash] the x, y and direction of the Robot.
+    # @example
+    #   robot.place(1, 2, Direction::West)
+    #   robot.report # => {x: 1, y: 2, direction: LocoBot::Robot::Direction::West}
+    def report
+      return {} if table.nil?
+
+      {x: x, y: y, direction: direction}
+    end
+
+    # Outputs a friendly greating.
+    # @return [void]
+    def hodor!
+      puts 'HODOR HODOR !'
+    end
+
+    # Returns a Hash containing the next x and y coordinates of the Robot if it moves facing its current direction.
+    # The Hash will be empty if the Robot has not been placed.
+    # @return [Hash] the next x and y coordinates of the Robot.
+    # @example
+    #   robot.place(1, 2, Direction::West)
+    #   robot.next_direction # => {x: 0, y: 2}
+    def next_position
+      return {} if table.nil?
+
+      direction.coordinates(x, y)
+    end
+  end
+end

data/lib/loco_bot/table.rb

@@ -0,0 +1,94 @@
+module LocoBot
+  # Representation of a table on which robots can be placed.
+  class Table
+
+    # @!attribute [r] width
+    # @return [Fixnum] width of the Table
+    # Determines the farthest accessible point on the Table's x-axis.
+    attr_reader :width
+
+    # @!attribute [r] height
+    # @return [Fixnum] height of the table
+    # Determines the farthest accessible point on the Table's y-axis.
+    attr_reader :height
+
+    # @!attribute [r] robots
+    # @return [Array<Robot>] a collection of [Robot]
+    # The collection of Robots currently placed on the Table.
+    attr_reader :robots
+
+    # @param width [Integer] The width of the Table
+    # @param height [Integer] The height of the Table
+    def initialize(width = 5, height = 5)
+      @width = width
+      @height = height
+      @robots = []
+
+      validate_dimensions
+    end
+
+    # Places the given Robot on the Table at the given coordinates, facing the given Direction.
+    # If the Robot was previously on another Table, it is removed from it before being placed on the current.
+    # @param robot [Robot] the Robot to place on the Table
+    # @param x [Integer] the x-axis coordinate
+    # @param y [Integer] the y-axis coordinate
+    # @param direction [Direction] the facing Direction
+    # @return [Boolean] true if placing was successful, false otherwise.
+    def place_robot(robot, x, y, direction)
+      return false unless position_valid?(x, y)
+
+      robot.table.remove_robot(robot) if robot.table
+
+      robot.table = self
+      robot.direction = direction
+      robot.x = x
+      robot.y = y
+
+      @robots.push(robot) unless robots.include?(robot)
+
+      true
+    end
+
+    # Removes the given Robot from the Table. Position attributes of the Robot are set to nil
+    # @param robot [Robot] the Robot to remove from the Table
+    # @return [Boolean] true if removing was successful, false otherwise.
+    def remove_robot(robot)
+      return false unless robots.include?(robot)
+
+      robot.table = nil
+      robot.x = nil
+      robot.y = nil
+      robot.direction = nil
+
+      @robots.delete(robot)
+
+      true
+    end
+
+    # Determines whether a Robot can be placed at the given coordinates.
+    # @param x [Integer] the x-axis coordinate
+    # @param y [Integer] the y-axis coordinate
+    # @return [Boolean] true if a Robot can be placed at the given coordinates, false otherwise.
+    def position_valid?(x, y)
+      position_within_bounds?(x, y) and position_free?(x, y)
+    end
+
+    private
+
+    def position_within_bounds?(x, y)
+      x >= 0 && y >= 0 && x < width && y < height
+    end
+
+    def position_free?(x, y)
+      robots.none? {|robot| robot.x == x && robot.y == y }
+    end
+
+    def validate_dimensions
+      errors = []
+      errors << "#{width} is not a valid width: it must be > 0" unless width > 0
+      errors << "#{height} is not a valid height: it must be > 0" unless height > 0
+
+      raise ArgumentError.new(errors.join(', ')) unless errors.empty?
+    end
+  end
+end

data/lib/loco_bot/version.rb

@@ -0,0 +1,4 @@
+module LocoBot
+  # The gem's current version
+  VERSION = '1.0.0'
+end

data/lib/loco_bot.rb

@@ -0,0 +1,8 @@
+require 'loco_bot/cli'
+require 'loco_bot/robot'
+require 'loco_bot/table'
+require 'loco_bot/version'
+
+# Top-level namespace of the gem.
+module LocoBot
+end

data/loco_bot.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'loco_bot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'loco_bot'
+  spec.version       = LocoBot::VERSION
+  spec.authors       = ['Rafaël Gonzalez']
+  spec.email         = ['github@rafaelgonzalez.me']
+  spec.summary       = %q{Ruby gem of crazy robots and benevolent tables that keep watching over them.}
+  spec.description   = %q{Issue commands to control the robots and the tables will keep you from making them fall, you monster!}
+  spec.homepage      = 'https://github.com/rafaelgonzalez/loco_bot'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov', '~> 0.9'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.4.0'
+end

data/spec/loco_bot/cli/command/hodor_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe LocoBot::CLI::Command::Hodor do
+  let(:robot) { LocoBot::Robot.new }
+  let(:table) { LocoBot::Table.new }
+
+  subject { described_class.new(robot, table) }
+
+  describe '#execute' do
+    it 'calls #hodor! on robot' do
+      expect(subject.robot).to receive(:hodor!).with(no_args).once
+
+      subject.execute
+    end
+  end
+end

data/spec/loco_bot/cli/command/left_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe LocoBot::CLI::Command::Left do
+  let(:robot) { LocoBot::Robot.new }
+  let(:table) { LocoBot::Table.new }
+
+  subject { described_class.new(robot, table) }
+
+  describe '#execute' do
+    it 'calls #turn_left on robot' do
+      expect(subject.robot).to receive(:turn_left).with(no_args).once
+
+      subject.execute
+    end
+  end
+end

data/spec/loco_bot/cli/command/move_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe LocoBot::CLI::Command::Move do
+  let(:robot) { LocoBot::Robot.new }
+  let(:table) { LocoBot::Table.new }
+
+  subject { described_class.new(robot, table) }
+
+  describe '#execute' do
+    it 'calls #move on robot' do
+      expect(subject.robot).to receive(:move).with(no_args).once
+
+      subject.execute
+    end
+  end
+end

data/spec/loco_bot/cli/command/place_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe LocoBot::CLI::Command::Place do
+  let(:robot) { LocoBot::Robot.new }
+  let(:table) { LocoBot::Table.new }
+
+  subject { described_class.new(robot, table) }
+
+  describe '#execute' do
+    it 'calls #place on robot' do
+      expect(subject.robot).to receive(:place).with(table, 3, 2, LocoBot::Robot::Direction::West).once
+
+      subject.execute('3', '2', 'west')
+    end
+  end
+end

data/spec/loco_bot/cli/command/report_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe LocoBot::CLI::Command::Report do
+  let(:robot) { LocoBot::Robot.new }
+  let(:table) { LocoBot::Table.new }
+
+  subject { described_class.new(robot, table) }
+
+  describe '#execute' do
+    context 'before placing robot' do
+      it 'does not output a string' do
+        expect { subject.execute }.not_to output.to_stdout
+      end
+    end
+
+    context 'after placing robot' do
+      before { subject.robot.place(table, 4 ,2 , LocoBot::Robot::Direction::East) }
+
+      it 'outputs a string' do
+        expect { subject.execute }.to output("4,2,EAST\n").to_stdout
+      end
+    end
+  end
+end

data/spec/loco_bot/cli/command/right_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe LocoBot::CLI::Command::Right do
+  let(:robot) { LocoBot::Robot.new }
+  let(:table) { LocoBot::Table.new }
+
+  subject { described_class.new(robot, table) }
+
+  describe '#execute' do
+    it 'calls #turn_right on robot' do
+      expect(subject.robot).to receive(:turn_right).with(no_args).once
+
+      subject.execute
+    end
+  end
+end

data/spec/loco_bot/cli/command_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe LocoBot::CLI::Command do
+  describe '.list' do
+    subject { described_class.list }
+
+    it { is_expected.to eql ['HODOR', 'LEFT', 'MOVE', 'PLACE', 'REPORT', 'RIGHT'] }
+  end
+
+  describe '.class_from_name' do
+    subject { described_class.class_from_name(direction) }
+
+    context 'passing :base' do
+      let(:direction) { :base }
+
+      it { is_expected.to eql nil }
+    end
+
+    context 'passing :hodor' do
+      let(:direction) { :hodor }
+
+      it { is_expected.to eql LocoBot::CLI::Command::Hodor }
+    end
+
+    context 'passing :left' do
+      let(:direction) { :left }
+
+      it { is_expected.to eql LocoBot::CLI::Command::Left }
+    end
+
+    context 'passing :move' do
+      let(:direction) { :move }
+
+      it { is_expected.to eql LocoBot::CLI::Command::Move }
+    end
+
+    context 'passing :place' do
+      let(:direction) { :place }
+
+      it { is_expected.to eql LocoBot::CLI::Command::Place }
+    end
+
+    context 'passing :report' do
+      let(:direction) { :report }
+
+      it { is_expected.to eql LocoBot::CLI::Command::Report }
+    end
+
+    context 'passing :right' do
+      let(:direction) { :right }
+
+      it { is_expected.to eql LocoBot::CLI::Command::Right }
+    end
+  end
+end

data/spec/loco_bot/cli_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe LocoBot::CLI do
+  describe '#initialize' do
+    subject { described_class.new }
+
+    it { expect(subject.robot).to be_an_instance_of(LocoBot::Robot) }
+    it { expect(subject.table).to be_an_instance_of(LocoBot::Table) }
+  end
+
+  describe '#input!' do
+    let(:input) { "#{command} #{arguments}" }
+
+    context 'using a valid command' do
+      let(:command) { :place }
+
+      context 'with a valid number of arguments' do
+        let(:arguments) { '1, 3, SOUTH' }
+      end
+
+      context 'with an invalid number of arguments' do
+        let(:arguments) { '1, 2' }
+
+        it 'outputs a custom ArgumentError message' do
+          expect { subject.input!(input) }.to output("PLACE: wrong number of arguments (2 for 3)\n").to_stdout
+        end
+      end
+    end
+
+    context 'using an invalid command' do
+      let(:command) { :yadayada }
+      let(:arguments) { '' }
+
+      it 'does not raise an error' do
+        expect { subject.input!(input) }.to output("YADAYADA: not a known command. Valid commands are HODOR, LEFT, MOVE, PLACE, REPORT, RIGHT.\n").to_stdout
+      end
+    end
+  end
+end