robot-simulator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9cb140774f5e37640651be65f0875aeef72f8e1
+  data.tar.gz: f7fde3553a045be18db5292044d22fc9027e7ab9
+SHA512:
+  metadata.gz: b3ffb093b24db252b7af2a8ecb8e1a4ab734220dc545f29e9c0a5e9e78513e8c62b313be398b85d8ab4938d1a4f95a8086dc2730fb0fa17b7b351580236d6a74
+  data.tar.gz: 187f05a2b7767b5ee1c16e7633eec89423a09be55e3bfb53009fc464ba39f761980c2d15719bebde28035ccc0aeb5bf7868852d247a376092a3212477ef1dcce

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in robot-simulator.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrew Feng
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Robot::Simulator
+
+A robot simulator that can receive commands and move around on a table surface. It will prevent falling from the table, and can report its position.
+
+
+## Installation
+
+Install it using gem:
+
+    $ gem install robot-simulator
+
+Or directly from git repository:
+
+    $ git clone https://mingliangfeng@bitbucket.org/mingliangfeng/robot-simulator.git
+    $ cd robot-simulator
+    $ bundle install
+    $ bundle exec rspec
+
+
+## Environment
+
+* Ruby version: `ruby 2.1.2p95`, best to use rbenv to set the ruby version.
+
+
+## Dependencies
+
+* [thor](https://github.com/erikhuda/thor)
+* [RSpec](https://github.com/rspec/rspec) for testing
+* [rbenv](https://github.com/sstephenson/rbenv) for seting the right ruby version
+
+
+## Usage
+
+#### Use installation
+Once installed, try the following, you will be asked for commands to instruct the robot to move:
+
+    $ robot-simulator
+
+Or alternatively run robot simulator with commands from a text file:
+
+    $ robot-simulator -f /path/to/commands/text/file
+
+#### Use source code
+Get the source code from bitbucket as instructed in Installation section, go to robot-simulator folder and play straightaway:
+
+    $ bundle exec bin/robot-simulator
+    $ bundle exec bin/robot-simulator -f /path/to/commands/text/file
+
+
+## Design
+
+Please see the class diagram [here](https://repository.genmymodel.com/mingliangfeng/robot-simulator).
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/robot-simulator

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'robot/simulator/ui/cli'
+
+Robot::Simulator::UI::CLI.start ARGV

data/lib/robot/simulator.rb

@@ -0,0 +1,7 @@
+require "robot/simulator/version"
+require "robot/simulator/direction"
+require 'robot/simulator/coordinate'
+require 'robot/simulator/track'
+require 'robot/simulator/robot'
+require 'robot/simulator/table'
+require 'robot/simulator/controller'

data/lib/robot/simulator/controller.rb

@@ -0,0 +1,34 @@
+require 'robot/simulator'
+
+module Robot
+  module Simulator
+    # Controller of the game, initialize the game and receive commands from UI
+    class Controller
+      attr_reader :robot
+
+      def initialize
+        @robot = Robot.new Table.new(5, 5)
+      end
+
+      def place(x, y, facing)
+        raise "Invalid PLACE command: PLACE #{x},#{y},#{facing}" unless robot.place Coordinate.new(x, y), Direction.from_str(facing)
+      end
+
+      def move
+        raise "Invalid MOVE command: robot is not on the table or could fall if move" unless robot.move
+      end
+
+      def left
+        raise "Invalid LEFT command: robot is not on the table" unless robot.turn_left
+      end
+
+      def right
+        raise "Invalid RIGHT command: robot is not on the table" unless robot.turn_right
+      end
+
+      def report
+        [robot.current_track.coordinate.x, robot.current_track.coordinate.y, Direction.to_str(robot.current_track.facing)] if robot.current_track
+      end
+    end
+  end
+end

data/lib/robot/simulator/coordinate.rb

@@ -0,0 +1,12 @@
+module Robot
+  module Simulator
+    # Coordinate on the table, starting from (0, 0) on south west corner.
+    class Coordinate
+      attr_reader :x, :y
+
+      def initialize(x, y)
+        @x, @y = x, y
+      end
+    end
+  end
+end

data/lib/robot/simulator/direction.rb

@@ -0,0 +1,43 @@
+module Robot
+  module Simulator
+    module Direction
+      DIRECTIONS = [EAST = 0, NORTH = 1, WEST = 2, SOUTH = 3]
+      TO_STRS = { EAST => 'EAST', NORTH => 'NORTH', WEST => 'WEST', SOUTH => 'SOUTH' }
+      TO_CONSTANTS = TO_STRS.invert
+
+      # Direction on the left when facing current direction
+      # @return [Direction]
+      def self.left(direction)
+        validate direction
+
+        DIRECTIONS[(direction + 1) % 4]
+      end
+
+      # Direction on the right when facing current direction
+      # @return [Direction]
+      def self.right(direction)
+        validate direction
+
+        DIRECTIONS[(direction - 1 + 4) % 4]
+      end
+
+      def self.to_str(direction)
+        validate direction
+
+        TO_STRS[direction]
+      end
+
+      def self.from_str(direction_str)
+        key = (direction_str || "").upcase
+        raise(ArgumentError, "Direction string '#{direction_str}' must be one of #{TO_CONSTANTS.keys}") unless TO_CONSTANTS.keys.include? key
+        TO_CONSTANTS[key]
+      end
+
+      def self.validate(direction)
+        raise(ArgumentError, "Direction must be one of #{DIRECTIONS}") unless DIRECTIONS.include?(direction)
+      end
+
+      private_class_method :validate
+    end
+  end
+end

data/lib/robot/simulator/robot.rb

@@ -0,0 +1,60 @@
+module Robot
+  module Simulator
+    # Robot class corresponds to robot which can move around on the table.
+    class Robot
+      attr_reader :current_track, :table
+
+      def initialize(table)
+        @table = table
+      end
+
+      def place(coordinate, direction)
+        return false unless is_valid_coordinate?(coordinate)
+
+        self.current_track = Track.new coordinate, direction
+      end
+
+      def move
+        return false unless is_on_table?
+
+        newX = current_track.coordinate.x
+        newX += 1 if current_track.facing == Direction::EAST
+        newX -= 1 if current_track.facing == Direction::WEST
+
+        newY = current_track.coordinate.y
+        newY += 1 if current_track.facing == Direction::NORTH
+        newY -= 1 if current_track.facing == Direction::SOUTH
+
+        new_coordinate = Coordinate.new(newX, newY)
+        return false unless is_valid_coordinate? new_coordinate
+
+        self.current_track = Track.new new_coordinate, current_track.facing
+      end
+
+      def turn_left
+        return false unless is_on_table?
+
+        self.current_track = Track.new current_track.coordinate, Direction.left(current_track.facing)
+      end
+
+      def turn_right
+        return false unless is_on_table?
+
+        self.current_track = Track.new current_track.coordinate, Direction.right(current_track.facing)
+      end
+
+    private
+      def current_track=(current_track)
+        @current_track = current_track
+      end
+
+      def is_valid_coordinate?(coordinate)
+        table.is_valid_coordinate? coordinate
+      end
+
+      def is_on_table?
+        self.current_track != nil
+      end
+    end
+  end
+end

data/lib/robot/simulator/table.rb

@@ -0,0 +1,18 @@
+module Robot
+  module Simulator
+    # Table with dimension, in which a robot can be placed and roam around.
+    class Table
+      attr_reader :dimensionX, :dimensionY
+
+      def initialize(dimensionX, dimensionY)
+        @dimensionX, @dimensionY = dimensionX, dimensionY
+      end
+
+      def is_valid_coordinate?(coordinate)
+        coordinate and
+        coordinate.x >= 0 and coordinate.x < dimensionX and
+        coordinate.y >= 0 and coordinate.y < dimensionY
+      end
+    end
+  end
+end

data/lib/robot/simulator/track.rb

@@ -0,0 +1,12 @@
+module Robot
+  module Simulator
+    # Track of a robot, contains coordinate and facing direction.
+    class Track
+      attr_reader :coordinate, :facing
+
+      def initialize(coordinate, facing)
+        @coordinate, @facing = coordinate, facing
+      end
+    end
+  end
+end

data/lib/robot/simulator/ui/cli.rb

@@ -0,0 +1,86 @@
+require "thor"
+require 'robot/simulator'
+
+module Robot
+  module Simulator
+    module UI
+      class CLI < Thor
+
+        desc "start_game", "Start the robot simulator game"
+        method_option :file, :aliases => "-f", :desc => "path to a text file containing robot commands"
+        def start_game
+          @controller = Controller.new
+
+          if options[:file]
+            commands = read_commands_from_file options[:file]
+          else
+            commands = read_commands_from_console
+          end
+
+          commands.each {|command| dispatch_command command }
+        end
+
+        default_task :start_game
+
+      private
+        def read_commands_from_console
+          say "Please input robot commands, end with a blank line ...", :green
+          commands = []
+          loop do
+            command = ask('>').strip
+            break if command.empty?
+            commands << command
+          end
+          commands
+        end
+
+        def read_commands_from_file(file_name)
+          say "Reading robot commands from file #{file_name} ...", :green
+          commands = []
+          File.foreach(file_name) do |line|
+            line = line.strip
+            commands << line unless line.empty?
+          end
+          commands
+        end
+
+        def dispatch_command(command)
+          action, param = command.split(/\s+/)
+          say "Will execute command: #{command}", :cyan
+          begin
+            case action.upcase
+            when 'PLACE'
+              execute_place_command action, param
+            when 'MOVE'
+              @controller.move
+            when 'LEFT'
+              @controller.left
+            when 'RIGHT'
+              @controller.right
+            when 'REPORT'
+              report = @controller.report
+              say report ? report.join(',') : 'Not on table'
+            else
+              error "Unknow command is ignored: #{command}"
+            end
+          rescue StandardError => err
+            error err.message
+          end
+        end
+
+        def execute_place_command(action, param)
+          if param
+            x, y, facing = param.split(/\s*\,\s*/)
+            if x and y and facing
+              @controller.place x.to_i, y.to_i, facing
+            else
+              error "Command PLACE needs 3 parameters in format of x,y,facing, got #{param}"
+            end
+          else
+            error "Command PLACE is ignored because of lack parameters"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/robot/simulator/version.rb

@@ -0,0 +1,5 @@
+module Robot
+  module Simulator
+    VERSION = "0.0.1"
+  end
+end

data/robot-simulator.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'robot/simulator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "robot-simulator"
+  spec.version       = Robot::Simulator::VERSION
+  spec.authors       = ["Andrew Feng"]
+  spec.email         = ["mingliangfeng@gmail.com"]
+  spec.description   = %q{Robot Simulator Code Exercise}
+  spec.summary       = %q{A robot simulator that can receive commands and move around on a table surface. It will prevent falling from the table, and can report its position.}
+  spec.homepage      = "https://github.com/mingliangfeng"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "thor", '~> 0.19'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", '~> 10.3'
+  spec.add_development_dependency 'rspec', '3.1'
+end

data/robot-simulator.txt

@@ -0,0 +1,72 @@
+Robot Simulator
+
+## Description:
+
+The application is a simulation of a toy robot moving on a square tabletop, of dimensions 5 units x 5 units.
+
+There are no other obstructions on the table surface.
+
+The robot is free to roam around the surface of the table, but must be prevented from falling to destruction. Any movement that would result in the robot falling from the table must be prevented, however further valid movement commands must still be allowed.
+
+Create an application that can read in commands of the following form:
+
+```
+PLACE X,Y,F
+MOVE
+LEFT
+RIGHT
+REPORT
+```
+
+- `PLACE` will put the toy robot on the table in position X,Y and facing NORTH, SOUTH, EAST or WEST. 
+
+- The origin (0,0) can be considered to be the SOUTH WEST most corner.
+
+- The first valid command to the robot is a `PLACE` command, after that, any sequence of commands may be issued, in any order, including another `PLACE` command. The application should discard all commands in the sequence until a valid `PLACE` command has been executed.
+
+- `MOVE` will move the toy robot one unit forward 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. This can be in any form, but standard output is sufficient.
+
+- A robot that is not on the table can choose the ignore the MOVE, LEFT, RIGHT and REPORT commands.
+
+- Input can be from a file, or from standard input, as the developer chooses.
+
+- Provide test data to exercise the application.
+
+## Constraints:
+
+The toy robot must not fall off the table during movement. This also includes the initial placement of the toy robot. Any move that would cause the robot to fall must be ignored.
+
+## Example Input and Output:
+
+```
+a)
+PLACE 0,0,NORTH
+MOVE
+REPORT
+Output: 0,1,NORTH
+
+b)
+PLACE 0,0,NORTH
+LEFT
+REPORT
+Output: 0,0,WEST
+
+c)
+PLACE 1,2,EAST
+MOVE
+MOVE
+LEFT
+MOVE
+REPORT
+Output: 3,3,NORTH
+```
+
+## Deliverables:
+
+The source files, the test data and any test code.
+
+It is not required to provide any graphical output showing the movement of the toy robot.

data/spec/robot/simulator/controller_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+module Robot
+  module Simulator
+    describe Controller do
+      context 'Robot simulator controller' do
+        let!(:controller) { Controller.new }
+
+        it 'controller should init the game with a robot and a 5 x 5 dimension table' do
+          expect( controller.robot ).not_to be nil
+          expect( controller.robot.table ).not_to be nil
+          expect( controller.robot.table.dimensionX ).to eq(5)
+          expect( controller.robot.table.dimensionY ).to eq(5)
+        end
+
+        context 'test place' do
+          it 'controller should receive PLACE command and set robot at correct coordinate' do
+            controller.place 0, 1, 'EAST'
+            expect( controller.robot.current_track ).not_to be nil
+            expect( controller.robot.current_track.coordinate.x ).to eq(0)
+            expect( controller.robot.current_track.coordinate.y ).to eq(1)
+          end
+
+          it 'controller should raise error for invalid PLACE command' do
+            expect{ controller.place 6, 6, 'EAST' }.to raise_error
+          end
+        end
+
+        context 'test move' do
+          it 'controller should receive MOVE command and move robot to correct coordinate' do
+            controller.place 0, 1, 'EAST'
+            controller.move
+            expect( controller.robot.current_track.coordinate.x ).to eq(1)
+            expect( controller.robot.current_track.coordinate.y ).to eq(1)
+          end
+
+          it 'controller should raise error for MOVE command before valid PLACE command' do
+            expect{ controller.move }.to raise_error
+          end
+
+          it 'controller should ingore MOVE command if doing so will cause robot to fall' do
+            controller.place 4, 4, 'EAST'
+            expect{ controller.move }.to raise_error
+            expect( controller.robot.current_track.coordinate.x ).to eq(4)
+            expect( controller.robot.current_track.coordinate.y ).to eq(4)
+          end
+        end
+
+        context 'test left' do
+          it 'controller should receive LEFT command and change robot facing direction' do
+            controller.place 0, 1, 'EAST'
+            controller.left
+            expect( controller.robot.current_track.facing ).to eq(Direction::NORTH)
+            controller.left
+            expect( controller.robot.current_track.facing ).to eq(Direction::WEST)
+            controller.left
+            expect( controller.robot.current_track.facing ).to eq(Direction::SOUTH)
+            controller.left
+            expect( controller.robot.current_track.facing ).to eq(Direction::EAST)
+          end
+
+          it 'controller should raise error for LEFT command before valid PLACE command' do
+            expect{ controller.left }.to raise_error
+          end
+        end
+
+        context 'test right' do
+          it 'controller should receive RIGHT command and change robot facing direction' do
+            controller.place 0, 1, 'EAST'
+            controller.right
+            expect( controller.robot.current_track.facing ).to eq(Direction::SOUTH)
+            controller.right
+            expect( controller.robot.current_track.facing ).to eq(Direction::WEST)
+            controller.right
+            expect( controller.robot.current_track.facing ).to eq(Direction::NORTH)
+            controller.right
+            expect( controller.robot.current_track.facing ).to eq(Direction::EAST)
+          end
+
+          it 'controller should raise error for RIGHT command before valid PLACE command' do
+            expect{ controller.right }.to raise_error
+          end
+        end
+
+        it 'test commands sequence' do
+          controller.place 1, 2, 'EAST'
+          controller.move
+          controller.move
+          controller.left
+          controller.move
+          expect( controller.report ).to eq [3, 3, "NORTH"]
+        end
+
+      end
+    end
+  end
+end

data/spec/robot/simulator/coordinate_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Robot
+  module Simulator
+    describe Coordinate do
+
+      it 'constructor and getters' do
+        coordinate = Coordinate.new 0, 1
+        expect( coordinate.x ).to eq(0)
+        expect( coordinate.y ).to eq(1)
+      end
+
+    end
+  end
+end

data/spec/robot/simulator/direction_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Robot
+  module Simulator
+    describe Direction do
+
+      context 'test left' do
+
+        it 'expect ArgumentError if not called by passing Direction constants value' do
+          expect { Direction.left(-1) }.to raise_error(ArgumentError)
+          expect { Direction.left(5) }.to raise_error(ArgumentError)
+        end
+
+        it 'left should return correct value' do
+          expect( Direction.left(Direction::EAST) ).to eq(Direction::NORTH)
+          expect( Direction.left(Direction::NORTH) ).to eq(Direction::WEST)
+          expect( Direction.left(Direction::WEST) ).to eq(Direction::SOUTH)
+          expect( Direction.left(Direction::SOUTH) ).to eq(Direction::EAST)
+        end
+
+      end
+
+      context 'test right' do
+
+        it 'expect ArgumentError if not called by passing Direction constants value' do
+          expect { Direction.right(-1) }.to raise_error(ArgumentError)
+          expect { Direction.right(5) }.to raise_error(ArgumentError)
+        end
+
+        it 'right should return correct value' do
+          expect( Direction.right(Direction::EAST) ).to eq(Direction::SOUTH)
+          expect( Direction.right(Direction::SOUTH) ).to eq(Direction::WEST)
+          expect( Direction.right(Direction::WEST) ).to eq(Direction::NORTH)
+          expect( Direction.right(Direction::NORTH) ).to eq(Direction::EAST)
+        end
+
+      end
+
+      context 'test to_str' do
+
+        it 'expect ArgumentError if not called by passing Direction constants value' do
+          expect { Direction.to_str(-1) }.to raise_error(ArgumentError)
+          expect { Direction.to_str(5) }.to raise_error(ArgumentError)
+        end
+
+        it 'to_str should return correct string value' do
+          expect( Direction.to_str(Direction::EAST) ).to eq('EAST')
+          expect( Direction.to_str(Direction::SOUTH) ).to eq('SOUTH')
+          expect( Direction.to_str(Direction::WEST) ).to eq('WEST')
+          expect( Direction.to_str(Direction::NORTH) ).to eq('NORTH')
+        end
+
+      end
+
+      context 'test from_str' do
+
+        it 'expect ArgumentError if not called by passing right string' do
+          expect { Direction.from_str('east-weast') }.to raise_error(ArgumentError)
+        end
+
+        it 'from_str should return correct Direction constant' do
+          expect( Direction.from_str('EAST') ).to eq(Direction::EAST)
+          expect( Direction.from_str('south') ).to eq(Direction::SOUTH)
+          expect( Direction.from_str('West') ).to eq(Direction::WEST)
+          expect( Direction.from_str('NorTH') ).to eq(Direction::NORTH)
+        end
+        
+      end
+
+    end
+  end
+end

data/spec/robot/simulator/robot_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+module Robot
+  module Simulator
+    describe Robot do
+
+      let(:robot) { Robot.new Table.new(5, 5) }
+
+      context 'test place method' do
+        it 'expect robot current track to be nil before valid PLACE command' do
+          expect( robot.current_track ).to be_nil
+        end
+
+        it 'expect robot current track NOT to be nil after valid PLACE command' do
+          expect( robot.place(Coordinate.new(0, 0), Direction::EAST) ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.coordinate.x ).to eq(0)
+          expect( robot.current_track.coordinate.y ).to eq(0)
+          expect( robot.current_track.facing ).to eq(Direction::EAST)
+        end
+
+        it 'expect robot current track to be nil after invalid PLACE command' do
+          expect( robot.place(Coordinate.new(6, 6), Direction::EAST) ).to be_falsey
+          expect( robot.current_track ).to be_nil
+        end
+
+        it 'expect robot to stay on track and refuse subsequent invalid PLACE commands' do
+          robot.send :current_track=, Track.new(Coordinate.new(0, 0), Direction::EAST)
+
+          expect( robot.place(Coordinate.new(6, 6), Direction::EAST) ).to be_falsey
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.coordinate.x ).to eq(0)
+          expect( robot.current_track.coordinate.y ).to eq(0)
+          expect( robot.current_track.facing ).to eq(Direction::EAST)
+        end
+      end
+
+      context 'test move method' do
+        it 'expect robot move to be failed before valid PLACE command' do
+          expect( robot.move() ).to be_falsey
+          expect( robot.current_track ).to be_nil
+        end
+
+        it 'expect robot move to next track after valid PLACE command' do
+          robot.send :current_track=, Track.new(Coordinate.new(0, 0), Direction::EAST)
+          expect( robot.move() ).to be_truthy
+          expect( robot.current_track.coordinate.x ).to eq(1)
+          expect( robot.current_track.coordinate.y ).to eq(0)
+        end
+
+        it 'expect robot to refuse to move to prevent falling from table' do
+          robot.send :current_track=, Track.new(Coordinate.new(4, 4), Direction::EAST)
+          expect( robot.move() ).to be_falsey
+          expect( robot.current_track.coordinate.x ).to eq(4)
+          expect( robot.current_track.coordinate.y ).to eq(4)
+        end
+      end
+
+      context 'test turn_left' do
+        it 'expect robot to ingore LEFT command before valid PLACE command' do
+          expect( robot.turn_left() ).to be_falsey
+          expect( robot.current_track ).to be_nil
+        end
+
+        it 'expect robot to change facing direction when receive LEFT command' do
+          robot.send :current_track=, Track.new(Coordinate.new(0, 0), Direction::EAST)
+
+          expect( robot.turn_left() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::NORTH)
+
+          expect( robot.turn_left() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::WEST)
+
+          expect( robot.turn_left() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::SOUTH)
+
+          expect( robot.turn_left() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::EAST)
+        end
+      end
+
+      context 'test turn_right' do
+        it 'expect robot to ingore RIGHT command before valid PLACE command' do
+          expect( robot.turn_right() ).to be_falsey
+          expect( robot.current_track ).to be_nil
+        end
+
+        it 'expect robot to change facing direction when receive RIGHT command' do
+          robot.send :current_track=, Track.new(Coordinate.new(0, 0), Direction::EAST)
+
+          expect( robot.turn_right() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::SOUTH)
+
+          expect( robot.turn_right() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::WEST)
+
+          expect( robot.turn_right() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::NORTH)
+
+          expect( robot.turn_right() ).to be_truthy
+          expect( robot.current_track ).not_to be_nil
+          expect( robot.current_track.facing ).to eq(Direction::EAST)
+        end
+      end
+
+    end
+  end
+end

data/spec/robot/simulator/table_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Robot
+  module Simulator
+    describe Table do
+
+      let(:table) { Table.new 5, 5 }
+
+      it 'constructor and getters' do
+        expect( table.dimensionX ).to eq(5)
+        expect( table.dimensionY ).to eq(5)
+      end
+
+      it 'test is_valid_coordinate?' do
+    		expect( table.is_valid_coordinate?(Coordinate.new(0, 0)) ).to be true
+    		expect( table.is_valid_coordinate?(Coordinate.new(4, 0)) ).to be true
+    		expect( table.is_valid_coordinate?(Coordinate.new(4, 4)) ).to be true
+    		expect( table.is_valid_coordinate?(Coordinate.new(0, 4)) ).to be true
+
+    		expect( table.is_valid_coordinate?(Coordinate.new(0, -1)) ).to be false
+    		expect( table.is_valid_coordinate?(Coordinate.new(-1, 0)) ).to be false
+    		expect( table.is_valid_coordinate?(Coordinate.new(4, -1)) ).to be false
+    		expect( table.is_valid_coordinate?(Coordinate.new(5, 0)) ).to be false
+    		expect( table.is_valid_coordinate?(Coordinate.new(4, 5)) ).to be false
+    		expect( table.is_valid_coordinate?(Coordinate.new(5, 4)) ).to be false
+    		expect( table.is_valid_coordinate?(Coordinate.new(0, 5)) ).to be false
+    		expect( table.is_valid_coordinate?(Coordinate.new(-1, 4)) ).to be false
+      end
+
+    end
+  end
+end

data/spec/robot/simulator/track_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Robot
+  module Simulator
+    describe Track do
+
+      it 'constructor and getters' do
+        track = Track.new Coordinate.new(0, 1), Direction::EAST
+        expect( track.coordinate.x ).to eq(0)
+        expect( track.coordinate.y ).to eq(1)
+        expect( track.facing ).to eq(Direction::EAST)
+      end
+
+    end
+  end
+end

data/spec/robot/simulator/ui/cli_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Robot
+  module Simulator
+    module UI
+      describe CLI do
+        let(:cli) { CLI.new }
+
+        it 'test commands from file' do
+          expect( cli ).to receive(:say).with(/Reading robot commands from file/, anything)
+          expect( cli ).to receive(:say).exactly 6
+          expect( cli ).to receive(:say).with "3,3,NORTH"
+
+          cli.options = { :file => File.expand_path('../commands.txt', __FILE__) }
+          cli.start_game
+        end
+
+        context 'test commands from console' do
+          let(:console_prompt) { "Please input robot commands, end with a blank line ..." }
+
+          it "should process the commands and output the results" do
+            expect( cli ).to receive(:say).with console_prompt, anything
+            expect( cli ).to receive(:ask).with('>').and_return 'PLACE 1,2,East'
+            expect( cli ).to receive(:ask).with('>').and_return 'MOVE'
+            expect( cli ).to receive(:ask).with('>').and_return 'MOVE'
+            expect( cli ).to receive(:ask).with('>').and_return 'LEFT'
+            expect( cli ).to receive(:ask).with('>').and_return 'MOVE'
+            expect( cli ).to receive(:ask).with('>').and_return 'REPORT'
+            expect( cli ).to receive(:ask).with('>').and_return ''
+
+            expect( cli ).to receive(:say).exactly 6
+            expect( cli ).to receive(:say).with "3,3,NORTH"
+
+            cli.start_game
+          end
+
+          context 'should report error for invalid commands' do
+            it 'report unknow command error' do
+              expect( cli ).to receive(:say).with console_prompt, anything
+              expect( cli ).to receive(:ask).with('>').and_return 'PLACE2'
+              expect( cli ).to receive(:ask).with('>').and_return ''
+
+              expect( cli ).to receive(:say).once
+              expect( cli ).to receive(:error).with "Unknow command is ignored: PLACE2"
+
+              cli.start_game
+            end
+
+            it 'report error when there is exception' do
+              expect( cli ).to receive(:say).with console_prompt, anything
+              expect( cli ).to receive(:ask).with('>').and_return 'PLACE 1,2,EastWest'
+              expect( cli ).to receive(:ask).with('>').and_return ''
+
+              expect( cli ).to receive(:say).once
+              expect( cli ).to receive(:error).with(/Direction string/)
+
+              cli.start_game
+            end
+
+            it 'report error when robot would fall' do
+              expect( cli ).to receive(:say).with console_prompt, anything
+              expect( cli ).to receive(:ask).with('>').and_return 'PLACE 4,4,East'
+              expect( cli ).to receive(:ask).with('>').and_return 'MOVE'
+              expect( cli ).to receive(:ask).with('>').and_return ''
+
+              expect( cli ).to receive(:say).twice
+              expect( cli ).to receive(:error).with(/Invalid MOVE command/)
+
+              cli.start_game
+            end
+
+            it 'report error if robot is not on the table' do
+              expect( cli ).to receive(:say).with console_prompt, anything
+              expect( cli ).to receive(:ask).with('>').and_return 'MOVE'
+              expect( cli ).to receive(:ask).with('>').and_return 'LEFT'
+              expect( cli ).to receive(:ask).with('>').and_return 'RIGHT'
+              expect( cli ).to receive(:ask).with('>').and_return ''
+
+              expect( cli ).to receive(:say).once
+              expect( cli ).to receive(:error).with(/Invalid MOVE command/)
+
+              expect( cli ).to receive(:say).once
+              expect( cli ).to receive(:error).with(/Invalid LEFT command/)
+
+              expect( cli ).to receive(:say).once
+              expect( cli ).to receive(:error).with(/Invalid RIGHT command/)
+
+              cli.start_game
+            end
+
+            context "should report invalid PLACE commands" do
+              it 'report if PLACE on invalid position' do
+                expect( cli ).to receive(:say).with console_prompt, anything
+                expect( cli ).to receive(:ask).with('>').and_return 'PLACE'
+                expect( cli ).to receive(:ask).with('>').and_return ''
+
+                expect( cli ).to receive(:say).once
+                expect( cli ).to receive(:error).with "Command PLACE is ignored because of lack parameters"
+
+                cli.start_game
+              end
+
+              it 'report no arguments error' do
+                expect( cli ).to receive(:say).with console_prompt, anything
+                expect( cli ).to receive(:ask).with('>').and_return 'PLACE 5,5,EAST'
+                expect( cli ).to receive(:ask).with('>').and_return ''
+
+                expect( cli ).to receive(:say).once
+                expect( cli ).to receive(:error).with(/Invalid PLACE command/)
+
+                cli.start_game
+              end
+
+              it 'report no enough arguments error' do
+                expect( cli ).to receive(:say).with console_prompt, anything
+                expect( cli ).to receive(:ask).with('>').and_return 'PLACE 1,2'
+                expect( cli ).to receive(:ask).with('>').and_return ''
+
+                expect( cli ).to receive(:say).once
+                expect( cli ).to receive(:error).with "Command PLACE needs 3 parameters in format of x,y,facing, got 1,2"
+
+                cli.start_game
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/robot/simulator/ui/commands.txt

@@ -0,0 +1,8 @@
+PLACE    1,2,EAST
+MOVE
+MOVE
+
+LEFT
+
+MOVE
+REPORT

data/spec/robot/simulator_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module Robot
+  describe Simulator do
+
+    it 'version is 0.0.1' do
+      expect(Simulator::VERSION).to eq('0.0.1')
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'robot/simulator'
+require 'robot/simulator/ui/cli'

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: robot-simulator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Feng
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Robot Simulator Code Exercise
+email:
+- mingliangfeng@gmail.com
+executables:
+- robot-simulator
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/robot-simulator
+- lib/robot/simulator.rb
+- lib/robot/simulator/controller.rb
+- lib/robot/simulator/coordinate.rb
+- lib/robot/simulator/direction.rb
+- lib/robot/simulator/robot.rb
+- lib/robot/simulator/table.rb
+- lib/robot/simulator/track.rb
+- lib/robot/simulator/ui/cli.rb
+- lib/robot/simulator/version.rb
+- robot-simulator.gemspec
+- robot-simulator.txt
+- spec/robot/simulator/controller_spec.rb
+- spec/robot/simulator/coordinate_spec.rb
+- spec/robot/simulator/direction_spec.rb
+- spec/robot/simulator/robot_spec.rb
+- spec/robot/simulator/table_spec.rb
+- spec/robot/simulator/track_spec.rb
+- spec/robot/simulator/ui/cli_spec.rb
+- spec/robot/simulator/ui/commands.txt
+- spec/robot/simulator_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mingliangfeng
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: A robot simulator that can receive commands and move around on a table surface.
+  It will prevent falling from the table, and can report its position.
+test_files:
+- spec/robot/simulator/controller_spec.rb
+- spec/robot/simulator/coordinate_spec.rb
+- spec/robot/simulator/direction_spec.rb
+- spec/robot/simulator/robot_spec.rb
+- spec/robot/simulator/table_spec.rb
+- spec/robot/simulator/track_spec.rb
+- spec/robot/simulator/ui/cli_spec.rb
+- spec/robot/simulator/ui/commands.txt
+- spec/robot/simulator_spec.rb
+- spec/spec_helper.rb
+has_rdoc: