chessmate 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3eb25de34a44fabc8d5c94cff25979b5664c075c5cc897eb151c4513a749789
-  data.tar.gz: 1ee304bf8f9ca8adb1cfceb143b44abeb6af447539ac1854622237d7b81e2791
+  metadata.gz: e8a0298012d7f8cad83eb00236534883f661bf131b826400de162a952d6a846e
+  data.tar.gz: b3047583dc762d0fa97c555102f59a7289e5dcd913ae76fa71a8b4b937a1b6ec
 SHA512:
-  metadata.gz: 6e53760a34c345c7297cd59dbe6f77d06c3ac08f9507d7bdcf06528327199ccbbe808ea65f5103a688268b0b849039a31148ccd1c17b36ad091811d9be3bb89c
-  data.tar.gz: 80089bb5808ab2fcb7f4a2dd8c65ef9500d5dc31759cfbd655c6552179e665698e8910867f2d24c94f4e7deac11f990c7714a34602f9ecfa9f04e7a14521fd8b
+  metadata.gz: c34f8fc54e8c829e454142f82f4c8b4f788018f32b646de78c39201462e57d849c50792b5cb5d591480fa99aba3fba56a328210ee1bfa5492779eb75bf0efd70
+  data.tar.gz: b865da7aba16232d0fadb70f7156bae86a8bbcf79688ae53644f6209f5bfbd427f246da18d8dc29c34778903551b60cd6dc6e8f1e16ecb2cec9125d2e028edc5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at tyler.b.porter@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    chessmate (0.7.0)
+    chessmate (0.7.1)
       deep_dup (~> 0)
 
 GEM
@@ -37,7 +37,7 @@ DEPENDENCIES
   chessmate!
   pry (~> 0)
   rspec (~> 0)
-  rubocop (>= 0.49.0)
+  rubocop (= 0.75.1)
 
 BUNDLED WITH
    2.0.2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Tyler Porter
+
+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,129 @@
+<p align="center">
+  <img width="800" height="150" src="https://imgur.com/WFCwf9p.png">
+</p>
+<h2 align="center">A dead-simple chess validation gem for Rails</h2>
+<p align="center">
+  <a href="https://travis-ci.com/pawptart/ChessMate">
+    <img src="https://travis-ci.com/pawptart/ChessMate.svg?branch=master">
+  </a>
+  <a href="https://github.com/pawptart/ChessMate/issues">
+    <img src="https://img.shields.io/github/issues/pawptart/chessmate">
+  </a>
+  <a href="https://rubygems.org/gems/chessmate">
+    <img src="https://img.shields.io/gem/v/chessmate">
+  </a>
+</p>
+
+## About
+ChessMate was built in around 2 months to be as easy to use as possible to quickly and easily bootstrap a chess game in Rails. The original idea came from a bootcamp exercise to build a working chess game, and so the code that was written there has been ported to ChessMate in order to benefit future programmers.
+
+ChessMate is designed to be a backend tool to validate possible chess moves. Therefore, it is intentionally as agnostic to your frontend as possible to integrate into many different frameworks. Because it's designed to be flexible, it even supports custom game boards and can allow out-of-turn movement!
+
+Click [here](http://chessmate-demo.herokuapp.com/) to play with a Rails app running ChessMate! (Or check out the source code [here](https://github.com/pawptart/ChessTest).)
+
+<p align="center">
+  <img src="https://i.imgur.com/vyQjL4Y.png">
+</p>
+
+## Usage
+Simply add ChessMate to your Gemfile:
+
+```
+gem 'chessmate'
+```
+
+and then you can require it in a model, controller, etc. 
+
+```
+require 'chessmate'
+```
+
+From there, you are free to utilize all the functions and features of ChessMate!
+
+## Building a new game and playing 
+
+```
+game = ChessMate.new
+```
+
+Moving pieces works based on chess notation: for example, a common first move is `e2` to `e4`. ChessMate accepts these squares as arguments to the `move` method, so you don't need to specify a piece type like in normal chess notation. To make this move in ChessMate:
+
+```
+game.move('e2', 'e4')
+```
+
+If a move is invalid, `ChessMate.move` will return `false`, and the board and game state will not update. You also do not need to specify for any "special" moves, like castling or _en passant_, as ChessMate can handle this for you.
+
+Other functions you might call:
+
+```
+game.promote?(square)           # Check if a square is capable of pawn promotion
+game.promote!(square, piece)     # Promote a promotable pawn, accepts 'rook'/'knight'/'bishop'/'queen'
+game.in_check?                  # Determine if either color is currently in check
+game.checkmate?(color)          # Determine if the game is over, accepts 'W'/'B'
+game.draw?(color)               # Same as checkmate, for draw
+```
+
+Using these functions, it's quite simple to build a working chess game!
+
+## Custom games
+With ChessMate, it's very easy to build your own custom games. Below is a list of all the defaults ChessMate uses to build a game board, but they can be modified and passed into the `ChessMate.new` method as named arguments in any order, and ChessMate will build a game around your custom params. 
+
+For instance, for a custom board, on turn 10, with the white king in check:
+
+```
+custom_board = [
+          [nil, nil, nil, nil, 'BK', nil, nil, nil],
+          [nil, nil, nil, nil, 'BQ', nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          ['WP', nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, 'WK', nil, nil, nil]
+        ]
+turn = 10
+in_check = { white: true, black: false }
+
+game = ChessMate.new(board: custom_board, turn: turn, in_check: in_check)
+```
+
+ChessMate can build a game with those parameters!
+
+Here is a list of all the defaults:
+```
+board: [
+  %w[BR BN BB BQ BK BB BN BR],
+  %w[BP BP BP BP BP BP BP BP],
+  [nil, nil, nil, nil, nil, nil, nil, nil],
+  [nil, nil, nil, nil, nil, nil, nil, nil],
+  [nil, nil, nil, nil, nil, nil, nil, nil],
+  [nil, nil, nil, nil, nil, nil, nil, nil],
+  %w[WP WP WP WP WP WP WP WP],
+  %w[WR WN WB WQ WK WB WN WR]
+]
+
+turn: 1
+
+promotable: nil
+
+en_passant: { white: nil, black: nil }
+
+in_check: { white: false, black: false }
+
+castling: {
+  white: {
+    kingside: true,
+    queenside: true
+  },
+  black: {
+    kingside: true,
+    queenside: true
+  }
+}
+```
+
+## Contributing
+ChessMate is open to contributions! If you have a feature request, a bug, or a suggestion, please open an issue! Please note that a review is required and passing TravisCI build before your PR can be merged with master.
+
+Currently looking to expand ChessMate features by allowing chess notation logging as well as better documentation!

data/lib/chessmate.rb

@@ -11,8 +11,16 @@ class ChessMate
   require 'pieces/queen'
   require 'pieces/king'
   require 'helpers/default'
+  require 'helpers/logger'
 
-  attr_reader :board, :turn, :in_check, :promotable, :en_passant, :castling, :allow_out_of_turn
+  attr_reader :board,
+              :turn,
+              :in_check,
+              :promotable,
+              :en_passant,
+              :castling,
+              :allow_out_of_turn,
+              :move_history
 
   def initialize(board: nil,
                  turn: nil,
@@ -20,10 +28,12 @@ class ChessMate
                  en_passant: nil,
                  castling: nil,
                  in_check: nil,
-                 allow_out_of_turn: nil)
+                 allow_out_of_turn: nil,
+                 move_history: nil,
+                 ignore_logging: false)
     @board = board || DEFAULT[:board].map(&:dup)
     @turn = turn || DEFAULT[:turn]
-    @promotable = promotable || DeepDup.deep_dup(DEFAULT[:promotable])
+    @promotable = promotable
     @en_passant = en_passant || DeepDup.deep_dup(DEFAULT[:en_passant])
     @castling = castling || DeepDup.deep_dup(DEFAULT[:castling])
     @in_check = in_check || DeepDup.deep_dup(DEFAULT[:in_check])
@@ -35,13 +45,13 @@ class ChessMate
                          else
                            false
                          end
+    @move_history = move_history || []
+    @ignore_logging = ignore_logging
   end
 
   def update(orig, dest = nil)
-    orig_y = orig[0]
-    orig_x = orig[1]
-    dest_y = dest[0]
-    dest_x = dest[1]
+    orig_y, orig_x = orig
+    dest_y, dest_x = dest
     piece_type = @board[orig_y][orig_x]
     piece_color = piece_type[0] == 'W' ? :white : :black
     opposite_color = piece_type[0] == 'W' ? :black : :white
@@ -79,10 +89,16 @@ class ChessMate
       @board[orig_y][new_rook_x_position] = piece_type[0] + 'R'
     end
 
+    @promotable = dest if piece_type[1] == 'P' && promote?(orig)
+
+    unless @ignore_logging
+      logger = Logger.new(orig, dest, @board)
+      @move_history << logger.log_move
+    end
+
     @board[orig_y][orig_x] = nil
     @board[dest_y][dest_x] = piece_type
 
-    @promotable = dest if piece_type[1] == 'P' && promote?(dest)
     @in_check = in_check?
     @turn += 1
   end
@@ -117,6 +133,8 @@ class ChessMate
   end
 
   def move(orig, dest, test = false, test_board = nil)
+    return false if @promotable
+
     orig_pos = NotationParser.parse_notation(orig)
     dest_pos = NotationParser.parse_notation(dest)
 
@@ -149,7 +167,7 @@ class ChessMate
                    false
                  end
     unless test
-      in_check_after_move = in_check_after_move?(orig_pos, dest_pos) 
+      in_check_after_move = in_check_after_move?(orig_pos, dest_pos)
       update(orig_pos, dest_pos) if valid_move && !test && !in_check_after_move
     end
 
@@ -159,10 +177,8 @@ class ChessMate
   def in_check_after_move?(orig, dest)
     test_board = @board.map(&:dup)
 
-    orig_y = orig[0]
-    orig_x = orig[1]
-    dest_y = dest[0]
-    dest_x = dest[1]
+    orig_y, orig_x = orig
+    dest_y, dest_x = dest
     piece = test_board[orig_y][orig_x]
     piece_type = test_board[orig_y][orig_x]
     opposite_color = piece_type[0] == 'W' ? :black : :white
@@ -236,8 +252,8 @@ class ChessMate
   def promote?(square)
     square_y = square[0]
     square_x = square[1]
-    piece = @board[square_y][square_x][0]
-    promote_column = piece.downcase == 'w' ? 0 : 7
+    piece_color = @board[square_y][square_x][0]
+    promote_column = piece_color.downcase == 'w' ? 1 : 6
     promote_column == square_y
   end
 
@@ -246,7 +262,7 @@ class ChessMate
     square_x = square[1]
 
     old_piece = @board[square_y][square_x]
-    return nil if old_piece.nil? || !promote?(square)
+    return nil if old_piece.nil? || @promotable != [square_y, square_x]
 
     case piece.downcase
     when 'rook'
@@ -262,5 +278,11 @@ class ChessMate
     end
 
     @board[square_y][square_x] = old_piece[0] + piece_type
+    @promotable = nil
+
+    return if @ignore_logging
+
+    logger = Logger.new(nil, nil, nil, promotion_type: piece_type, history: @move_history)
+    @move_history[-1] += logger.log_promotion
   end
 end

data/lib/helpers/default.rb

@@ -12,7 +12,6 @@ DEFAULT = {
     %w[WR WN WB WQ WK WB WN WR]
   ],
   turn: 1,
-  promotable: nil,
   en_passant: { white: nil, black: nil },
   in_check: { white: false, black: false },
   castling: {

data/lib/helpers/logger.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'helpers/notation_parser'
+require 'chessmate'
+
+class Logger
+  def initialize(orig, dest, board, en_passant: false, promotion_type: nil, history: nil)
+    @promotion_type = promotion_type
+    @history = history
+
+    return unless orig && dest && board
+
+    @orig = orig
+    @dest = dest
+    @board = board
+    @en_passant = en_passant
+    @orig_y, @orig_x = @orig
+    @dest_y, @dest_x = @dest
+    @piece = @board[@orig_y][@orig_x]
+    @piece_color, @piece_type = @piece.chars
+  end
+
+  def log_move
+    if @piece_type == 'K' && (@orig_x - @dest_x).abs > 1
+      return (@dest_x - @orig_x).positive? ? '0-0' : '0-0-0'
+    end
+
+    origin = encode_origin
+    capture = @board[@dest_y][@dest_x] || @en_passant ? 'x' : ''
+    destination = NotationParser.encode_notation(@dest)
+
+    origin + capture + destination + check_or_mate
+  end
+
+  def log_promotion
+    @promotion_type ? "=(#{@promotion_type})" : ''
+  end
+
+  private
+
+  def encode_origin
+    notation_required = [false, false]
+    game = ChessMate.new(board: @board)
+    encoded_dest = NotationParser.encode_notation(@dest)
+
+    @board.each_with_index do |row, y|
+      row.each_with_index do |col, x|
+        next unless @piece == col && [@orig_y, @orig_x] != [y, x]
+
+        encoded_orig = NotationParser.encode_notation([y, x])
+
+        if game.move(encoded_orig, encoded_dest, true)
+          notation_required[0] = true if @orig_y == y || (@orig_y != y && @orig_x != x)
+          notation_required[1] = true if @orig_x == x
+        end
+      end
+    end
+
+    if notation_required.nil? || notation_required.none?(true)
+      if @piece_type == 'P'
+        return NotationParser.encode_notation(@orig)[0] if @board[@dest_y][@dest_x] || @en_passant
+
+        return ''
+      end
+      return @piece_type
+    end
+    ambiguous_encoded = @piece_type
+    encoded_origin_chars = NotationParser.encode_notation(@orig).chars
+    notation_required.each_with_index do |value, i|
+      ambiguous_encoded += encoded_origin_chars[i] if value
+    end
+    ambiguous_encoded
+  end
+
+  def check_or_mate
+    game = ChessMate.new(board: @board, ignore_logging: true)
+    encoded_orig = NotationParser.encode_notation(@orig)
+    encoded_dest = NotationParser.encode_notation(@dest)
+    opposite_color_letter = @piece_color == 'W' ? 'B' : 'W'
+    opposite_color_string = opposite_color_letter == 'W' ? 'white' : 'black'
+
+    game.move(encoded_orig, encoded_dest)
+    checkmate = game.checkmate?(opposite_color_letter)
+    check = game.in_check?[opposite_color_string.to_sym]
+
+    return '#' if checkmate
+    return '+' if check
+
+    ''
+  end
+end

data/lib/pieces/king.rb

@@ -16,10 +16,8 @@ class King < Piece
   end
 
   def self.valid_castling_move?(orig, dest, board, castling)
-    orig_y = orig[0]
-    orig_x = orig[1]
-    dest_y = dest[0]
-    dest_x = dest[1]
+    orig_y, orig_x = orig
+    dest_y, dest_x = dest
 
     return false if orig_y != dest_y || (orig_x - dest_x).abs != 2
 

data/lib/pieces/pawn.rb

@@ -6,10 +6,8 @@ class Pawn < Piece
   def self.move_is_valid?(orig, dest, board, en_passant)
     return true if en_passant(orig, dest, board, en_passant)
 
-    orig_y = orig[0]
-    orig_x = orig[1]
-    dest_y = dest[0]
-    dest_x = dest[1]
+    orig_y, orig_x = orig
+    dest_y, dest_x = dest
     piece_type = board[orig_y][orig_x]
     piece_color = piece_type[0].downcase
 
@@ -36,10 +34,8 @@ class Pawn < Piece
   end
 
   def self.en_passant(orig, dest, board, en_passant)
-    orig_y = orig[0]
-    orig_x = orig[1]
-    dest_y = dest[0]
-    dest_x = dest[1]
+    orig_y, orig_x = orig
+    dest_y, dest_x = dest
     piece_type = board[orig_y][orig_x]
     opposite_color = piece_type[0].downcase == 'w' ? :black : :white
     direction = opposite_color == :white ? -1 : 1

data/lib/pieces/piece.rb

@@ -2,10 +2,8 @@
 
 class Piece
   def self.obstructed?(orig, dest, board)
-    orig_y = orig[0]
-    orig_x = orig[1]
-    dest_y = dest[0]
-    dest_x = dest[1]
+    orig_y, orig_x = orig
+    dest_y, dest_x = dest
 
     if orig_y == dest_y
 
@@ -14,7 +12,8 @@ class Piece
         test_pos = orig_x - (x * direction) - direction
         return true unless board[orig_y][test_pos].nil?
       end
-      return false
+
+      false
 
     elsif orig_x == dest_x
 
@@ -24,7 +23,7 @@ class Piece
         return true unless board[test_pos][orig_x].nil?
       end
 
-      return false
+      false
 
     elsif (orig_y - dest_y).abs == (orig_x - dest_x).abs
 
@@ -37,18 +36,14 @@ class Piece
         return true unless board[test_y_pos][test_x_pos].nil?
       end
 
-      return false
+      false
 
-    else
-      return nil
     end
   end
 
   def self.capturable?(orig, dest, board)
-    orig_y = orig[0]
-    orig_x = orig[1]
-    dest_y = dest[0]
-    dest_x = dest[1]
+    orig_y, orig_x = orig
+    dest_y, dest_x = dest
     orig_piece = board[orig_y][orig_x]
     dest_piece = board[dest_y][dest_x]
 

data/pre-commit.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'english'
+require 'rubocop'
+
+ADDED_OR_MODIFIED = /A|AM|^M/.freeze
+
+changed_files = `git status --porcelain`.split(/\n/).
+    select { |file_name_with_status|
+      file_name_with_status =~ ADDED_OR_MODIFIED
+    }.
+    map { |file_name_with_status|
+      file_name_with_status.split(' ')[1]
+    }.
+    select { |file_name|
+      File.extname(file_name) == '.rb'
+    }.join(' ')
+
+success = system(%(rubocop #{changed_files}))
+
+STDIN.reopen('/dev/tty')
+
+if success == false
+  puts "Would you like to continue press 'any key' or 'n/N' to halt?"
+  exit(1) if %w(N n).include?(gets.chomp)
+end

data/spec/chessmate_spec.rb

@@ -59,7 +59,7 @@ describe ChessMate do
         chess = ChessMate.new
         expect(chess.board).to eql(DEFAULT[:board])
         expect(chess.turn).to eql(DEFAULT[:turn])
-        expect(chess.promotable).to eql(DEFAULT[:promotable])
+        expect(chess.promotable).to eql(nil)
         expect(chess.en_passant).to eql(DEFAULT[:en_passant])
         expect(chess.castling).to eql(DEFAULT[:castling])
         expect(chess.in_check).to eql(DEFAULT[:in_check])
@@ -356,6 +356,21 @@ describe ChessMate do
       )
     end
 
+    it 'should return false if there is a promotable pawn on the board' do
+      board = [
+        ['WP', nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        ['WP', nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil]
+      ]
+      chess = ChessMate.new(board: board, promotable: [0, 0])
+      expect(chess.move('a2', 'a3')).to eql(false)
+    end
+
     context 'for pawns' do
       it 'should update the board if pawn move is valid' do
         @chess.move('c2', 'c3')
@@ -1357,27 +1372,27 @@ describe ChessMate do
   end
 
   describe 'promote? method' do
-    it 'should return true if white piece is on last rank' do
+    it 'should return true if white piece is moving to last rank' do
       board = Array.new(8) { Array.new(8, nil) }
-      board[0][0] = 'WP'
+      board[1][0] = 'WP'
       chess = ChessMate.new(board: board)
-      expect(chess.promote?([0, 0])).to eql(true)
+      expect(chess.promote?([1, 0])).to eql(true)
     end
 
-    it 'should return true if black piece is on last rank' do
+    it 'should return true if black piece is moving to last rank' do
       board = Array.new(8) { Array.new(8, nil) }
-      board[7][0] = 'BP'
+      board[6][0] = 'BP'
       chess = ChessMate.new(board: board)
-      expect(chess.promote?([7, 0])).to eql(true)
+      expect(chess.promote?([6, 0])).to eql(true)
     end
 
     it 'should return false otherwise' do
       board = Array.new(8) { Array.new(8, nil) }
-      board[1][0] = 'WP'
-      board[6][0] = 'BP'
+      board[2][0] = 'WP'
+      board[5][0] = 'BP'
       chess = ChessMate.new(board: board)
-      expect(chess.promote?([1, 0])).to eql(false)
-      expect(chess.promote?([6, 0])).to eql(false)
+      expect(chess.promote?([2, 0])).to eql(false)
+      expect(chess.promote?([5, 0])).to eql(false)
     end
   end
 
@@ -1399,8 +1414,9 @@ describe ChessMate do
     context 'should promote to' do
       before :each do
         board = Array.new(8) { Array.new(8, nil) }
-        board[0][0] = 'WP'
+        board[1][0] = 'WP'
         @chess = ChessMate.new(board: board)
+        @chess.move('a7', 'a8')
       end
 
       it 'queen' do
@@ -1423,6 +1439,25 @@ describe ChessMate do
         expect(@chess.board[0][0]).to eql('WR')
       end
     end
+
+    context 'logging' do
+      it 'should correctly handle logging promotion' do
+        board = [
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          ['WP', nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil],
+          [nil, nil, nil, nil, nil, nil, nil, nil]
+        ]
+        chess = ChessMate.new(board: board)
+        chess.move('a7', 'a8')
+        chess.promote!([0, 0], 'queen')
+        expect(chess.move_history[-1]).to eql('a8=(Q)')
+      end
+    end
   end
 
   describe 'en_passant method' do

data/spec/logger_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../lib/helpers/logger'
+require 'chessmate'
+
+describe 'Logger' do
+  before :each do
+    @normal_moves_board = [
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      ['WP', 'WN', 'WB', 'WQ', 'WK', nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil]
+    ]
+
+    @capture_moves_board = [
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, 'WP', 'BP'],
+      ['BP', nil, nil, nil, nil, nil, nil, nil],
+      [nil, 'BP', nil, 'BP', nil, nil, nil, nil],
+      ['WP', 'WN', 'WB', 'WQ', 'WK', nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil]
+    ]
+
+    @ambiguous_moves_board = [
+      [nil, nil, nil, 'BR', nil, nil, nil, 'BR'],
+      ['BB', nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, 'BB', nil, nil, nil, nil],
+      ['WR', nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, 'WQ', nil, nil, 'WQ'],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      ['WR', nil, nil, nil, nil, nil, nil, 'WQ']
+    ]
+
+    @specialty_moves_board = [
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      ['WP', nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      ['WR', nil, nil, nil, 'WK', nil, nil, 'WR']
+    ]
+
+    @check_board = [
+      [nil, nil, nil, 'BQ', nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, nil, nil, nil, nil, nil],
+      ['BN', nil, nil, nil, nil, nil, nil, nil],
+      [nil, nil, nil, 'WP', nil, 'WP', nil, nil],
+      [nil, nil, nil, 'WR', 'WK', 'WR', nil, nil]
+    ]
+  end
+
+  context 'pawn moves' do
+    it 'should log normal pawn moves' do
+      logger = Logger.new([6, 0], [5, 0], @normal_moves_board)
+      expect(logger.log_move).to eql('a3')
+    end
+
+    it 'should log capturing moves' do
+      logger = Logger.new([6, 0], [5, 1], @capture_moves_board)
+      expect(logger.log_move).to eql('axb3')
+    end
+
+    it 'should log en passant moves' do
+      logger = Logger.new([3, 6], [2, 7], @capture_moves_board, en_passant: true)
+      expect(logger.log_move).to eql('gxh6')
+    end
+  end
+
+  context 'knight moves' do
+    it 'should log normal knight moves' do
+      logger = Logger.new([6, 1], [4, 0], @normal_moves_board)
+      expect(logger.log_move).to eql('Na4')
+    end
+
+    it 'should log capturing moves' do
+      logger = Logger.new([6, 1], [4, 0], @capture_moves_board)
+      expect(logger.log_move).to eql('Nxa4')
+    end
+  end
+
+  context 'bishop moves' do
+    it 'should log normal bishop moves' do
+      logger = Logger.new([6, 2], [5, 1], @normal_moves_board)
+      expect(logger.log_move).to eql('Bb3')
+    end
+
+    it 'should log capturing moves' do
+      logger = Logger.new([6, 2], [5, 1], @capture_moves_board)
+      expect(logger.log_move).to eql('Bxb3')
+    end
+  end
+
+  context 'queen moves' do
+    it 'should log normal queen moves' do
+      logger = Logger.new([6, 3], [5, 3], @normal_moves_board)
+      expect(logger.log_move).to eql('Qd3')
+    end
+
+    it 'should log capturing moves' do
+      logger = Logger.new([6, 3], [5, 3], @capture_moves_board)
+      expect(logger.log_move).to eql('Qxd3')
+    end
+  end
+
+  context 'king moves' do
+    it 'should log normal king moves' do
+      logger = Logger.new([6, 4], [5, 4], @normal_moves_board)
+      expect(logger.log_move).to eql('Ke3')
+    end
+
+    it 'should log capturing moves' do
+      logger = Logger.new([6, 4], [5, 3], @capture_moves_board)
+      expect(logger.log_move).to eql('Kxd3')
+    end
+  end
+
+  context 'ambiguous moves' do
+    it 'should add file info to log moves with pieces in same file' do
+      logger = Logger.new([7, 0], [5, 0], @ambiguous_moves_board)
+      expect(logger.log_move).to eql('R1a3')
+    end
+
+    it 'should add rank info to log moves with pieces in same rank' do
+      logger = Logger.new([0, 3], [0, 5], @ambiguous_moves_board)
+      expect(logger.log_move).to eql('Rdf8')
+    end
+
+    it 'should add file and rank info to log moves with multiple pieces in same file and rank' do
+      logger = Logger.new([4, 7], [7, 4], @ambiguous_moves_board)
+      expect(logger.log_move).to eql('Qh4e1')
+    end
+
+    it 'should handle knights/bishops/queens with ability to move to dest square' do
+      logger = Logger.new([2, 3], [0, 1], @ambiguous_moves_board)
+      expect(logger.log_move).to eql('Bdb8')
+    end
+  end
+
+  context 'specialty moves' do
+    it 'should log kingside castles' do
+      logger = Logger.new([7, 4], [7, 6], @specialty_moves_board)
+      expect(logger.log_move).to eql('0-0')
+    end
+
+    it 'should log queenside castles' do
+      logger = Logger.new([7, 4], [7, 2], @specialty_moves_board)
+      expect(logger.log_move).to eql('0-0-0')
+    end
+
+    it 'should log pawn promotion' do
+      %w[R N B Q].each do |piece|
+        logger = Logger.new(nil, nil, nil, promotion_type: piece)
+        expect(logger.log_promotion).to eql("=(#{piece})")
+      end
+    end
+  end
+
+  context 'game status indications' do
+    it 'should log check' do
+      logger = Logger.new([5, 0], [6, 2], @check_board)
+      expect(logger.log_move).to eql('Nc2+')
+    end
+
+    it 'should log checkmate' do
+      logger = Logger.new([0, 3], [0, 4], @check_board)
+      expect(logger.log_move).to eql('Qe8#')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chessmate
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Tyler Porter
@@ -42,16 +42,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.49.0
+        version: 0.75.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.49.0
+        version: 0.75.1
 - !ruby/object:Gem::Dependency
   name: deep_dup
   requirement: !ruby/object:Gem::Requirement
@@ -72,10 +72,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
+- LICENSE
+- README.md
 - lib/chessmate.rb
 - lib/helpers/default.rb
+- lib/helpers/logger.rb
 - lib/helpers/notation_parser.rb
 - lib/pieces/bishop.rb
 - lib/pieces/king.rb
@@ -84,7 +88,9 @@ files:
 - lib/pieces/piece.rb
 - lib/pieces/queen.rb
 - lib/pieces/rook.rb
+- pre-commit.sh
 - spec/chessmate_spec.rb
+- spec/logger_spec.rb
 - spec/notation_parser_spec.rb
 - spec/piece_spec.rb
 - spec/spec_helper.rb
@@ -108,8 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Chess for Rails