tournament-system 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52196b11f89aad9f8e4dbf67094ba9e99dff805e6d7d95dc840213d802bfb511
-  data.tar.gz: 739375eaad6f1093c3e47ec6e630ea1394670582f1f6e84d85917327bc30358e
+  metadata.gz: 9917e1eba50ce274c68fd9dc17d30ce7545667e09be47ddad077b46841446bfb
+  data.tar.gz: 02a331c1672c1fc6265c8d28a813df74e96d89ec14a925f83f0a9ae4fdca69a2
 SHA512:
-  metadata.gz: 80e6f521ef7293504a69d2d0287200d535ce5833cbbc4d78c60878de30d18f1862aea1101460e9aeac0c396d18818c5a199764a875bcebbbc6298b8ab5f30ae3
-  data.tar.gz: 88b4831a41dea4acce69ffcde2e10eed2edbb5ec5a435c9d97b47fb5aad85e24beffb3aa76a809eadca053769c354611798edac2e79dd57382145c256d0d517a
+  metadata.gz: 423871fd41ae8c97d16cca8a55999f97325b8e208c7a964cdd2202b241af9dc59dc2332c195f05ce956045123786b6c5ebe3483639e378d2763cf1aeed51417c
+  data.tar.gz: 64ab7e6df86f5614a1912d741be1642e7031208ccb0fa99430afd761b9f995f5dcc167fb647e7d25cd2594264620af011bf9d8b9230a6c3aa0564c112cebbd24

data/.rubocop.yml

@@ -1,14 +1,10 @@
 AllCops:
   DisplayCopNames: true
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.5
 
 Metrics/LineLength:
   Max: 120
 
-# This is fine, really
-Naming/FileName:
-  Enabled: false
-
 # 'old' style
 Style/EmptyMethod:
   EnforcedStyle: expanded
@@ -17,7 +13,7 @@ Style/EmptyMethod:
 Bundler/OrderedGems:
   Enabled: false
 
-# Not interchangeable
+# `module_function` and `extend self` aren't actually interchangeable
 Style/ModuleFunction:
   Enabled: false
 
@@ -26,8 +22,11 @@ Style/FrozenStringLiteralComment:
   Enabled: false
 
 # Doesn't really make sense for multiline
-Style/TrailingCommaInLiteral:
-  Enabled: false
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
 
 # Tests should be as long as they need to be
 Metrics/BlockLength:

data/Gemfile

@@ -12,7 +12,7 @@ gem 'rspec'
 gem 'simplecov'
 
 # Linting
-gem 'rubocop', '~> 0.52.1'
+gem 'rubocop', '~> 0.56.0'
 gem 'reek'
 
 group :test do

data/README.md

@@ -87,7 +87,7 @@ TournamentSystem::RoundRobin.generate driver
 # Generate a round for a swiss system tournament, pushing byes to the bottom
 #  half (bottom half teams will bye before the top half)
 TournamentSystem::Swiss.generate driver, pairer: TournamentSystem::Swiss::Dutch,
-                                   pair_options: { push_byes_to: :bottom_half }
+                                         pair_options: { push_byes_to: :bottom_half }
 
 # Alternatively use the accelerated swiss system
 TournamentSystem::Swiss.generate driver, pairer: TournamentSystem::Swiss::AcceleratedDutch

data/lib/tournament_system.rb

@@ -5,6 +5,7 @@ require 'tournament_system/swiss'
 require 'tournament_system/round_robin'
 require 'tournament_system/page_playoff'
 require 'tournament_system/single_elimination'
+require 'tournament_system/double_elimination'
 
 # This library is split into two parts, there's the actual algorithms that implement various tournament systems
 # ({Algorithm}) and a data abstraction layer for generating matches using various tournament systems in a

data/lib/tournament_system/algorithm/double_bracket.rb

@@ -0,0 +1,129 @@
+require 'ostruct'
+
+module TournamentSystem
+  module Algorithm
+    # This module provides algorithms for dealing with double bracket elimination tournaments.
+    module DoubleBracket
+      extend self
+
+      # Get the number of rounds required for a double bracket tournament.
+      #
+      # @param teams_count [Number]
+      # @return [Number]
+      def total_rounds(teams_count)
+        Math.log2(teams_count).ceil * 2
+      end
+
+      # Get the maximum number of teams that can be processed in the given number of rounds.
+      #
+      # @param rounds [Number]
+      # @return [Number]
+      def max_teams(rounds)
+        2**(rounds / 2)
+      end
+
+      # Guess the next round number given the number of teams and matches played so far.
+      # Due to the complexity of double elimination, this practically runs through the tournament one round at a time,
+      # but is still faster as it only handles numbers and not concrete teams.
+      #
+      # @param teams_count [Number]
+      # @param matches_count [Number]
+      # @return [Number]
+      # @raise [ArgumentError] when the number of matches does not add up
+      def guess_round(teams_count, matches_count)
+        counting_state = OpenStruct.new(winners: teams_count, losers: 0)
+
+        round_number = count_iterations do |round|
+          round_size = count_round(round, counting_state)
+
+          next false if round_size > matches_count || round_size.zero?
+
+          matches_count -= round_size
+        end
+
+        raise ArgumentError, "Invalid number of matches, was off by #{matches_count}" unless matches_count.zero?
+
+        round_number
+      end
+
+      # Determines whether a given round is a minor round, ie. the top and bottom bracket have a round.
+      # Use this in combination with {#major_round?} to determine the type of round.
+      # The first round is neither minor nor major.
+      #
+      # @param round [Number]
+      # @return [Boolean]
+      def minor_round?(round)
+        round.odd?
+      end
+
+      # Determines whether a given round is a major round, ie. only the bottom bracket has a round.
+      # Use this in combination with {#minor_round?} to determine the type of round.
+      # The first round is neither major nor minor.
+      #
+      # @param round [Number]
+      # @return [Boolean]
+      def major_round?(round)
+        round.even? && round.positive?
+      end
+
+      # Seed the given teams for a double bracket tournament. Identical to {SingleBracket#seed}.
+      #
+      # @param teams [Array<team>]
+      # @return [Array<team>]
+      def seed(teams)
+        SingleBracket.seed(teams)
+      end
+
+      private
+
+      # Handle state transition for a round. Counts the number of winners and losers.
+      #
+      # @return [Number] the number of matches played this round.
+      def count_round(round, state)
+        if minor_round? round
+          count_minor_round(state)
+        elsif major_round? round
+          count_major_round(state)
+        else
+          count_first_round(state)
+        end
+      end
+
+      # @return [Number] the number of matches played this round.
+      def count_minor_round(state)
+        winner_matches = state.winners / 2
+        state.winners -= winner_matches
+
+        loser_matches = state.losers / 2
+        state.losers += winner_matches - loser_matches
+
+        winner_matches + loser_matches
+      end
+
+      # @return [Number] the number of matches played this round.
+      def count_major_round(state)
+        matches = state.losers / 2
+        state.losers -= matches
+        matches
+      end
+
+      # @return [Number] the number of matches played this round.
+      def count_first_round(state)
+        winners = state.winners
+        padded_teams = Util.padded_teams_pow2_count(winners)
+
+        matches = winners - padded_teams / 2
+        state.winners -= matches
+        state.losers += matches
+        matches
+      end
+
+      # Count the number of iterations until the block returns false.
+      def count_iterations
+        counter = 0
+        counter += 1 while (yield counter) != false
+        counter
+      end
+    end
+  end
+end

data/lib/tournament_system/algorithm/round_robin.rb

@@ -14,7 +14,7 @@ module TournamentSystem
       # @param teams_count [Integer] the number of teams
       # @return [Integer] number of rounds needed for round robin
       def total_rounds(teams_count)
-        Util.padded_teams_count(teams_count) - 1
+        Util.padded_teams_even_count(teams_count) - 1
       end
 
       # Guess the next round (starting at 0) for round robin.
@@ -23,7 +23,7 @@ module TournamentSystem
       # @param matches_count [Integer] the number of existing matches
       # @return [Integer] next round number
       def guess_round(teams_count, matches_count)
-        matches_count / (Util.padded_teams_count(teams_count) / 2)
+        matches_count / (Util.padded_teams_even_count(teams_count) / 2)
       end
 
       # Rotate array using round robin.

data/lib/tournament_system/algorithm/single_bracket.rb

@@ -2,8 +2,7 @@ require 'ostruct'
 
 module TournamentSystem
   module Algorithm
-    # This module provides algorithms for dealing with single bracket
-    # elimination tournament systems.
+    # This module provides algorithms for dealing with single bracket elimination tournament systems.
     module SingleBracket
       extend self
 
@@ -45,15 +44,14 @@ module TournamentSystem
         round.to_i
       end
 
-      # Padd an array of teams to the next highest power of 2.
-      #
-      # @param teams [Array<team>]
-      # @return [Array<team, nil>]
+      # @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.

data/lib/tournament_system/algorithm/util.rb

@@ -5,11 +5,21 @@ module TournamentSystem
     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<team>]
       # @return [Array<team, nil>]
-      def padd_teams(teams)
+      def padd_teams_even(teams)
         if teams.length.odd?
           teams + [nil]
         else
@@ -17,17 +27,51 @@ module TournamentSystem
         end
       end
 
+      # @deprecated Please use {#padded_teams_even_count}
+      def padded_teams_count(teams_count)
+        message = 'Node: padded_teams_count is now deprecated in favour of padded_teams_even_count. '\
+                  'It will be removed in the next major version.'\
+                  "Util.padded_teams_count called from #{Gem.location_of_caller.join(':')}"
+        warn message unless Gem::Deprecate.skip
+
+        padded_teams_even_count(teams_count)
+      end
+
       # Padd the count of teams to be even.
       #
       # @example
-      #   padded_teams_count(teams.length/) == padd_teams(teams).length
+      #   padded_teams_even_count(teams.length) == padd_teams_even(teams).length
       #
       # @param teams_count [Integer] the number of teams
       # @return [Integer]
-      def padded_teams_count(teams_count)
+      def padded_teams_even_count(teams_count)
         (teams_count / 2.0).ceil * 2
       end
 
+      # pow2 is not uncommunicative
+      # :reek:UncommunicativeMethodName
+
+      # Padd an array of teams to the next power of 2.
+      #
+      # @param teams [Array<team>]
+      # @return [Array<team, nil>]
+      def padd_teams_pow2(teams)
+        required = padded_teams_pow2_count(teams.length)
+
+        Array.new(required) { |index| teams[index] }
+      end
+
+      # Padd the count of teams to be a power of 2.
+      #
+      # @example
+      #   padded_teams_pow2_count(teams.length) == padd_teams_pow2(teams).length
+      #
+      # @param teams_count [Integer] the number of teams
+      # @return [Integer]
+      def padded_teams_pow2_count(teams_count)
+        2**Math.log2(teams_count).ceil
+      end
+
       # rubocop:disable Metrics/MethodLength
 
       # Collect all values in an array with a minimum value.

data/lib/tournament_system/double_elimination.rb

@@ -0,0 +1,63 @@
+require 'tournament_system/algorithm/double_bracket'
+require 'tournament_system/algorithm/group_pairing'
+
+module TournamentSystem
+  # Implements the double bracket elimination tournament system.
+  module DoubleElimination
+    extend self
+
+    # Generate matches with the given driver
+    #
+    # @param driver [Driver]
+    # @return [nil]
+    def generate(driver, _options = {})
+      round = guess_round driver
+
+      teams_padded = Algorithm::Util.padd_teams_pow2 driver.seeded_teams
+      teams_seeded = Algorithm::DoubleBracket.seed teams_padded
+
+      teams = if driver.matches.empty?
+                teams_seeded
+              else
+                get_round_teams driver, round, teams_seeded
+              end
+
+      driver.create_matches Algorithm::GroupPairing.adjacent(teams)
+    end
+
+    # The total number of rounds needed for a single elimination tournament with
+    # the given driver.
+    #
+    # @param driver [Driver]
+    # @return [Integer]
+    def total_rounds(driver)
+      Algorithm::DoubleBracket.total_rounds(driver.seeded_teams.length)
+    end
+
+    # Guess the next round number (starting at 0) from the state in driver.
+    #
+    # @param driver [Driver]
+    # @return [Integer]
+    def guess_round(driver)
+      Algorithm::DoubleBracket.guess_round(driver.seeded_teams.length,
+                                           driver.non_bye_matches .length)
+    end
+
+    private
+
+    def get_round_teams(driver, round, teams_seeded)
+      loss_counts = driver.loss_count_hash
+
+      winners = teams_seeded.select { |team| loss_counts[team].zero? }
+      losers  = teams_seeded.select { |team| loss_counts[team] == 1 }
+
+      if Algorithm::DoubleBracket.minor_round?(round)
+        winners + losers
+      elsif Algorithm::DoubleBracket.major_round?(round)
+        losers
+      else
+        winners
+      end
+    end
+  end
+end

data/lib/tournament_system/driver.rb

@@ -1,5 +1,5 @@
 module TournamentSystem
-  # :reek:UnusedParameters
+  # :reek:UnusedParameters :reek:TooManyMethods
 
   # An interface for external tournament data.
   #
@@ -159,6 +159,21 @@ module TournamentSystem
       get_match_teams(match).reject { |team| team == winner }.first
     end
 
+    # Determine whether a specific match was a bye? By default uses {#get_match_teams} to determine a bye. Override if
+    # you have better access to this information.
+    #
+    # @return [Boolean]
+    def match_bye?(match)
+      get_match_teams(match).include?(nil)
+    end
+
+    # Get a list of matches that weren't byes. Used by tournament systems.
+    #
+    # @return [Array<match>]
+    def non_bye_matches
+      matches.reject { |match| match_bye?(match) }
+    end
+
     # Get a hash of unique team pairs and their number of occurences. Used by tournament systems.
     #
     # @return [Hash{Set(team, team) => Integer}]
@@ -199,10 +214,10 @@ module TournamentSystem
     # Create a bunch of matches. Used by tournament systems.
     # @see #create_match
     #
-    # @param matches [Array<Array(team, team)>] a collection of pairs
+    # @param pairs [Array<Array(team, team)>] a collection of pairs
     # @return [nil]
-    def create_matches(matches)
-      matches.each do |home_team, away_team|
+    def create_matches(pairs)
+      pairs.each do |home_team, away_team|
         create_match(home_team, away_team)
       end
     end
@@ -211,8 +226,14 @@ module TournamentSystem
     #
     # @return [Hash{team => Number}] a mapping from teams to scores
     def scores_hash
-      @scores_hash = ranked_teams.map { |team| [team, get_team_score(team)] }
-                                 .to_h
+      @scores_hash ||= ranked_teams.map { |team| [team, get_team_score(team)] }.to_h
+    end
+
+    # Get a hash of the number of losses of each team. Used by tournament systems.
+    #
+    # @return [Hash{team => Number}] a mapping from teams to losses
+    def loss_count_hash
+      @loss_count_hash ||= matches.each_with_object(Hash.new(0)) { |match, hash| hash[get_match_loser(match)] += 1 }
     end
 
     private

data/lib/tournament_system/page_playoff.rb

@@ -27,6 +27,9 @@ module TournamentSystem
       end
     end
 
+    # Rubocop doesn't handle _ as a parameter sink
+    # rubocop:disable Naming/UncommunicativeMethodParamName
+
     # The total number of rounds in a page playoff tournament
     #
     # @param _ for keeping the same interface as other tournament systems.
@@ -35,6 +38,8 @@ module TournamentSystem
       Algorithm::PagePlayoff::TOTAL_ROUNDS
     end
 
+    # rubocop:enable Naming/UncommunicativeMethodParamName
+
     # Guess the next round number (starting at 0) from the state in a driver.
     #
     # @param driver [Driver]

data/lib/tournament_system/round_robin.rb

@@ -14,7 +14,7 @@ module TournamentSystem
     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)
 

data/lib/tournament_system/single_elimination.rb

@@ -14,7 +14,7 @@ module TournamentSystem
       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

data/lib/tournament_system/version.rb

@@ -1,4 +1,4 @@
 module TournamentSystem
   # The current version of this gem.
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.1.0'.freeze
 end

data/tournament-system.gemspec

@@ -1,4 +1,4 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'tournament_system/version'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tournament-system
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Benjamin Schaaf
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-31 00:00:00.000000000 Z
+date: 2018-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graph_matching
@@ -56,6 +56,7 @@ files:
 - Rakefile
 - lib/tournament_system.rb
 - lib/tournament_system/algorithm.rb
+- lib/tournament_system/algorithm/double_bracket.rb
 - lib/tournament_system/algorithm/group_pairing.rb
 - lib/tournament_system/algorithm/matching.rb
 - lib/tournament_system/algorithm/page_playoff.rb
@@ -63,6 +64,7 @@ files:
 - lib/tournament_system/algorithm/single_bracket.rb
 - lib/tournament_system/algorithm/swiss.rb
 - lib/tournament_system/algorithm/util.rb
+- lib/tournament_system/double_elimination.rb
 - lib/tournament_system/driver.rb
 - lib/tournament_system/driver_proxy.rb
 - lib/tournament_system/page_playoff.rb
@@ -93,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Implements various tournament systems