loco_bot 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef33dd6ab2797541d85647722519e50e1fcf5c56
-  data.tar.gz: 2695c38bbc217dd317ba7ab67cfc6681e4034be7
+  metadata.gz: 5bcc03fc9e471fbe3836c3d97c8f4b2c1781c3b4
+  data.tar.gz: 3422b70bf9684df8760c86aee333509d3c3ea18f
 SHA512:
-  metadata.gz: 713365f6dd107ae2ac6410e192d5f77d4da7fd60590f289b409967e29dad9a83987103a6be79800092d0d02eba6b27a15b1f28dec10ac205736b1b4b0db69526
-  data.tar.gz: 511a8c28a3cfcd05ceb5b925f15c4cebfa250ca6a7b219657403c80d829add94e1c070248112b6260641a6805a94f505aa4a49828696ba914941d776663de2ac
+  metadata.gz: f6e1f94945da2600e5d87060c1d86a38609e38b762c2b270a2f603306b7bd762aa93883a1b6627d82a9a545d6f5a07471337a266bb1af7b4b11c1141f5a8a4d5
+  data.tar.gz: 1a543d54eb4229da4fe29d915b1f4f9251d31e9d9b56f76d34807d611193cfcec09c9cc3e2b1f60338d934224669109cf8ab08bea020c7c78acda7ef30f5b053

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

@@ -22,13 +22,13 @@ module LocoBot
           'EAST'
         end
 
-        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # The Direction is applied to the given coordinates and returns vectorial coordinates in a Hash.
         # @param x [Integer] the x-axis coordinate
         # @param y [Integer] the y-axis coordinate
-        # @return [Hash] the modified x and y coordinates
+        # @return [Hash] the vectorial x and y coordinates
         # @example
-        #   Direction::East.coordinates(1, 2) # => {x: 2, y: 2}
-        def self.coordinates(x, y)
+        #   Direction::East.vector(1, 2) # => {x: 2, y: 2}
+        def self.vector(x, y)
           { x: x + 1, y: y }
         end
       end

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

@@ -22,13 +22,13 @@ module LocoBot
           'NORTH'
         end
 
-        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # The Direction is applied to the given coordinates and returns vectorial coordinates in a Hash.
         # @param x [Integer] the x-axis coordinate
         # @param y [Integer] the y-axis coordinate
-        # @return [Hash] the modified x and y coordinates
+        # @return [Hash] the vectorial x and y coordinates
         # @example
-        #   Direction::North.coordinates(1, 2) # => {x: 1, y: 3}
-        def self.coordinates(x, y)
+        #   Direction::North.vector(1, 2) # => {x: 1, y: 3}
+        def self.vector(x, y)
           { x: x, y: y + 1 }
         end
       end

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

@@ -22,13 +22,13 @@ module LocoBot
           'SOUTH'
         end
 
-        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # The Direction is applied to the given coordinates and returns vectorial coordinates in a Hash.
         # @param x [Integer] the x-axis coordinate
         # @param y [Integer] the y-axis coordinate
-        # @return [Hash] the modified x and y coordinates
+        # @return [Hash] the vectorial x and y coordinates
         # @example
-        #   Direction::South.coordinates(1, 2) # => {x: 1, y: 1}
-        def self.coordinates(x, y)
+        #   Direction::South.vector(1, 2) # => {x: 1, y: 1}
+        def self.vector(x, y)
           { x: x, y: y - 1 }
         end
       end

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

@@ -22,13 +22,13 @@ module LocoBot
           'WEST'
         end
 
-        # Returns the given coordinates in a Hash, modified to reflect the Direction.
+        # The Direction is applied to the given coordinates and returns vectorial coordinates in a Hash.
         # @param x [Integer] the x-axis coordinate
         # @param y [Integer] the y-axis coordinate
-        # @return [Hash] the modified x and y coordinates
+        # @return [Hash] the vectorial x and y coordinates
         # @example
-        #   Direction::West.coordinates(1, 2) # => {x: 0, y: 2}
-        def self.coordinates(x, y)
+        #   Direction::West.vector(1, 2) # => {x: 0, y: 2}
+        def self.vector(x, y)
           { x: x - 1, y: y }
         end
       end

data/lib/loco_bot/robot.rb

@@ -4,21 +4,21 @@ module LocoBot
   # Representation of a robot, placeable on tables.
   class Robot
 
-    # @!attribute [rw] table
+    # @!attribute [r] table
     # @return [Table] the Table the Robot is currently placed on
-    attr_accessor :table
+    attr_reader :table
 
-    # @!attribute [rw] x
+    # @!attribute [r] x
     # @return [Integer] the x-axis coordinate the Robot is currently at on the Table
-    attr_accessor :x
+    attr_reader :x
 
-    # @!attribute [rw] y
+    # @!attribute [r] y
     # @return [Integer] the y-axis coordinate the Robot is currently at on the Table
-    attr_accessor :y
+    attr_reader :y
 
-    # @!attribute [rw] direction
+    # @!attribute [r] direction
     # @return [Direction] the Direction the Robot is currently facing on the Table
-    attr_accessor :direction
+    attr_reader :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.
@@ -31,7 +31,7 @@ module LocoBot
       table.place_robot(self, x, y, direction)
     end
 
-    # Removes the Robot its current Table. Position attributes of the Robot are set to nil.
+    # Removes the Robot from 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?
@@ -42,7 +42,7 @@ module LocoBot
     # 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])
+      return false unless next_position_valid?
 
       @x = next_position[:x]
       @y = next_position[:y]
@@ -92,11 +92,19 @@ module LocoBot
     # @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}
+    #   robot.next_position # => {x: 0, y: 2}
     def next_position
       return {} if table.nil?
 
-      direction.coordinates(x, y)
+      direction.vector(x, y)
+    end
+
+    # Determines if the next position position of the Robot is valid according to its Table.
+    # @return [Boolean] true if the position is valid, false otherwise.
+    def next_position_valid?
+      return false if table.nil?
+
+      table.position_valid?(next_position[:x], next_position[:y])
     end
   end
 end

data/lib/loco_bot/table.rb

@@ -12,11 +12,6 @@ module LocoBot
     # 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)
@@ -37,28 +32,28 @@ module LocoBot
     def place_robot(robot, x, y, direction)
       return false unless position_valid?(x, y)
 
-      robot.table.remove_robot(robot) if robot.table
+      robot.remove if robot.table
 
-      robot.table = self
-      robot.direction = direction
-      robot.x = x
-      robot.y = y
+      robot.instance_variable_set(:@table, self)
+      robot.instance_variable_set(:@x, x)
+      robot.instance_variable_set(:@y, y)
+      robot.instance_variable_set(:@direction, direction)
 
       @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
+    # 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
+      robot.instance_variable_set(:@table, nil)
+      robot.instance_variable_set(:@x, nil)
+      robot.instance_variable_set(:@y, nil)
+      robot.instance_variable_set(:@direction, nil)
 
       @robots.delete(robot)
 
@@ -73,6 +68,12 @@ module LocoBot
       position_within_bounds?(x, y) and position_free?(x, y)
     end
 
+    # The collection of Robots currently placed on the Table.
+    # @return [Array<Robot>] a collection of Robots
+    def robots
+      @robots.dup
+    end
+
     private
 
     def position_within_bounds?(x, y)

data/lib/loco_bot/version.rb

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

data/spec/loco_bot/cli_spec.rb

@@ -14,6 +14,17 @@ RSpec.describe LocoBot::CLI do
 
       context 'with a valid number of arguments' do
         let(:arguments) { '1, 3, SOUTH' }
+        let(:command_class_double) { double }
+
+        it 'calls the correct command' do
+          expect(LocoBot::CLI::Command::Place).to receive(:new).
+                                                  with(subject.robot, subject.table).
+                                                  once.and_return(command_class_double)
+
+          expect(command_class_double).to receive(:execute).with('1', '3', 'SOUTH').once
+
+          subject.input!(input)
+        end
       end
 
       context 'with an invalid number of arguments' do

data/spec/loco_bot/robot/direction/east_spec.rb

@@ -17,8 +17,8 @@ RSpec.describe LocoBot::Robot::Direction::East do
     it { is_expected.to eql 'EAST' }
   end
 
-  describe '.coordinates' do
-    subject { described_class.coordinates(21, 17) }
+  describe '.vector' do
+    subject { described_class.vector(21, 17) }
 
     it { is_expected.to eql({ x: 22, y: 17 }) }
   end

data/spec/loco_bot/robot/direction/north_spec.rb

@@ -17,8 +17,8 @@ RSpec.describe LocoBot::Robot::Direction::North do
     it { is_expected.to eql 'NORTH' }
   end
 
-  describe '.coordinates' do
-    subject { described_class.coordinates(21, 17) }
+  describe '.vector' do
+    subject { described_class.vector(21, 17) }
 
     it { is_expected.to eql({ x: 21, y: 18 }) }
   end

data/spec/loco_bot/robot/direction/south_spec.rb

@@ -17,8 +17,8 @@ RSpec.describe LocoBot::Robot::Direction::South do
     it { is_expected.to eql 'SOUTH' }
   end
 
-  describe '.coordinates' do
-    subject { described_class.coordinates(21, 17) }
+  describe '.vector' do
+    subject { described_class.vector(21, 17) }
 
     it { is_expected.to eql({ x: 21, y: 16 }) }
   end

data/spec/loco_bot/robot/direction/west_spec.rb

@@ -17,8 +17,8 @@ RSpec.describe LocoBot::Robot::Direction::West do
     it { is_expected.to eql 'WEST' }
   end
 
-  describe '.coordinates' do
-    subject { described_class.coordinates(21, 17) }
+  describe '.vector' do
+    subject { described_class.vector(21, 17) }
 
     it { is_expected.to eql({ x: 20, y: 17 }) }
   end

data/spec/loco_bot/robot_spec.rb

@@ -3,26 +3,104 @@ RSpec.describe LocoBot::Robot do
   let(:table) { LocoBot::Table.new(20, 20) }
 
   describe '#place' do
-    subject { robot }
+    let(:other_table) { LocoBot::Table.new(10, 10) }
+    let(:robot) { described_class.new }
+
+    before { robot.place(other_table, 5, 7, LocoBot::Robot::Direction::West) }
+
+    context 'with a valid position' do
+      it "modifies the table's robot list" do
+        expect(other_table.robots).to include(robot)
+        expect(table.robots).not_to include(robot)
+
+        robot.place(table, 12, 14, LocoBot::Robot::Direction::South)
+
+        expect(other_table.robots).not_to include(robot)
+        expect(table.robots).to include(robot)
+      end
+
+      it 'changes the robot table, x, y and position' do
+        expect(robot.table).to eql other_table
+        expect(robot.x).to eql 5
+        expect(robot.y).to eql 7
+        expect(robot.direction).to eql LocoBot::Robot::Direction::West
+
+        robot.place(table, 12, 14, LocoBot::Robot::Direction::South)
+
+        expect(robot.table).to eql table
+        expect(robot.x).to eql 12
+        expect(robot.y).to eql 14
+        expect(robot.direction).to eql LocoBot::Robot::Direction::South
+      end
+
+      it { expect(robot.place(table, 12, 14, LocoBot::Robot::Direction::South)).to be true }
+    end
+
+    context 'with an invalid position' do
+      it "does not modify the table's robot list" do
+        expect(other_table.robots).to include(robot)
+        expect(table.robots).not_to include(robot)
+
+        robot.place(table, 617, 9001, LocoBot::Robot::Direction::South)
+
+        expect(other_table.robots).to include(robot)
+        expect(table.robots).not_to include(robot)
+      end
+
+      it 'does not change the robot table, x, y and position' do
+        expect(robot.table).to eql other_table
+        expect(robot.x).to eql 5
+        expect(robot.y).to eql 7
+        expect(robot.direction).to eql LocoBot::Robot::Direction::West
 
-    it 'calls Table#place_robot' do
-      expect(table).to receive(:place_robot).with(subject, 9, 3, LocoBot::Robot::Direction::East).once
+        robot.place(table, 617, 9001, LocoBot::Robot::Direction::South)
 
-      subject.place(table, 9, 3, LocoBot::Robot::Direction::East)
+        expect(robot.table).to eql other_table
+        expect(robot.x).to eql 5
+        expect(robot.y).to eql 7
+        expect(robot.direction).to eql LocoBot::Robot::Direction::West
+      end
+
+      it { expect(robot.place(table, 617, 9001, LocoBot::Robot::Direction::South)).to be false }
     end
   end
 
   describe '#remove' do
     subject { robot.remove }
 
+    before do
+      table.place_robot(LocoBot::Robot.new, 3, 4, LocoBot::Robot::Direction::North)
+      table.place_robot(LocoBot::Robot.new, 1, 8, LocoBot::Robot::Direction::West)
+    end
+
     context 'when placed on a table' do
       before { robot.place(table, 6, 17, LocoBot::Robot::Direction::East)  }
 
-      it 'calls Table#remove_robot' do
-        expect(table).to receive(:remove_robot).with(robot).once
+      it "removes the robot from the table's list" do
+        expect(table.robots.count).to eql 3
+        expect(table.robots).to include(robot)
+
+        robot.remove
 
-        subject
+        expect(table.robots.count).to eql 2
+        expect(table.robots).not_to include(robot)
       end
+
+      it 'sets to nil robot table, x, y and direction' do
+        expect(robot.table).to eql table
+        expect(robot.x).to eql 6
+        expect(robot.y).to eql 17
+        expect(robot.direction).to eql LocoBot::Robot::Direction::East
+
+        robot.remove
+
+        expect(robot.table).to be_nil
+        expect(robot.x).to be_nil
+        expect(robot.y).to be_nil
+        expect(robot.direction).to be_nil
+      end
+
+      it { expect(subject).to be true }
     end
 
     context 'when not placed on a table' do
@@ -244,4 +322,29 @@ RSpec.describe LocoBot::Robot do
       end
     end
   end
+
+  describe '#next_position_valid?' do
+    subject { robot.next_position_valid? }
+
+    context 'when not placed on a table' do
+      it { is_expected.to be false }
+    end
+
+
+    context 'when placed on a table' do
+      before { robot.place(table, 0, 0, direction) }
+
+      context 'facing a invalid position' do
+        let(:direction) { LocoBot::Robot::Direction::West }
+
+        it { is_expected.to be false }
+      end
+
+      context 'facing a valid position' do
+        let(:direction) { LocoBot::Robot::Direction::North }
+
+        it { is_expected.to be true }
+      end
+    end
+  end
 end

data/spec/loco_bot/table_spec.rb

@@ -36,7 +36,7 @@ RSpec.describe LocoBot::Table do
     before { other_table.place_robot(robot, 5, 7, LocoBot::Robot::Direction::West) }
 
     context 'with a valid position' do
-      it 'modifies the robot lists' do
+      it 'modifies the robot list' do
         expect(other_table.robots).to include(robot)
         expect(table.robots).not_to include(robot)
 
@@ -64,7 +64,7 @@ RSpec.describe LocoBot::Table do
     end
 
     context 'with an invalid position' do
-      it 'does not modify the robot lists' do
+      it 'does not modify the robot list' do
         expect(other_table.robots).to include(robot)
         expect(table.robots).not_to include(robot)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loco_bot
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Rafaël Gonzalez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-06 00:00:00.000000000 Z
+date: 2015-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -156,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Ruby gem of crazy robots and benevolent tables that keep watching over them.