From 3f5bc58312b9046754b6e2728409c3e3a3034ae4 Mon Sep 17 00:00:00 2001 From: Benjamin Schaaf Date: Sun, 3 Jun 2018 19:19:00 +1000 Subject: [PATCH] Consolidated #padd_teams methods into Algorithm::Util and deprecated the other usages. --- .../algorithm/single_bracket.rb | 13 ++++--- lib/tournament_system/algorithm/util.rb | 26 +++++++++++++- lib/tournament_system/round_robin.rb | 2 +- lib/tournament_system/single_elimination.rb | 2 +- .../algorithm/single_bracket_spec.rb | 16 --------- spec/tournament/algorithm/util_spec.rb | 34 ++++++++++++++----- 6 files changed, 58 insertions(+), 35 deletions(-) diff --git a/lib/tournament_system/algorithm/single_bracket.rb b/lib/tournament_system/algorithm/single_bracket.rb index 849968c..c61dd62 100644 --- a/lib/tournament_system/algorithm/single_bracket.rb +++ b/lib/tournament_system/algorithm/single_bracket.rb @@ -45,15 +45,14 @@ def guess_round(teams_count, matches_count) round.to_i end - # Padd an array of teams to the next highest power of 2. - # - # @param teams [Array] - # @return [Array] + # @deprecated Please use {Util.padd_teams_pow2} instead. def padd_teams(teams) - required = max_teams(total_rounds(teams.length)) + message = 'NOTE: padd_teams is now deprecated in favour of Util.padd_teams_even.'\ + 'It will be removed in the next major version'\ + "SingleBracket.padd_teams called from #{Gem.location_of_caller.join(':')}" + warn message unless Gem::Deprecate.skip - # Insert the padding at the bottom to give top teams byes first - Array.new(required) { |index| teams[index] } + Util.padd_teams_pow2(teams) end # Seed teams for a single bracket tournament. diff --git a/lib/tournament_system/algorithm/util.rb b/lib/tournament_system/algorithm/util.rb index 9814c98..16ce011 100644 --- a/lib/tournament_system/algorithm/util.rb +++ b/lib/tournament_system/algorithm/util.rb @@ -5,11 +5,21 @@ module Algorithm module Util extend self + # @deprecated Please use {#padd_teams_even} instead. + def padd_teams(teams) + message = 'NOTE: padd_teams is now deprecated in favour of padd_teams_even. '\ + 'It will be removed in the next major version.'\ + "Util.padd_teams called from #{Gem.location_of_caller.join(':')}" + warn message unless Gem::Deprecate.skip + + padd_teams_even(teams) + end + # Padd an array of teams to be even. # # @param teams [Array] # @return [Array] - def padd_teams(teams) + def padd_teams_even(teams) if teams.length.odd? teams + [nil] else @@ -17,6 +27,20 @@ def padd_teams(teams) end end + # pow2 is not uncommunicative + # :reek:UncommunicativeMethodName + + # Padd an array of teams to the next power of 2. + # + # @param teams [Array] + # @return [Array] + def padd_teams_pow2(teams) + # Get the next power of 2 + required = 2**Math.log2(teams.length).ceil + + Array.new(required) { |index| teams[index] } + end + # Padd the count of teams to be even. # # @example diff --git a/lib/tournament_system/round_robin.rb b/lib/tournament_system/round_robin.rb index b71ba22..ec24897 100644 --- a/lib/tournament_system/round_robin.rb +++ b/lib/tournament_system/round_robin.rb @@ -14,7 +14,7 @@ module RoundRobin def generate(driver, options = {}) round = options[:round] || guess_round(driver) - teams = Algorithm::Util.padd_teams(driver.seeded_teams) + teams = Algorithm::Util.padd_teams_even(driver.seeded_teams) matches = Algorithm::RoundRobin.round_robin_pairing(teams, round) diff --git a/lib/tournament_system/single_elimination.rb b/lib/tournament_system/single_elimination.rb index fe89961..b060042 100644 --- a/lib/tournament_system/single_elimination.rb +++ b/lib/tournament_system/single_elimination.rb @@ -14,7 +14,7 @@ def generate(driver, _options = {}) round = guess_round(driver) teams = if driver.matches.empty? - padded = Algorithm::SingleBracket.padd_teams driver.seeded_teams + padded = Algorithm::Util.padd_teams_pow2 driver.seeded_teams Algorithm::SingleBracket.seed padded else last_matches = previous_round_matches driver, round diff --git a/spec/tournament/algorithm/single_bracket_spec.rb b/spec/tournament/algorithm/single_bracket_spec.rb index 913af05..670e442 100644 --- a/spec/tournament/algorithm/single_bracket_spec.rb +++ b/spec/tournament/algorithm/single_bracket_spec.rb @@ -55,22 +55,6 @@ def gen_teams(num) end end - describe '#padd_teams' do - it 'works' do - expect(described_class.padd_teams(gen_teams(2))).to eq([1, 2]) - expect(described_class.padd_teams(gen_teams(3))).to eq([1, 2, 3, nil]) - expect(described_class.padd_teams(gen_teams(4))).to eq([1, 2, 3, 4]) - expect(described_class.padd_teams(gen_teams(5))) - .to eq([1, 2, 3, 4, 5, nil, nil, nil]) - expect(described_class.padd_teams(gen_teams(6))) - .to eq([1, 2, 3, 4, 5, 6, nil, nil]) - expect(described_class.padd_teams(gen_teams(7))) - .to eq([1, 2, 3, 4, 5, 6, 7, nil]) - expect(described_class.padd_teams(gen_teams(8))) - .to eq([1, 2, 3, 4, 5, 6, 7, 8]) - end - end - describe '#seed' do it 'works for powers of 2' do expect(described_class.seed(gen_teams(2))).to eq([1, 2]) diff --git a/spec/tournament/algorithm/util_spec.rb b/spec/tournament/algorithm/util_spec.rb index e1fd195..93216e2 100644 --- a/spec/tournament/algorithm/util_spec.rb +++ b/spec/tournament/algorithm/util_spec.rb @@ -5,29 +5,45 @@ def gen_teams(num) (1..num).to_a.freeze end - describe '#padd_teams' do + describe '#padd_teams_even' do it 'works for even teams' do - expect(described_class.padd_teams(gen_teams(2))).to eq((1..2).to_a) - expect(described_class.padd_teams(gen_teams(4))).to eq((1..4).to_a) - expect(described_class.padd_teams(gen_teams(6))).to eq((1..6).to_a) - expect(described_class.padd_teams(gen_teams(8))).to eq((1..8).to_a) + expect(described_class.padd_teams_even(gen_teams(2))).to eq((1..2).to_a) + expect(described_class.padd_teams_even(gen_teams(4))).to eq((1..4).to_a) + expect(described_class.padd_teams_even(gen_teams(6))).to eq((1..6).to_a) + expect(described_class.padd_teams_even(gen_teams(8))).to eq((1..8).to_a) end it 'works for odd teams' do - expect(described_class.padd_teams(gen_teams(3))) + expect(described_class.padd_teams_even(gen_teams(3))) .to eq((1..3).to_a + [nil]) - expect(described_class.padd_teams(gen_teams(5))) + expect(described_class.padd_teams_even(gen_teams(5))) .to eq((1..5).to_a + [nil]) - expect(described_class.padd_teams(gen_teams(7))) + expect(described_class.padd_teams_even(gen_teams(7))) .to eq((1..7).to_a + [nil]) - expect(described_class.padd_teams(gen_teams(9))) + expect(described_class.padd_teams_even(gen_teams(9))) .to eq((1..9).to_a + [nil]) end end + describe '#padd_teams_pow2' do + it 'works' do + expect(described_class.padd_teams_pow2(gen_teams(2))).to eq([1, 2]) + expect(described_class.padd_teams_pow2(gen_teams(3))).to eq([1, 2, 3, nil]) + expect(described_class.padd_teams_pow2(gen_teams(4))).to eq([1, 2, 3, 4]) + expect(described_class.padd_teams_pow2(gen_teams(5))) + .to eq([1, 2, 3, 4, 5, nil, nil, nil]) + expect(described_class.padd_teams_pow2(gen_teams(6))) + .to eq([1, 2, 3, 4, 5, 6, nil, nil]) + expect(described_class.padd_teams_pow2(gen_teams(7))) + .to eq([1, 2, 3, 4, 5, 6, 7, nil]) + expect(described_class.padd_teams_pow2(gen_teams(8))) + .to eq([1, 2, 3, 4, 5, 6, 7, 8]) + end + end + describe '#padded_teams_count' do it 'works for even numbers' do expect(described_class.padded_teams_count(2)).to eq(2)