chess_vwong 0.0.1 → 0.0.2

data/spec/game_spec.rb

@@ -1,21 +1,20 @@
-require "spec_helper"
+require 'spec_helper'
 module ChessVwong
   describe Game do
-
-    let (:bob) { Player.new("Bob", "w") }
-    let (:peter) { Player.new("Peter", "b") }
-    let (:king) { King.new([0,0], "b") }
+    let (:bob) { Player.new('Bob', 'w') }
+    let (:peter) { Player.new('Peter', 'b') }
+    let (:king) { King.new([0, 0], 'b') }
     let (:game) { Game.new([bob, peter]) }
 
-    context "#switch_players" do
-      it "will set @current_player to @other_player" do
+    context '#switch_players' do
+      it 'will set @current_player to @other_player' do
         current_player = bob
         other_player = peter
         game.switch_players
         expect(game.current_player).to eq peter
       end
-     
-      it "will set @other_player to @current_player" do
+
+      it 'will set @other_player to @current_player' do
         current_player = bob
         other_player = peter
         game.switch_players
@@ -23,16 +22,15 @@ module ChessVwong
       end
     end
 
-    context "#game_over" do
-      it "should return winner if king has just been killed" do 
+    context '#game_over' do
+      it 'should return winner if king has just been killed' do
         game.current_player.kill_list << king
         expect(game.game_over).to eq game.current_player
       end
 
-      it "should return false if no King" do 
+      it 'should return false if no King' do
         expect(game.game_over).to eq false
-      end      
+      end
     end
-
   end
-end
+end

data/spec/king_spec.rb

@@ -1,51 +1,47 @@
-require "spec_helper"
+require 'spec_helper'
 
 module ChessVwong
-  describe King do 
-    let (:current_space) { [1,1]}
-    let (:king) { King.new(current_space,"w")}
-    context "#initialize" do
-      it "should return Piece attributes: color" do
-        expect(king.color).to eq "w"
+  describe King do
+    let (:current_space) { [1, 1] }
+    let (:king) { King.new(current_space, 'w') }
+    context '#initialize' do
+      it 'should return Piece attributes: color' do
+        expect(king.color).to eq 'w'
       end
 
-      it "should return Piece attributes: current_space" do
+      it 'should return Piece attributes: current_space' do
         expect(king.current_space).to eq current_space
       end
     end
 
-    context "#character" do
-      it "should return a white king character" do
-        expect(king.character).to eq "\u{265A}"
+    context '#character' do
+      it 'should return a white king character' do
+        expect(king.character).to eq "\u{2654}"
       end
 
-      it "should return a black king character" do
-        king_2 = King.new(current_space,"b")
-        expect(king_2.character).to eq "\u{2654}"
-      end    
-    end  
-
-    context "#generate_neighbours" do
+      it 'should return a black king character' do
+        king_2 = King.new(current_space, 'b')
+        expect(king_2.character).to eq "\u{265A}"
+      end
+    end
 
-      it "should return only 16 neighbour when [1,1]" do
+    context '#generate_neighbours' do
+      it 'should return only 16 neighbour when [1,1]' do
         king.generate_neighbours(current_space)
         expect(king.neighbours.count).to eq 3
       end
 
-      it "should return only 14 neighbour when [8,8]" do
-        current_space = [8,8]
+      it 'should return only 14 neighbour when [8,8]' do
+        current_space = [8, 8]
         king.generate_neighbours(current_space)
         expect(king.neighbours.count).to eq 3
       end
 
-      it "should return only 14 neighbour when in the middle" do
-        current_space = [3,3]
+      it 'should return only 14 neighbour when in the middle' do
+        current_space = [3, 3]
         king.generate_neighbours(current_space)
         expect(king.neighbours.count).to eq 8
-      end   
-
+      end
     end
-
-
   end
-end
+end

data/spec/knight_spec.rb

@@ -1,73 +1,71 @@
-require "spec_helper"
+require 'spec_helper'
 
 module ChessVwong
-  describe Knight do 
-    let (:current_space) {[1,1]}
-    let (:knight) { Knight.new(current_space, "w")}
-    context "#initialize" do
-      it "should return Piece attributes: color" do
-        expect(knight.color).to eq "w"
+  describe Knight do
+    let (:current_space) { [1, 1] }
+    let (:knight) { Knight.new(current_space, 'w') }
+    context '#initialize' do
+      it 'should return Piece attributes: color' do
+        expect(knight.color).to eq 'w'
       end
 
-      it "should return Piece attributes: current_space" do
+      it 'should return Piece attributes: current_space' do
         expect(knight.current_space).to eq current_space
       end
     end
 
-    context "#character" do
-      it "should return a white knight character" do
-        expect(knight.character).to eq "\u{265E}"
+    context '#character' do
+      it 'should return a white knight character' do
+        expect(knight.character).to eq "\u{2658}"
       end
 
-      it "should return a black knight character" do
-        knight_2 = Knight.new(current_space,"b")
-        expect(knight_2.character).to eq "\u{2658}"
-      end    
-    end  
+      it 'should return a black knight character' do
+        knight_2 = Knight.new(current_space, 'b')
+        expect(knight_2.character).to eq "\u{265E}"
+      end
+    end
 
-    context "#generate_neighbours" do
-      it "should return only 2 neighbour when [1,1]" do
+    context '#generate_neighbours' do
+      it 'should return only 2 neighbour when [1,1]' do
         knight.generate_neighbours(current_space)
         expect(knight.neighbours.count).to eq 2
       end
 
-      it "should return only 2 neighbour when [7,7]" do
-        current_space = [8,8]
+      it 'should return only 2 neighbour when [7,7]' do
+        current_space = [8, 8]
         knight.generate_neighbours(current_space)
         expect(knight.neighbours.count).to eq 2
       end
 
-      it "should return only 4 neighbour when on left edge" do
-        current_space = [1,4]
+      it 'should return only 4 neighbour when on left edge' do
+        current_space = [1, 4]
         knight.generate_neighbours(current_space)
         expect(knight.neighbours.count).to eq 4
       end
 
-      it "should return only 4 neighbour when on right edge" do
-        current_space = [8,4]
+      it 'should return only 4 neighbour when on right edge' do
+        current_space = [8, 4]
         knight.generate_neighbours(current_space)
         expect(knight.neighbours.count).to eq 4
       end
 
-      it "should return only 4 neighbour when on top edge" do
-        current_space = [4,1]
+      it 'should return only 4 neighbour when on top edge' do
+        current_space = [4, 1]
         knight.generate_neighbours(current_space)
         expect(knight.neighbours.count).to eq 4
       end
 
-      it "should return only 4 neighbour when on right edge" do
-        current_space = [4,8]
+      it 'should return only 4 neighbour when on right edge' do
+        current_space = [4, 8]
         knight.generate_neighbours(current_space)
         expect(knight.neighbours.count).to eq 4
       end
 
-      it "should return 8 neighbour when in middle" do
-        current_space = [4,4]
+      it 'should return 8 neighbour when in middle' do
+        current_space = [4, 4]
         knight.generate_neighbours(current_space)
         expect(knight.neighbours.count).to eq 8
       end
     end
-
-
   end
-end
+end

data/spec/node_spec.rb

@@ -1,24 +1,23 @@
-require "spec_helper"
+require 'spec_helper'
 
 module ChessVwong
-  describe Node do 
-    let (:node) { Node.new}
-    let (:knight) { Knight.new(node, "w")}
+  describe Node do
+    let (:node) { Node.new }
+    let (:knight) { Knight.new(node, 'w') }
 
-    context "#intialize" do
+    context '#intialize' do
       # it "is initialized with x,y coordinates for its value" do
       #   expect(node.value).to eq [0,0]
       # end
 
-      it "defaults to unoccupied" do
+      it 'defaults to unoccupied' do
         expect(node.occupied).to eq []
-      end       
+      end
 
-      it "can accept pieces as occupants" do
+      it 'can accept pieces as occupants' do
         node.occupied << knight
         expect(node.occupied).to eq [knight]
-      end                      
+      end
     end
-    
   end
-end
+end

data/spec/pawn_spec.rb

@@ -1,112 +1,110 @@
-require "spec_helper"
+require 'spec_helper'
 
 module ChessVwong
-  describe Pawn do 
-    let (:current_space) { [1,1]}
-    let (:board) { Board.new}
-    let (:node) { Node.new}
-    let (:pawn) { Pawn.new(current_space,"w")}
-    let (:pawn_2) { Pawn.new(current_space,"b")}
-    context "#initialize" do
-      it "should return Piece attributes: color" do
-        expect(pawn.color).to eq "w"
+  describe Pawn do
+    let (:current_space) { [1, 1] }
+    let (:board) { Board.new }
+    let (:node) { Node.new }
+    let (:pawn) { Pawn.new(current_space, 'w') }
+    let (:pawn_2) { Pawn.new(current_space, 'b') }
+    context '#initialize' do
+      it 'should return Piece attributes: color' do
+        expect(pawn.color).to eq 'w'
       end
 
-      it "should return Piece attributes: current_space" do
+      it 'should return Piece attributes: current_space' do
         expect(pawn.current_space).to eq current_space
       end
     end
 
-    context "#character" do
-      it "should return a white pawn character" do
-        expect(pawn.character).to eq "\u{265F}"
+    context '#character' do
+      it 'should return a white pawn character' do
+        expect(pawn.character).to eq "\u{2659}"
       end
 
-      it "should return a black pawn character" do
-        expect(pawn_2.character).to eq "\u{2659}"
-      end    
-    end  
+      it 'should return a black pawn character' do
+        expect(pawn_2.character).to eq "\u{265F}"
+      end
+    end
 
-    context "#generate_neighbours" do
-      it "should return only 0 neighbour when [1,1] and White" do
+    context '#generate_neighbours' do
+      it 'should return only 0 neighbour when [1,1] and White' do
         pawn.generate_neighbours(current_space, node, node)
         expect(pawn.neighbours.count).to eq 0
       end
 
-      it "should return only 4 neighbours if First move and white" do
-        current_space = [7,7]
+      it 'should return only 4 neighbours if First move and white' do
+        current_space = [7, 7]
         pawn.generate_neighbours(current_space, node, node)
         expect(pawn.neighbours.count).to eq 2
       end
 
-      it "should return 4 moves if First move and Black" do
-        current_space = [2,2]
+      it 'should return 4 moves if First move and Black' do
+        current_space = [2, 2]
         pawn.generate_neighbours(current_space, node, node)
         pawn_2.generate_neighbours(current_space, node, node)
         expect(pawn_2.neighbours.count).to eq 2
       end
 
-      it "should return only 2 neighbour when [8,8] and Black" do
-        current_space = [8,8]
+      it 'should return only 2 neighbour when [8,8] and Black' do
+        current_space = [8, 8]
         pawn_2.generate_neighbours(current_space, node, node)
         expect(pawn_2.neighbours.count).to eq 0
       end
 
-      it "should return only 3 neighbour when in the middle" do
-        current_space = [3,3]
+      it 'should return only 3 neighbour when in the middle' do
+        current_space = [3, 3]
         pawn.generate_neighbours(current_space, node, node)
         expect(pawn.neighbours.count).to eq 1
-      end      
+      end
     end
 
-    context "kill_move" do 
-      it "should return Kill Moves for Black Pawn" do
-        current_space = [2,2]
+    context 'kill_move' do
+      it 'should return Kill Moves for Black Pawn' do
+        current_space = [2, 2]
         enemy_node1 = board.grid[3][3]
         enemy_node1.occupied << pawn
         enemy_node2 = board.grid[3][1]
         enemy_node2.occupied << pawn
-        expect(pawn_2.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 4 
+        expect(pawn_2.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 4
       end
 
-      it "should not return Kill Moves for Black Pawn if empty" do
-        current_space = [2,2]         
-        expect(pawn_2.generate_neighbours(current_space, node, node).count).to eq 2             
-      end      
+      it 'should not return Kill Moves for Black Pawn if empty' do
+        current_space = [2, 2]
+        expect(pawn_2.generate_neighbours(current_space, node, node).count).to eq 2
+      end
 
-      it "should not return Kill Moves for Black Pawn if blocked by same color" do
-        current_space = [2,2]
+      it 'should not return Kill Moves for Black Pawn if blocked by same color' do
+        current_space = [2, 2]
         enemy_node1 = board.grid[3][3]
         enemy_node1.occupied << pawn_2
         enemy_node2 = board.grid[3][1]
         enemy_node2.occupied << pawn_2
-        expect(pawn_2.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 2         
-      end      
+        expect(pawn_2.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 2
+      end
 
-      it "should return Kill Moves for White Pawn" do
-        current_space = [7,7]
+      it 'should return Kill Moves for White Pawn' do
+        current_space = [7, 7]
         enemy_node1 = board.grid[6][6]
         enemy_node1.occupied << pawn_2
         enemy_node2 = board.grid[6][8]
         enemy_node2.occupied << pawn_2
-        expect(pawn.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 4    
-      end      
-
-      it "should not return Kill Moves for White Pawn if empty" do
-        current_space = [7,7]         
-        expect(pawn.generate_neighbours(current_space, node, node).count).to eq 2        
+        expect(pawn.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 4
+      end
 
-      end  
+      it 'should not return Kill Moves for White Pawn if empty' do
+        current_space = [7, 7]
+        expect(pawn.generate_neighbours(current_space, node, node).count).to eq 2
+      end
 
-      it "should not return Kill Moves for White Pawn if blocked by same color" do
-        current_space = [7,7]
+      it 'should not return Kill Moves for White Pawn if blocked by same color' do
+        current_space = [7, 7]
         enemy_node1 = board.grid[6][6]
         enemy_node1.occupied << pawn
         enemy_node2 = board.grid[6][8]
         enemy_node2.occupied << pawn
-        expect(pawn.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 2           
-      end                   
+        expect(pawn.generate_neighbours(current_space, enemy_node1, enemy_node2).count).to eq 2
+      end
     end
-
   end
-end
+end

data/spec/piece_spec.rb

@@ -1,53 +1,53 @@
-require "spec_helper"
+require 'spec_helper'
 
 module ChessVwong
-  describe Piece do 
-    let (:current_space) {[1,1]}
-    let (:piece) { Piece.new(current_space, "w")}
+  describe Piece do
+    let (:current_space) { [1, 1] }
+    let (:piece) { Piece.new(current_space, 'w') }
 
-    context "#initialize" do
-      it "should initialize with current_space" do
+    context '#initialize' do
+      it 'should initialize with current_space' do
         expect(piece.current_space).to eq current_space
       end
 
-      it "should initialize with current_space" do
-        expect(piece.color).to eq "w"
+      it 'should initialize with current_space' do
+        expect(piece.color).to eq 'w'
       end
     end
 
-    context "#neighbours" do
-      it "should contain neighouring spaces" do 
-        neighouring_space = [4,4]
+    context '#neighbours' do
+      it 'should contain neighouring spaces' do
+        neighouring_space = [4, 4]
         piece.neighbours << neighouring_space
-        expect(piece.neighbours).to eq [[4,4]]
+        expect(piece.neighbours).to eq [[4, 4]]
       end
     end
 
-    context "#valid_space?" do
-      it "should return true if valid" do
-        valid_space = [5,5]
+    context '#valid_space?' do
+      it 'should return true if valid' do
+        valid_space = [5, 5]
         expect(piece.valid_space?(valid_space)).to eq true
       end
 
-      it "should return nil if x < 0" do
+      it 'should return nil if x < 0' do
         invalid_space = [-1, 5]
         expect(piece.valid_space?(invalid_space)).to eq nil
       end
 
-      it "should return nil if x > 9" do
-        invalid_space = [9,5]
+      it 'should return nil if x > 9' do
+        invalid_space = [9, 5]
         expect(piece.valid_space?(invalid_space)).to eq nil
       end
 
-      it "should return nil if y < 0" do
-        invalid_space = [5,-1]
+      it 'should return nil if y < 0' do
+        invalid_space = [5, -1]
         expect(piece.valid_space?(invalid_space)).to eq nil
       end
 
-      it "should return nil if y > 9" do
-        invalid_space = [5,9]
+      it 'should return nil if y > 9' do
+        invalid_space = [5, 9]
         expect(piece.valid_space?(invalid_space)).to eq nil
       end
     end
   end
-end
+end