toyrobot 0.0.1

data/lib/toy_robot/robot.rb

@@ -0,0 +1,41 @@
+require 'forwardable'
+
+module ToyRobot
+  class Robot
+    extend Forwardable
+
+    def initialize(args)
+      @placement = args[:placement]
+    end
+
+    def place(*args)
+      placement.update(*args)
+    end
+
+    def move
+      with_placement { placement.advance }
+    end
+
+    def right
+      with_placement { placement.rotate(90) }
+    end
+
+    def left
+      with_placement { placement.rotate(-90) }
+    end
+
+    def report
+      with_placement { placement.report }
+    end
+
+    private
+
+    attr_accessor :placement
+
+    def with_placement
+      if placement.on_board?
+        yield
+      end
+    end
+  end
+end

data/lib/toy_robot/robot_controller.rb

@@ -0,0 +1,35 @@
+require_relative 'command/token'
+require 'forwardable'
+
+module ToyRobot
+  class RobotController
+    extend Forwardable
+
+    def_delegators :robot, :place, :move, :left, :right
+    def_delegator :view, :report
+
+    def initialize(args)
+      @robot = args[:robot]
+      @view = args[:view]
+    end
+
+    def input(command)
+      case command.token
+      when Command::Token::PLACE
+        place(command.args)
+      when Command::Token::MOVE
+        move
+      when Command::Token::RIGHT
+        right
+      when Command::Token::LEFT
+        left
+      when Command::Token::REPORT
+        report
+      end
+    end
+
+    private
+
+    attr_reader :robot, :view
+  end
+end

data/lib/toy_robot/view.rb

@@ -0,0 +1,22 @@
+module ToyRobot
+  View = Struct.new(:args) do
+    def report
+      report = robot.report
+      output.puts report_string(report) if report
+    end
+
+    private
+
+    def report_string(report)
+      "#{report[:x]},#{report[:y]},#{report[:orientation].upcase}"
+    end
+
+    def robot
+      args[:robot]
+    end
+
+    def output
+      args[:output] || $stdout
+    end
+  end
+end

data/lib/toy_robot.rb

@@ -0,0 +1 @@
+require_relative 'toy_robot/application'

data/test/integration/test_application.rb

@@ -0,0 +1,24 @@
+require_relative '../../lib/toy_robot'
+require 'minitest/autorun'
+
+module ToyRobot
+  class ToyRobotTest < MiniTest::Unit::TestCase
+    def setup
+      @app = lambda { |f| ToyRobot::Application.new(nil, input: f).run }
+    end
+    def test_example_input_a
+      file = File.open('data/example_input_a.txt', 'r')
+      assert_output(/\A0,1,NORTH\n\z/) { @app.call(file) }
+    end
+
+    def test_example_input_b
+      file = File.open('data/example_input_b.txt', 'r')
+      assert_output(/\A0,0,WEST\n\z/) { @app.call(file) }
+    end
+
+    def test_example_input_c
+      file = File.open('data/example_input_c.txt', 'r')
+      assert_output(/\A3,3,NORTH\n\z/) { @app.call(file) }
+    end
+  end
+end

data/test/integration/test_factory.rb

@@ -0,0 +1,18 @@
+require_relative '../../lib/toy_robot/factory'
+require 'minitest/autorun'
+
+module ToyRobot
+  class FactoryTest < MiniTest::Unit::TestCase
+    def setup
+      @object = Factory
+    end
+
+    def test_public_interface
+      assert_respond_to @object, :create
+    end
+
+    def test_that_create_returns_a_robot_controller
+      assert_instance_of RobotController, @object.create(:controller)
+    end
+  end
+end

data/test/integration/test_toy_robot.rb

@@ -0,0 +1,9 @@
+require 'minitest/autorun'
+
+module ToyRobot
+  class ToyRobotTest < MiniTest::Unit::TestCase
+    def test_that_it_is_executable
+      assert system('[ -x bin/toyrobots ]')
+    end
+  end
+end

data/test/test_board.rb

@@ -0,0 +1,31 @@
+require_relative '../lib/toy_robot/board'
+require 'minitest/autorun'
+
+module ToyRobot
+  class BoardTest < MiniTest::Unit::TestCase
+
+    PoseDouble = Struct.new(:x, :y)
+
+    def setup
+      @board = Board.new(5,5)
+    end
+
+    def test_that_knows_a_valid_pose
+      pose_double = PoseDouble.new(0,0)
+
+      assert @board.valid_pose?(pose_double)
+    end
+
+    def test_that_knows_an_invalid_pose
+      [[-1,0], [0,-1], [6,0], [0,6]].each do |out_of_range|
+        pose_double = PoseDouble.new(*out_of_range)
+
+        refute @board.valid_pose?(pose_double), "Pose #{pose_double} should be invalid"
+      end
+    end
+
+    def test_that_a_nil_pose_is_invalid
+      refute @board.valid_pose?(nil)
+    end
+  end
+end

data/test/test_command.rb

@@ -0,0 +1,22 @@
+require_relative '../lib/toy_robot/command/token'
+require 'minitest/autorun'
+
+module ToyRobot
+  class CommandTest < MiniTest::Unit::TestCase
+    def test_tokens_are_defined
+      assert defined?(Command::Token::PLACE)
+
+      assert defined?(Command::Token::MOVE)
+
+      assert defined?(Command::Token::RIGHT)
+
+      assert defined?(Command::Token::LEFT)
+
+      assert defined?(Command::Token::REPORT)
+    end
+
+    def test_base_is_defined
+      assert defined?(Command::Base)
+    end
+  end
+end

data/test/test_command_matcher.rb

@@ -0,0 +1,32 @@
+require_relative '../lib/toy_robot/command/parser'
+require 'minitest/autorun'
+
+module ToyRobot
+  class CommandMatcherTest < MiniTest::Unit::TestCase
+    def setup
+      @matcher = Command::Parser
+    end
+
+    def test_that_it_can_parse
+      refute_equal nil, @matcher.parse('PLACE 0,0,NORTH')
+    end
+
+    def test_that_parsing_can_fail
+      assert_equal nil, @matcher.parse('PLACE 0,0,NORTHISH')
+    end
+
+    def test_that_it_knows_all_matchers
+      all = @matcher.all
+
+      assert_includes all, Command::Parser::Place
+
+      assert_includes all, Command::Parser::Move
+
+      assert_includes all, Command::Parser::Left
+
+      assert_includes all, Command::Parser::Right
+
+      assert_includes all, Command::Parser::Report
+    end
+  end
+end

data/test/test_command_matcher_interface.rb

@@ -0,0 +1,31 @@
+module ToyRobot
+  module CommandMatcherInterfaceTest
+    def test_it_implement_the_command_matcher_interface
+      assert_respond_to @object, :build_with_match
+    end
+
+    def test_that_it_matches_a_valid_string
+      assert @object.build_with_match(@object_valid_str)
+    end
+
+    def test_that_it_ignores_invalid_strings
+      @object_invalid_strs.each do |invalid|
+        refute @object.build_with_match(invalid), "It should ignore '#{invalid}'"
+      end
+    end
+
+    def test_that_response_knows_token
+      assert_equal @object_token,
+                   @object.build_with_match(@object_valid_str).token
+    end
+
+    def test_that_response_knows_args
+      assert_respond_to @object.build_with_match(@object_valid_str),
+                        :args
+    end
+
+    def test_that_response_is_nil
+      assert_equal nil, @object.build_with_match(@object_invalid_strs.sample)
+    end
+  end
+end

data/test/test_command_matcher_left.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/toy_robot/command/parser/base'
+require_relative 'test_command_matcher_interface'
+require 'minitest/autorun'
+
+module ToyRobot
+  class CommandMatcherLeftTest < MiniTest::Unit::TestCase
+    include CommandMatcherInterfaceTest
+
+    def setup
+      @object = Command::Parser::Left
+      @object_token = Command::Token::LEFT
+      @object_valid_str = 'LEFT'
+      @object_invalid_strs = [
+        'LEFT ',
+        'LEFTY',
+        'LEFT 180'
+      ]
+    end
+  end
+end

data/test/test_command_matcher_move.rb

@@ -0,0 +1,21 @@
+require_relative '../lib/toy_robot/command/parser/base'
+require_relative 'test_command_matcher_interface'
+require 'minitest/autorun'
+
+module ToyRobot
+  class CommandMatcherMoveTest < MiniTest::Unit::TestCase
+    include CommandMatcherInterfaceTest
+
+    def setup
+      @object = Command::Parser::Move
+      @object_token = Command::Token::MOVE
+      @object_valid_str = 'MOVE'
+      @object_invalid_strs = [
+        'MOVE ',
+        'MOVER',
+        'MOVE 180',
+        'move'
+      ]
+    end
+  end
+end

data/test/test_command_matcher_place.rb

@@ -0,0 +1,56 @@
+require_relative '../lib/toy_robot/command/parser/place'
+require_relative 'test_command_matcher_interface'
+require 'minitest/autorun'
+
+module ToyRobot
+  class CommandMatcherPlaceTest < MiniTest::Unit::TestCase
+    include CommandMatcherInterfaceTest
+
+    def setup
+      @object = Command::Parser::Place
+      @object_token = Command::Token::PLACE
+      @object_valid_str = 'PLACE 0,0,NORTH'
+      @object_invalid_strs = [
+        'PLACE',
+        'PLACE ',
+        'PLACE X,Y,Z,F',
+        'PLACE 0,0,OTHER',
+        'PLACE 0,0',
+        'PLACE 0,a,NORTH',
+        'PLACE a,99,NORTH',
+        'PLACE a,NORHT',
+        'PLACE 0,NORTH'
+      ]
+    end
+
+    def test_that_response_args_know_x
+      assert_equal 123,
+                   @object.build_with_match('PLACE 123,0,NORTH').args.x
+    end
+
+    def test_that_response_args_know_y
+      assert_equal 123,
+                   @object.build_with_match('PLACE 0,123,NORTH').args.y
+    end
+
+    def test_that_response_args_knows_north_orientation
+      assert_equal Pose::Orientation::NORTH,
+                   @object.build_with_match('PLACE 0,123,NORTH').args.orientation
+    end
+
+    def test_that_response_args_knows_south_orientation
+      assert_equal Pose::Orientation::SOUTH,
+                   @object.build_with_match('PLACE 0,123,SOUTH').args.orientation
+    end
+
+    def test_that_response_args_knows_east_orientation
+      assert_equal Pose::Orientation::EAST,
+                   @object.build_with_match('PLACE 0,123,EAST').args.orientation
+    end
+
+    def test_that_response_args_knows_west_orientation
+      assert_equal Pose::Orientation::WEST,
+                   @object.build_with_match('PLACE 0,123,WEST').args.orientation
+    end
+  end
+end

data/test/test_command_matcher_report.rb

@@ -0,0 +1,21 @@
+require_relative '../lib/toy_robot/command/parser/base'
+require_relative 'test_command_matcher_interface'
+require 'minitest/autorun'
+
+module ToyRobot
+  class CommandMatcherReportTest < MiniTest::Unit::TestCase
+    include CommandMatcherInterfaceTest
+
+    def setup
+      @object = Command::Parser::Report
+      @object_token = Command::Token::REPORT
+      @object_valid_str = 'REPORT'
+      @object_invalid_strs = [
+        'REPORT ',
+        'REPORTNOW',
+        'REP',
+        'R'
+      ]
+    end
+  end
+end

data/test/test_command_matcher_right.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/toy_robot/command/parser/base'
+require_relative 'test_command_matcher_interface'
+require 'minitest/autorun'
+
+module ToyRobot
+  class CommandMatcherRightTest < MiniTest::Unit::TestCase
+    include CommandMatcherInterfaceTest
+
+    def setup
+      @object = Command::Parser::Right
+      @object_token = Command::Token::RIGHT
+      @object_valid_str = 'RIGHT'
+      @object_invalid_strs = [
+        'RIGHT ',
+        'RIGHTY',
+        'RIGHT 180'
+      ]
+    end
+  end
+end

data/test/test_placement.rb

@@ -0,0 +1,94 @@
+require_relative '../lib/toy_robot/placement'
+require_relative 'test_reporter_interface'
+require 'minitest/autorun'
+
+module ToyRobot
+  class PlacementTest < MiniTest::Unit::TestCase
+    include ReporterInterfaceTest
+
+    SimpleDouble = Struct.new(:stub) do
+      def valid_pose?(_)
+        stub.fetch(:valid_pose?)
+      end
+
+      def adjacent
+        stub.fetch(:adjacent)
+      end
+    end
+
+    def setup
+      @board = SimpleDouble.new(valid_pose?: true)
+      @pose = SimpleDouble.new
+      @placement = @object = Placement.new(board: @board, pose: @pose)
+    end
+
+    def test_respond_to_public_interface
+      assert_respond_to @placement, :update
+      assert_respond_to @placement, :advance
+      assert_respond_to @placement, :rotate
+      assert_respond_to @placement, :on_board?
+    end
+
+    def test_that_it_might_be_on_board
+      assert @placement.on_board?
+    end
+
+    def test_that_it_might_not_be_on_board
+      @board[:stub] = { valid_pose?: false }
+
+      refute @placement.on_board?
+    end
+
+    def test_that_it_might_update
+      new_pose = Object.new
+
+      @placement.update(new_pose)
+
+      assert_equal new_pose, @placement.instance_variable_get(:@pose)
+    end
+
+    def test_that_update_might_fail
+      @board[:stub] = { valid_pose?: false }
+
+      @placement.update('invalid_pose')
+
+      assert_equal @pose, @placement.instance_variable_get(:@pose)
+    end
+
+    def test_that_it_might_advance
+      adjacent_pose = Object.new
+      @pose[:stub] = { adjacent: adjacent_pose }
+
+      @placement.advance
+
+      assert_equal adjacent_pose, @placement.instance_variable_get(:@pose)
+    end
+
+    def test_that_it_might_not_advance
+      @board[:stub] = { valid_pose?: false }
+      @pose[:stub] = { adjacent: 'anything' }
+
+      @placement.advance
+
+      assert_equal @pose, @placement.instance_variable_get(:@pose)
+    end
+
+    def test_that_it_rotates
+      pose = MiniTest::Mock.new
+      placement = Placement.new(pose: pose)
+
+      pose.expect(:rotate!, nil, [123])
+      placement.rotate(123)
+      pose.verify
+    end
+
+    def test_that_it_reports
+      pose = MiniTest::Mock.new
+      placement = Placement.new(pose: pose)
+
+      pose.expect(:report, nil)
+      placement.report
+      pose.verify
+    end
+  end
+end

data/test/test_pose.rb

@@ -0,0 +1,146 @@
+require_relative '../lib/toy_robot/pose'
+require_relative 'test_reporter_interface'
+require 'minitest/autorun'
+
+module ToyRobot
+  class PoseTest < MiniTest::Unit::TestCase
+    include ReporterInterfaceTest
+
+    def setup
+      @x, @y = 0, 1
+      @orientation = Pose::Orientation::EAST
+      @pose = @object = Pose.new(
+        x: @x,
+        y: @y,
+        orientation: @orientation
+      )
+    end
+
+    def test_public_interface
+      assert_respond_to @pose, :adjacent
+      assert_respond_to @pose, :rotate!
+      assert_respond_to @pose, :report
+      assert_respond_to @pose, :x
+      assert_respond_to @pose, :y
+      assert_respond_to @pose, :orientation
+    end
+
+    def test_it_can_be_initialized_without_arguments
+      assert Pose.new
+    end
+
+    def test_that_adjacent_returns_a_pose
+      assert_instance_of Pose, @pose.adjacent
+    end
+
+    def test_that_adjacent_pose_is_not_the_reciever
+      refute_equal @pose, @pose.adjacent
+    end
+
+    def test_that_knows_adjacent_when_facing_east
+      adjacent_pose_hash = {
+        x: @x + 1,
+        y: @y,
+        orientation: @orientation
+      }
+
+      assert_pose adjacent_pose_hash, @pose.adjacent
+    end
+
+    def test_that_knows_adjacent_when_facing_north
+      orientation = Pose::Orientation::NORTH
+      @pose.instance_variable_set(:@orientation, orientation)
+      adjacent_pose_hash = {
+        x: @x,
+        y: @y + 1,
+        orientation: orientation
+      }
+
+      assert_pose adjacent_pose_hash, @pose.adjacent
+    end
+
+    def test_that_knows_adjacent_when_facing_west
+      orientation = Pose::Orientation::WEST
+      @pose.instance_variable_set(:@orientation, orientation)
+      adjacent_pose_hash = {
+        x: @x - 1,
+        y: @y,
+        orientation: orientation
+      }
+
+      assert_pose adjacent_pose_hash, @pose.adjacent
+    end
+
+    def test_that_knows_adjacent_when_facing_south
+      orientation = Pose::Orientation::SOUTH
+      @pose.instance_variable_set(:@orientation, orientation)
+      adjacent_pose_hash = {
+        x: @x,
+        y: @y - 1,
+        orientation: orientation
+      }
+
+      assert_pose adjacent_pose_hash, @pose.adjacent
+    end
+
+    def test_that_can_rotate_90
+      clockwise_orientations = [
+        Pose::Orientation::NORTH,
+        Pose::Orientation::EAST,
+        Pose::Orientation::SOUTH,
+        Pose::Orientation::WEST,
+        Pose::Orientation::NORTH
+      ]
+
+      clockwise_orientations.each_cons(2) do |initial_orientation, rotated_orientation|
+        @pose.instance_variable_set(:@orientation, initial_orientation)
+        rotated_pose_hash = {x: @x, y: @y, orientation: rotated_orientation}
+
+        @pose.rotate!(90)
+
+        assert_pose rotated_pose_hash, @pose
+      end
+    end
+
+    def test_that_can_rotate_90_counterclockwise
+      counter_clockwise_orientations = [
+        Pose::Orientation::NORTH,
+        Pose::Orientation::WEST,
+        Pose::Orientation::SOUTH,
+        Pose::Orientation::EAST,
+        Pose::Orientation::NORTH
+      ]
+
+      counter_clockwise_orientations.each_cons(2) do |initial_orientation, rotated_orientation|
+        @pose.instance_variable_set(:@orientation, initial_orientation)
+        rotated_pose_hash = {
+          x: @x,
+          y: @y,
+          orientation: rotated_orientation
+        }
+
+        @pose.rotate!(-90)
+
+        assert_pose rotated_pose_hash, @pose
+      end
+    end
+
+    def test_that_it_reports_x
+      assert_includes @pose.report, :x
+    end
+
+    def test_that_it_reports_y
+      assert_includes @pose.report, :y
+    end
+
+    def test_that_it_reports_orientation
+      assert_includes @pose.report, :orientation
+    end
+
+    def assert_pose(expected_pose_hash, actual)
+      assert_equal expected_pose_hash[:x], actual.send(:x), ':x coordinate is different'
+      assert_equal expected_pose_hash[:y], actual.send(:y), ':y coordinate is different'
+      assert_equal expected_pose_hash[:orientation], actual.send(:orientation), ':orientation is different'
+    end
+  end
+end

data/test/test_reporter_interface.rb

@@ -0,0 +1,7 @@
+module ToyRobot
+  module ReporterInterfaceTest
+    def test_it_implement_the_reproter_interface
+      assert_respond_to @object, :report
+    end
+  end
+end