toy 0.1.0

data/lib/toy/unit.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Toy
+  class Unit
+    attr_reader :table, :x, :y, :object
+
+    def initialize(table=Table.new, x, y)
+      raise Error::CoordinateError unless x.is_a?(Fixnum)
+      raise Error::CoordinateError unless y.is_a?(Fixnum)
+      raise Error::TableError unless table.is_a?(Table)
+
+      @table = table
+      @x = x
+      @y = y
+      @object = nil
+    end
+
+    def hold!(object)
+      @object = object
+    end
+
+    def release!
+      @object = nil
+    end
+
+    def available?
+      @object.nil?
+    end
+
+    module Error
+      class CoordinateError < ArgumentError
+        def message
+          'Coordinates must be of type Fixnum!'
+        end
+      end
+
+      class TableError < ArgumentError
+        def message
+          'Table must be of type Table!'
+        end
+      end
+    end
+  end
+end

data/lib/toy/unit_collection.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Toy
+  class UnitCollection
+    attr_reader :all
+
+    def initialize(direction=Toy::Direction)
+      @all = []
+      @direction = direction
+    end
+
+    def add(unit)
+      raise Error::UnitError unless unit.is_a?(Unit)
+      
+      @all << unit
+    end
+
+    def find_by_coordinates(x, y)
+      @all.find { |unit| unit.x == x && unit.y == y }
+    end
+
+    def find_by_object(object)
+      @all.find { |unit| unit.object == object }
+    end
+
+    def find_north_of(x, y)
+      @all.find { |unit| unit.x == x && unit.y == y.succ }
+    end
+
+    def find_east_of(x, y)
+      @all.find { |unit| unit.x == x.succ && unit.y == y }
+    end
+
+    def find_south_of(x, y)
+      @all.find { |unit| unit.x == x && unit.y == y.pred }
+    end
+
+    def find_west_of(x, y)
+      @all.find { |unit| unit.x == x.pred && unit.y == y }
+    end
+
+    def find_by_direction_of(x, y, direction)
+      raise Error::DirectionError unless @direction::DIRECTION.include?(direction)
+
+      send("find_#{direction}_of", x, y)
+    end
+
+    module Error
+      class UnitError < ArgumentError
+        def message
+          'Argument must be of type Unit!'
+        end
+      end
+
+      class DirectionError < ArgumentError
+        def message
+          'Invalid direction!'
+        end
+      end
+    end
+  end
+end

data/lib/toy/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Toy
+  VERSION = '0.1.0'
+end

data/spec/controller_spec.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Toy::Controller do
+  let(:controller) { Toy::Controller.new }
+
+  describe '#start' do
+    context 'on invalid command' do
+      before { allow(controller).to receive(:gets).and_return('INVALID', 'STOP') }
+
+      specify do
+        expect { controller.start }.to output("Invalid command! Type HELP for list of available commands.\n").to_stdout
+      end
+    end
+
+    context 'on HELP' do
+      before { allow(controller).to receive(:gets).and_return('HELP', 'STOP') }
+
+      specify do
+        expect { controller.start }.to output("Available commands: STOP HELP PLACE MOVE LEFT RIGHT REPORT\n").to_stdout
+      end
+    end
+
+    context 'on PLACE' do
+      context 'when valid arguments' do
+        before { allow(controller).to receive(:gets).and_return('PLACE 1,1,NORTH', 'STOP') }
+
+        specify do
+          controller.start
+          expect(controller.robot.position).to eq([1, 1, :north]) 
+        end
+      end
+
+      context 'when invalid coordinates' do
+        before { allow(controller).to receive(:gets).and_return('PLACE 1,INVALID,NORTH', 'STOP') }
+
+        specify do
+          expect { controller.start }.to output("Coordinates must be of type Fixnum!\n").to_stdout
+        end
+      end
+
+      context 'when invalid direciton' do
+        before { allow(controller).to receive(:gets).and_return('PLACE 1,1,INVALID', 'STOP') }
+
+        specify do
+          expect { controller.start }.to output("Invalid direction!\n").to_stdout
+        end
+      end
+
+      context 'when invalid arguments' do
+        before { allow(controller).to receive(:gets).and_return('PLACE 1,INVALID', 'STOP') }
+
+        specify do
+          expect { controller.start }.to output("Invalid placement arguments!\n").to_stdout
+        end
+      end
+
+      context 'when unit is taken' do
+        before { allow(controller).to receive(:gets).and_return('PLACE 1,1,NORTH','PLACE 1,1,NORTH', 'STOP') }
+
+        specify do
+          expect { controller.start }.to output("Not available!\n").to_stdout
+        end
+      end
+
+      context 'when unit is not non-existant' do
+        before { allow(controller).to receive(:gets).and_return('PLACE 12,12,NORTH', 'STOP') }
+
+        specify do
+          expect { controller.start }.to output("Not available!\n").to_stdout
+        end
+      end
+    end
+
+    context 'on MOVE' do
+      before { allow(controller).to receive(:gets).and_return('MOVE', 'STOP') }
+
+      context 'when placed' do
+        context 'when unit is available' do
+          before { controller.robot.place(0, 0, :north) }
+
+          specify do
+            controller.start
+            expect(controller.robot.position).to eq([0, 1, :north]) 
+          end
+        end
+
+        context 'when unit is not available' do
+          before { controller.robot.place(0, 0, :south) }
+
+          specify do
+            controller.start
+            expect(controller.robot.position).to eq([0, 0, :south]) 
+          end
+        end
+      end
+
+      context 'when not placed' do
+        specify do
+          expect { controller.start }.to output("Robot is not placed!\n").to_stdout
+        end
+      end
+    end
+
+    context 'on LEFT' do
+      before { allow(controller).to receive(:gets).and_return('LEFT', 'STOP') }
+
+      context 'when placed' do
+        before { controller.robot.place(0, 0, :north) }
+
+        specify do
+          controller.start
+          expect(controller.robot.facing).to eq(:west) 
+        end
+      end
+
+      context 'when not placed' do
+        specify do
+          expect { controller.start }.to output("Robot is not placed!\n").to_stdout
+        end
+      end
+    end
+
+    context 'on RIGHT' do
+      before { allow(controller).to receive(:gets).and_return('RIGHT', 'STOP') }
+
+      context 'when placed' do
+        before { controller.robot.place(0, 0, :north) }
+
+        specify do
+          controller.start
+          expect(controller.robot.facing).to eq(:east) 
+        end
+      end
+
+      context 'when not placed' do
+        specify do
+          expect { controller.start }.to output("Robot is not placed!\n").to_stdout
+        end
+      end
+    end
+
+    context 'on REPORT' do
+      before { allow(controller).to receive(:gets).and_return('REPORT', 'STOP') }
+
+      context 'when placed' do
+        before { controller.robot.place(0, 0, :north) }
+
+        specify do
+          expect { controller.start }.to output("0,0,NORTH\n").to_stdout
+        end
+      end
+
+      context 'when not placed' do
+        specify do
+          expect { controller.start }.to output("Robot is not placed!\n").to_stdout
+        end
+      end
+    end
+  end
+end

data/spec/direction_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Toy::Direction do
+  let(:direction) { Toy::Direction }
+
+  describe '.rotate_left' do
+    context 'when valid arguments' do
+      specify { expect(direction.rotate_left(:north)).to eq(:west) }
+      specify { expect(direction.rotate_left(:east)).to eq(:north) }
+    end
+
+    context 'when invalid arguments' do
+      specify do 
+        expect { direction.rotate_left(:invalid) }.to \
+          raise_error Toy::Direction::Error::DirectionError, 'Invalid direction!'
+      end
+    end
+  end
+
+  describe '.rotate_right' do
+    context 'when valid arguments' do
+      specify { expect(direction.rotate_right(:west)).to eq(:north) }
+      specify { expect(direction.rotate_right(:east)).to eq(:south) }
+    end
+
+    context 'when invalid arguments' do
+      specify do 
+        expect { direction.rotate_right(:invalid) }.to \
+          raise_error Toy::Direction::Error::DirectionError, 'Invalid direction!'
+      end
+    end
+  end
+end

data/spec/robot_spec.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Toy::Robot do
+  let(:robot) { Toy::Robot.new }
+
+  describe '#facing' do
+    context 'when placed' do
+      before { robot.place(0, 0, :north) }
+
+      specify { expect(robot.facing).to eq(:north) }
+    end
+
+    context 'when not placed' do
+      specify { expect(robot.facing).to eq(nil) }
+    end
+  end
+
+  describe '#table' do
+    specify { expect(robot.table.is_a?(Table)).to eq(true) }
+  end
+
+  describe '#place' do
+    context 'when valid arguments' do
+      before { robot.place(0, 0, :north) }
+
+      specify { expect(robot.facing).to eq(:north) }
+      specify { expect(robot.position).to eq([0, 0, :north]) }
+    end
+
+    context 'when invalid direction' do
+      specify do 
+        expect { robot.place(0, 0, :invalid) }.to \
+          raise_error Toy::Direction::Error::DirectionError, 'Invalid direction!'
+      end
+    end
+
+    context 'when invalid coordinate' do
+      specify do 
+        expect { robot.place(:invalid, 0, :north) }.to \
+          raise_error(Toy::Unit::Error::CoordinateError, 'Coordinates must be of type Fixnum!')
+      end
+
+      specify do 
+        expect { robot.place(0, :invalid, :north) }.to \
+          raise_error(Toy::Unit::Error::CoordinateError, 'Coordinates must be of type Fixnum!')
+      end
+    end
+  end
+
+  describe '#placed?' do
+    context 'when placed' do
+      before { robot.place(0, 0, :north) }
+
+      specify { expect(robot.placed?).to eq(true) }
+    end
+
+    context 'when not placed' do
+      specify { expect(robot.placed?).to eq(false) }
+    end
+  end
+
+  describe '#position' do
+    context 'when placed' do
+      before { robot.place(0, 0, :north) }
+
+      specify { expect(robot.position).to eq([0, 0, :north]) }
+    end
+
+    context 'when not placed' do
+      specify do
+        expect { robot.position }.to \
+          raise_error(Toy::Robot::Error::PlacementError, 'Robot is not placed!')
+      end
+    end
+  end
+
+  describe '#move!' do
+    context 'when placed' do
+      context 'when target unit is available' do
+        before do 
+          robot.place(0, 0, :north) 
+          robot.move!
+        end
+
+        specify { expect(robot.position).to eq([0, 1, :north]) }
+      end
+
+      context 'when target unit is not available' do
+        before do 
+          robot.place(0, 0, :south) 
+          robot.move!
+        end
+
+        specify { expect(robot.position).to eq([0, 0, :south]) }
+      end
+    end
+
+    context 'when not placed' do
+      specify do 
+        expect { robot.move! }.to \
+          raise_error(Toy::Robot::Error::PlacementError, 'Robot is not placed!')
+      end
+    end
+  end
+
+  describe '#turn_left!' do
+    context 'when placed' do
+      before do 
+        robot.place(0, 0, :north)
+        robot.turn_left!
+      end
+
+      specify { expect(robot.position).to eq([0, 0, :west]) }
+    end
+
+    context 'when not placed' do
+      specify do 
+        expect { robot.turn_left! }.to \
+          raise_error(Toy::Robot::Error::PlacementError, 'Robot is not placed!')
+      end
+    end
+  end
+
+  describe '#turn_right!' do
+    context 'when placed' do
+      before do 
+        robot.place(0, 0, :north)
+        robot.turn_right!
+      end
+
+      specify { expect(robot.position).to eq([0, 0, :east]) }
+    end
+
+    context 'when not placed' do
+      specify do 
+        expect { robot.turn_right! }.to \
+          raise_error(Toy::Robot::Error::PlacementError, 'Robot is not placed!')
+      end
+    end
+  end
+end