refactor: rename legal_moves to legal_target_positions

lib/board.rb

@@ -29,7 +29,7 @@ def place(piece, position)
   def legal_target_positions_for(position)
     piece = get(position).piece
     piece.move_types.map do |type|
-      type.new(self, position).legal_moves
+      type.new(self, position).legal_target_positions
     end.flatten
   end
 

lib/move/base.rb

@@ -13,7 +13,7 @@ def initialize(board, position)
 
     private
 
-    def legal_moves_in_line(positions)
+    def legal_target_positions_in_line(positions)
       legals = []
       positions.each do |target_position|
         break if occupied_by_friend?(target_position)
@@ -38,7 +38,7 @@ def occupied_by_enemy?(target_position)
       other_piece && other_piece.color != piece.color
     end
 
-    def without_illegal_moves(positions)
+    def without_illegal_target_positions(positions)
       positions -= target_positions_that_are_occupied_by_friend(positions)
       positions
     end

lib/move/diagonal.rb

@@ -3,14 +3,14 @@
 module Move
   # unlimited horizontal movement for a piece
   class Diagonal < Base
-    def legal_moves
+    def legal_target_positions
       [
         position.positions_up_left,
         position.positions_up_right,
         position.positions_down_left,
         position.positions_down_right
       ].map do |positions|
-        legal_moves_in_line(positions)
+        legal_target_positions_in_line(positions)
       end.flatten
     end
   end

lib/move/horizontal.rb

@@ -3,9 +3,9 @@
 module Move
   # unlimited horizontal movement for a piece
   class Horizontal < Base
-    def legal_moves
-      legal_moves_in_line(position.positions_to_the_left) +
-        legal_moves_in_line(position.positions_to_the_right)
+    def legal_target_positions
+      legal_target_positions_in_line(position.positions_to_the_left) +
+        legal_target_positions_in_line(position.positions_to_the_right)
     end
   end
 end

lib/move/knight.rb

@@ -3,11 +3,11 @@
 module Move
   # knight moves in ls
   class Knight < Base
-    def legal_moves
+    def legal_target_positions
       positions = directions.map do |direction|
         position.go(*direction)
       end
-      without_illegal_moves(positions.compact)
+      without_illegal_target_positions(positions.compact)
     end
 
     private

lib/move/one_down.rb

@@ -3,8 +3,8 @@
 module Move
   # king moves
   class OneDown < Base
-    def legal_moves
-      without_illegal_moves([position.down])
+    def legal_target_positions
+      without_illegal_target_positions([position.down])
     end
   end
 end

lib/move/one_into_any_direction.rb

@@ -3,11 +3,11 @@
 module Move
   # king moves
   class OneIntoAnyDirection < Base
-    def legal_moves
+    def legal_target_positions
       positions = directions.map do |direction|
         position.go(*direction)
       end
-      without_illegal_moves(positions.compact)
+      without_illegal_target_positions(positions.compact)
     end
 
     private

lib/move/one_up.rb

@@ -3,8 +3,8 @@
 module Move
   # king moves
   class OneUp < Base
-    def legal_moves
-      without_illegal_moves([position.down])
+    def legal_target_positions
+      without_illegal_target_positions([position.down])
     end
   end
 end

lib/move/two_down.rb

@@ -3,7 +3,7 @@
 module Move
   # move down two squares if not occupied
   class TwoDown < Base
-    def legal_moves
+    def legal_target_positions
       if no_piece_in_the_way? && target_piece_not_occupied?
         [position.down.down]
       else

lib/move/two_up.rb

@@ -3,7 +3,7 @@
 module Move
   # move down two squares if not occupied
   class TwoUp < Base
-    def legal_moves
+    def legal_target_positions
       if no_piece_in_the_way? && target_piece_not_occupied?
         [position.up.up]
       else

lib/move/vertical.rb

@@ -3,9 +3,9 @@
 module Move
   # unlimited vertical movement for a piece
   class Vertical < Base
-    def legal_moves
-      legal_moves_in_line(position.positions_upwards) +
-        legal_moves_in_line(position.positions_downwards)
+    def legal_target_positions
+      legal_target_positions_in_line(position.positions_upwards) +
+        legal_target_positions_in_line(position.positions_downwards)
     end
   end
 end

test/move/diagonal_test.rb

@@ -9,10 +9,10 @@ def test_legal_move_blocked_by_other_piece_to_the_upper_right
       board.place(Piece.new(:black), "C1")
 
       move = Move::Diagonal.new(board, "C1")
-      assert_includes move.legal_moves, Position.parse("A3")
+      assert_includes move.legal_target_positions, Position.parse("A3")
 
       board.place(Piece.new(:white), "B2")
-      assert !move.legal_moves.include?(Position.parse("A1"))
+      assert !move.legal_target_positions.include?(Position.parse("A1"))
     end
   end
 end

test/move/horizontal_test.rb

@@ -9,10 +9,10 @@ def test_legal_move_blocked_by_other_piece_to_the_left
       board.place(Piece.new(:black), "C1")
 
       move = Move::Horizontal.new(board, "C1")
-      assert_includes move.legal_moves, Position.parse("A1")
+      assert_includes move.legal_target_positions, Position.parse("A1")
 
       board.place(Piece.new(:white), "B1")
-      assert !move.legal_moves.include?(Position.parse("A1"))
+      assert !move.legal_target_positions.include?(Position.parse("A1"))
     end
 
     def test_legal_move_blocked_by_enemy_piece_to_the_right
@@ -21,16 +21,16 @@ def test_legal_move_blocked_by_enemy_piece_to_the_right
       move = Move::Horizontal.new(board, "C1")
       board.place(Piece.new(:white), "F1")
 
-      assert_includes move.legal_moves, Position.parse("F1")
-      assert !move.legal_moves.include?(Position.parse("H1"))
+      assert_includes move.legal_target_positions, Position.parse("F1")
+      assert !move.legal_target_positions.include?(Position.parse("H1"))
     end
 
     def test_legal_move_blocked_by_own_piece
       board = Board.new
       board.place(Rook.new(:black), "C1")
       board.place(Piece.new(:black), "B1")
       move = Move::Horizontal.new(board, "C1")
-      assert !move.legal_moves.include?(Position.parse("B1"))
+      assert !move.legal_target_positions.include?(Position.parse("B1"))
     end
   end
 end

test/move/knight_test.rb

@@ -9,10 +9,10 @@ def test_knight_move
       board.place(Piece.new(:black), "C1")
       move = Move::Knight.new(board, "C1")
 
-      assert_includes move.legal_moves, Position.parse("D3")
+      assert_includes move.legal_target_positions, Position.parse("D3")
 
       board.place(Piece.new(:black), "D3")
-      assert !move.legal_moves.include?(Position.parse("D3"))
+      assert !move.legal_target_positions.include?(Position.parse("D3"))
     end
   end
 end

test/move/one_into_any_direction_text.rb

@@ -9,8 +9,8 @@ def test_move_right
       board.place(Piece.new(:black), "A1")
       move = Move::OneIntoAnyDirection.new(board, "A1")
 
-      assert_includes move.legal_moves, Position.parse("B1")
-      assert !move.legal_moves.include?(Position.parse("C1"))
+      assert_includes move.legal_target_positions, Position.parse("B1")
+      assert !move.legal_target_positions.include?(Position.parse("C1"))
     end
   end
 end

test/move/two_down_test.rb

@@ -8,10 +8,10 @@ def test_move_down
       board = Board.new
       board.place(Piece.new(:black), "A8")
       move = Move::TwoDown.new(board, "A8")
-      assert_includes move.legal_moves, Position.parse("A6")
+      assert_includes move.legal_target_positions, Position.parse("A6")
 
       board.place(Piece.new(:black), "A7")
-      assert !move.legal_moves.include?(Position.parse("A6"))
+      assert !move.legal_target_positions.include?(Position.parse("A6"))
     end
   end
 end

test/move/vertical_test.rb

@@ -9,10 +9,10 @@ def test_move_vertical
       board.place(Piece.new(:black), "C1")
       move = Move::Vertical.new(board, "C1")
 
-      assert_includes move.legal_moves, Position.parse("C8")
+      assert_includes move.legal_target_positions, Position.parse("C8")
 
       board.place(Piece.new(:black), "C2")
-      assert !move.legal_moves.include?(Position.parse("C2"))
+      assert !move.legal_target_positions.include?(Position.parse("C2"))
     end
   end
 end