Kata: Refactoring Tennis in Ruby

We practiced with the Refactoring Tennis kata in the last Barcelona Ruby meetup.

There were three different versions of the original code. I refactored the first one.

This is the original code:

	class TennisGame
	def initialize(player1_name, player2_name)
	@player1_name = player1_name
	@player2_name = player2_name
	@p1points = 0
	@p2points = 0
	end
	def won_point(player_name)
	if player_name == @player1_name
	@p1points += 1
	else
	@p2points += 1
	end
	end
	def score
	result = ""
	tempScore=0
	if (@p1points==@p2points)
	result = {
	0 => "Love-All",
	1 => "Fifteen-All",
	2 => "Thirty-All",
	}.fetch(@p1points, "Deuce")
	elsif (@p1points>=4 or @p2points>=4)
	minusResult = @p1points-@p2points
	if (minusResult==1)
	result ="Advantage " + @player1_name
	elsif (minusResult ==-1)
	result ="Advantage " + @player2_name
	elsif (minusResult>=2)
	result = "Win for " + @player1_name
	else
	result ="Win for " + @player2_name
	end
	else
	(1...3).each do |i|
	if (i==1)
	tempScore = @p1points
	else
	result+="-"
	tempScore = @p2points
	end
	result += {
	0 => "Love",
	1 => "Fifteen",
	2 => "Thirty",
	3 => "Forty",
	}[tempScore]
	end
	end
	result
	end
	end

view raw TennisGameOriginal.rb hosted with ❤ by GitHub

First, I tried to refactor the code to the State Pattern as I did once before in C++. Then I realized checking the tests that the code was not meant to model a real tennis game. It's just focused in displaying the current score.

So I decided to try to separate the code that was keeping the tennis game score from the code that was displaying its score. I also wanted to be able to display the score in different languages.

This is the resulting code after the refactoring:

	class TennisGame
	attr_reader :game_score, :score_displayer
	def initialize(game_score, score_displayer)
	@game_score = game_score
	@score_displayer = score_displayer
	end
	def won_point(player_name)
	game_score.won_point(player_name)
	end
	def score
	score_displayer.display(game_score)
	end
	end
	class GameScore
	attr_reader :first_player, :second_player
	def initialize(first_player, second_player)
	@first_player = first_player
	@second_player = second_player
	end
	def tied?
	first_player.points == second_player.points
	end
	def advantage_for_any_player?
	both_with_forty_or_more? and points_difference() == 1
	end
	def over?
	any_over_forty? and points_difference() >= 2
	end
	def won_point(player_name)
	if player_name == first_player.name
	first_player.won_point
	else
	second_player.won_point
	end
	end
	def current_winner
	first_player.points > second_player.points ? first_player : second_player
	end
	private
	def points_difference
	(first_player.points - second_player.points).abs
	end
	def both_with_forty_or_more?
	first_player.points >= 3 and second_player.points >= 3
	end
	def any_over_forty?
	first_player.points >= 4 or second_player.points >= 4
	end
	end
	class Player
	attr_reader :points, :name
	def initialize(name)
	@name = name
	@points = 0
	end
	def won_point
	@points += 1
	end
	end
	class ScoreDisplayer
	attr_accessor :vocabulary
	def initialize
	@vocabulary = GameVocabulary.new({
	:zero_all => "Love-All",
	:fifteen_all => "Fifteen-All",
	:thirty_all => "Thirty-All",
	:deuce => "Deuce",
	:zero => "Love",
	:fifteen => "Fifteen",
	:thirty => "Thirty",
	:forty => "Forty",
	:advantage => "Advantage",
	:game_over => "Win for"
	})
	end
	def display(game_score)
	if game_score.tied?
	display_tie(game_score.first_player)
	elsif game_score.over?
	display_game_over(game_score.current_winner())
	elsif game_score.advantage_for_any_player?
	display_advantage(game_score.current_winner())
	else
	display_default(game_score.first_player, game_score.second_player)
	end
	end
	def display_game_over(winner)
	@vocabulary.word_for(:game_over) + " " + winner.name
	end
	def display_advantage(player_with_advantage)
	@vocabulary.word_for(:advantage) + " " + player_with_advantage.name
	end
	def display_tie(any_player)
	key = {
	0 => :zero_all,
	1 => :fifteen_all,
	2 => :thirty_all,
	}.fetch(any_player.points, :deuce)
	@vocabulary.word_for(key)
	end
	def display_default(first_player, second_player)
	key_by_points = {
	0 => :zero,
	1 => :fifteen,
	2 => :thirty,
	3 => :forty,
	}
	@vocabulary.word_for(key_by_points[first_player.points]) +
	"-" +
	@vocabulary.word_for(key_by_points[second_player.points])
	end
	end
	class GameVocabulary
	def initialize(vocabulary)
	@vocabulary = vocabulary
	end
	def word_for(key)
	@vocabulary[key]
	end
	end

view raw TennisGameRefactored.rb hosted with ❤ by GitHub

The TennisGame has two collaborators: the GameScore and the ScoreDisplayer.

The GameScore keeps track of the two Players in order to answer questions about the game score, whereas the ScoreDisplayer is in charge of displaying the score.

By default the ScoreDisplayer uses an English GameVocabulary, but the GameVocabulary can be injected through its accessor in order to display the score a different language (check the tests to see how the score is displayed in Spanish).

You can check the code and its tests in this GitHub repository.

I also committed after every tiny refactoring step so you can follow the process (especially the changes of mind I had and the dead-ends I found).

This kata was a great puzzle to practise and think.

I'd like to thank David Vrensk for his great work facilitating the kata and the interesting talk about Deliberate Practice that he gave before.