queen-attack: update to v2.0.0

https://github.com/exercism/problem-specifications/commit/44a1e12aedb1a9acff3ee79c0413ecf3093401a6#diff-96b36309ff1b4f05ed51e0af6563ed56

exercises/queen-attack/.meta/src/reference/java/BoardCoordinate.java

@@ -1,27 +1,27 @@
-public final class BoardCoordinate {
+final class BoardCoordinate {
 
-    private final int rank;
+    private final int row;
 
-    private final int file;
+    private final int column;
 
-    public BoardCoordinate(final int rank, final int file) throws IllegalArgumentException {
-        this.rank = rank;
-        this.file = file;
+    BoardCoordinate(final int row, final int column) throws IllegalArgumentException {
+        this.row = row;
+        this.column = column;
 
         validateInputs();
     }
 
-    public int getRank() {
-        return rank;
+    int getRow() {
+        return row;
     }
 
-    public int getFile() {
-        return file;
+    int getColumn() {
+        return column;
     }
 
     private void validateInputs() throws IllegalArgumentException {
-        validateCoordinateComponent(rank, "rank");
-        validateCoordinateComponent(file, "file");
+        validateCoordinateComponent(row, "row");
+        validateCoordinateComponent(column, "column");
     }
 
     private void validateCoordinateComponent(final int value, final String componentName)

exercises/queen-attack/.meta/src/reference/java/QueenAttackCalculator.java

@@ -1,10 +1,10 @@
-public final class QueenAttackCalculator {
+final class QueenAttackCalculator {
 
     private final BoardCoordinate whiteQueenCoordinate;
 
     private final BoardCoordinate blackQueenCoordinate;
 
-    public QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
+    QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
             throws IllegalArgumentException {
 
         this.whiteQueenCoordinate = whiteQueenCoordinate;
@@ -13,8 +13,8 @@ public final class QueenAttackCalculator {
         validateInputs();
     }
 
-    public boolean canQueensAttackOneAnother() {
-        return queensShareFile() || queensShareRank() || queensShareDiagonal();
+    boolean canQueensAttackOneAnother() {
+        return queensShareColumn() || queensShareRow() || queensShareDiagonal();
     }
 
     private void validateInputs() throws IllegalArgumentException {
@@ -27,28 +27,28 @@ public final class QueenAttackCalculator {
         }
     }
 
-    private boolean queensShareRank() {
-        return differenceBetweenRanks() == 0;
+    private boolean queensShareRow() {
+        return differenceBetweenRows() == 0;
     }
 
-    private boolean queensShareFile() {
-        return differenceBetweenFiles() == 0;
+    private boolean queensShareColumn() {
+        return differenceBetweenColumns() == 0;
     }
 
     private boolean queensShareBoardCoordinate() {
-        return queensShareRank() && queensShareFile();
+        return queensShareRow() && queensShareColumn();
     }
 
     private boolean queensShareDiagonal() {
-        return differenceBetweenRanks() == differenceBetweenFiles();
+        return differenceBetweenRows() == differenceBetweenColumns();
     }
 
-    private int differenceBetweenRanks() {
-        return Math.abs(whiteQueenCoordinate.getRank() - blackQueenCoordinate.getRank());
+    private int differenceBetweenRows() {
+        return Math.abs(whiteQueenCoordinate.getRow() - blackQueenCoordinate.getRow());
     }
 
-    private int differenceBetweenFiles() {
-        return Math.abs(whiteQueenCoordinate.getFile() - blackQueenCoordinate.getFile());
+    private int differenceBetweenColumns() {
+        return Math.abs(whiteQueenCoordinate.getColumn() - blackQueenCoordinate.getColumn());
     }
 
 }

exercises/queen-attack/.meta/version

@@ -1 +1 @@
-1.0.0
+2.0.0

exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

@@ -12,7 +12,7 @@ public class QueenAttackCalculatorTest {
     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
-    public void testQueensThatDoNotShareRankFileOrDiagonalCannotAttack() {
+    public void testQueensThatDoNotShareRowColumnOrDiagonalCannotAttack() {
         final QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
 
@@ -21,7 +21,7 @@ public class QueenAttackCalculatorTest {
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameRank() {
+    public void testQueensCanAttackOnTheSameRow() {
         final QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
 
@@ -30,7 +30,7 @@ public class QueenAttackCalculatorTest {
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameFile() {
+    public void testQueensCanAttackOnTheSameColumn() {
         final QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
 
@@ -75,36 +75,36 @@ public class QueenAttackCalculatorTest {
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeRankNotAllowed() {
+    public void testCoordinateWithNegativeRowNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive rank.");
+        expectedException.expectMessage("Coordinate must have positive row.");
 
         new BoardCoordinate(-2, 2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithRankGreaterThan7NotAllowed() {
+    public void testCoordinateWithRowGreaterThan7NotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have rank <= 7.");
+        expectedException.expectMessage("Coordinate must have row <= 7.");
 
         new BoardCoordinate(8, 4);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeFileNotAllowed() {
+    public void testCoordinateWithNegativeColumnNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive file.");
+        expectedException.expectMessage("Coordinate must have positive column.");
 
         new BoardCoordinate(2, -2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithFileGreaterThan7NotAllowed() {
+    public void testCoordinateWithColumnGreaterThan7NotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have file <= 7.");
+        expectedException.expectMessage("Coordinate must have column <= 7.");
 
         new BoardCoordinate(4, 8);
     }