tournament-system 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 864919bea23fd1e9fce67c2dd004acd1d27005e8
-  data.tar.gz: 57af40662e26b221a00e0425ba9f53ddd9277bfd
+SHA256:
+  metadata.gz: 52196b11f89aad9f8e4dbf67094ba9e99dff805e6d7d95dc840213d802bfb511
+  data.tar.gz: 739375eaad6f1093c3e47ec6e630ea1394670582f1f6e84d85917327bc30358e
 SHA512:
-  metadata.gz: 96f2de44135c43b48be3dad1e981d890518fdc936620047908e115b7b6fb46468a22b826fc3712b2dd27ebaf28e5ab2bfdd51185ebfd79fed7cb60fb73fcad5d
-  data.tar.gz: f7b53a6c95787e983273242ec1d15160a427a77728ff5ec9a7925669788d50d91b1ccafa3eecc218855c962ea6117c1133ae4e76d8e9a4f8bfae28e12c16f425
+  metadata.gz: 80e6f521ef7293504a69d2d0287200d535ce5833cbbc4d78c60878de30d18f1862aea1101460e9aeac0c396d18818c5a199764a875bcebbbc6298b8ab5f30ae3
+  data.tar.gz: 88b4831a41dea4acce69ffcde2e10eed2edbb5ec5a435c9d97b47fb5aad85e24beffb3aa76a809eadca053769c354611798edac2e79dd57382145c256d0d517a

data/.reek

@@ -14,3 +14,6 @@ DuplicateMethodCall:
 
 NestedIterators:
   max_allowed_nesting: 2
+
+TooManyMethods:
+  max_methods: 17

data/.rubocop.yml

@@ -6,7 +6,7 @@ Metrics/LineLength:
   Max: 120
 
 # This is fine, really
-Style/FileName:
+Naming/FileName:
   Enabled: false
 
 # 'old' style

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 cache: bundler
-rvm: 2.3.3
+rvm: 2.5.0
 # rainbow gem install script is broken
 before_install:
   - gem update --system

data/Gemfile

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

data/README.md

@@ -14,7 +14,7 @@ It is designed to easily fit into any memory model you might already have.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tournament-system', '~> 1.0.0'
+gem 'tournament-system', '~> 2'
 ```
 
 And then execute:
@@ -35,7 +35,7 @@ First you need to implement a driver to handle the interface between your data
 and the tournament systems:
 
 ```ruby
-class Driver < Tournament::Driver
+class Driver < TournamentSystem::Driver
   def matches
     ...
   end
@@ -60,12 +60,18 @@ class Driver < Tournament::Driver
     ...
   end
 
+  def get_team_matches(team)
+    ...
+  end
+
   def build_match(home_team, away_team)
     ...
   end
 end
 ```
 
+Check the docs on [`TournamentSystem::Driver`](http://www.rubydoc.info/github/ozfortress/tournament-system/master/Tournament/Driver) for more information.
+
 Then you can simply generate matches for any tournament system using a driver
 instance:
 
@@ -73,18 +79,21 @@ instance:
 driver = Driver.new
 
 # Generate a round of a single elimination tournament
-Tournament::SingleElimination.generate driver
+TournamentSystem::SingleElimination.generate driver
 
 # Generate a round for a round robin tournament
-Tournament::RoundRobin.generate driver
+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)
-Tournament::Swiss.generate driver, pairer: Tournament::Swiss::Dutch,
+TournamentSystem::Swiss.generate driver, pairer: TournamentSystem::Swiss::Dutch,
                                    pair_options: { push_byes_to: :bottom_half }
 
+# Alternatively use the accelerated swiss system
+TournamentSystem::Swiss.generate driver, pairer: TournamentSystem::Swiss::AcceleratedDutch
+
 # Generate a round for a page playoff system, with an optional bronze match
-Tournament::PagePlayoff.generate driver, bronze_match: true
+TournamentSystem::PagePlayoff.generate driver, bronze_match: true
 ```
 
 ## Contributing

data/Rakefile

@@ -9,5 +9,5 @@ RuboCop::RakeTask.new
 Reek::Rake::Task.new
 
 task default: :test
-task test: %w(rspec lint)
-task lint: %w(rubocop reek)
+task test: %w[rspec lint]
+task lint: %w[rubocop reek]

data/lib/tournament_system.rb

@@ -0,0 +1,25 @@
+require 'tournament_system/version'
+require 'tournament_system/driver'
+
+require 'tournament_system/swiss'
+require 'tournament_system/round_robin'
+require 'tournament_system/page_playoff'
+require 'tournament_system/single_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-independent way ({Driver}), along with matching implementations of tournament systems using drivers.
+#
+# TournamentSystem currently supports the following systems:
+#
+# * {https://en.wikipedia.org/wiki/Single-elimination_tournament Single elimination}
+#   ({TournamentSystem::SingleElimination})
+# * {https://en.wikipedia.org/wiki/Page_playoff_system Page playoffs} ({TournamentSystem::PagePlayoff})
+# * {https://en.wikipedia.org/wiki/Round-robin_tournament Round robin} ({TournamentSystem::RoundRobin})
+# * {https://en.wikipedia.org/wiki/Swiss-system_tournament Swiss-system} ({TournamentSystem::Swiss}) with support for
+#   multiple types of pairing systems:
+#
+#   * Dutch pairing (very popular) ({TournamentSystem::Swiss::Dutch})
+#   * Accelerated pairing (aka Accelerated swiss) ({TournamentSystem::Swiss::AcceleratedDutch})
+module TournamentSystem
+end

data/lib/{tournament → tournament_system}/algorithm.rb

@@ -1,6 +1,5 @@
-module Tournament
-  # This module provides abtraction-less implementations of all algorithms
-  # used for tournament systems.
+module TournamentSystem
+  # This module provides abtraction-less implementations of all algorithms used for tournament systems.
   module Algorithm
   end
 end

data/lib/{tournament → tournament_system}/algorithm/group_pairing.rb

@@ -1,4 +1,4 @@
-module Tournament
+module TournamentSystem
   module Algorithm
     # This module provides group pairing algorithms
     module GroupPairing

data/lib/{tournament → tournament_system}/algorithm/matching.rb

@@ -1,6 +1,6 @@
 require 'graph_matching'
 
-module Tournament
+module TournamentSystem
   module Algorithm
     # Implements graph matching algorithms for tournament systems.
     module Matching
@@ -41,7 +41,7 @@ module Tournament
           end
         end
       end
-      # rubbocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/MethodLength
 
       # Performs maximum weight perfect matching of a undirected complete graph composed of the given vertices.
       #

data/lib/{tournament → tournament_system}/algorithm/page_playoff.rb

@@ -1,4 +1,4 @@
-module Tournament
+module TournamentSystem
   module Algorithm
     # This module provides algorithms for dealing with the page playoff system.
     module PagePlayoff

data/lib/{tournament → tournament_system}/algorithm/round_robin.rb

@@ -1,7 +1,7 @@
-require 'tournament/algorithm/util'
-require 'tournament/algorithm/group_pairing'
+require 'tournament_system/algorithm/util'
+require 'tournament_system/algorithm/group_pairing'
 
-module Tournament
+module TournamentSystem
   module Algorithm
     # This module provides algorithms for dealing with round robin tournament
     # systems.

data/lib/{tournament → tournament_system}/algorithm/single_bracket.rb

@@ -1,6 +1,6 @@
 require 'ostruct'
 
-module Tournament
+module TournamentSystem
   module Algorithm
     # This module provides algorithms for dealing with single bracket
     # elimination tournament systems.
@@ -36,15 +36,11 @@ module Tournament
         total_teams = max_teams(rounds)
 
         # Make sure we don't have too many matches
-        unless total_teams >= matches_count
-          raise ArgumentError, 'Too many matches'
-        end
+        raise ArgumentError, 'Too many matches' unless total_teams >= matches_count
 
         round = rounds - Math.log2(total_teams - matches_count)
-        unless (round % 1).zero?
-          # Make sure we don't have some weird number of matches
-          raise ArgumentError, 'Invalid number of matches'
-        end
+        # Make sure we don't have some weird number of matches
+        raise ArgumentError, 'Invalid number of matches' unless (round % 1).zero?
 
         round.to_i
       end
@@ -72,9 +68,7 @@ module Tournament
       # @return [Array<team>]
       # @raise [ArgumentError] when the number of teams is not a power of 2
       def seed(teams)
-        unless (Math.log2(teams.length) % 1).zero?
-          raise ArgumentError, 'Need power-of-2 teams'
-        end
+        raise ArgumentError, 'Need power-of-2 teams' unless (Math.log2(teams.length) % 1).zero?
 
         teams = teams.map.with_index do |team, index|
           OpenStruct.new(team: team, index: index)

data/lib/{tournament → tournament_system}/algorithm/swiss.rb

@@ -1,4 +1,4 @@
-module Tournament
+module TournamentSystem
   module Algorithm
     # This module provides algorithms for dealing with swiss tournament systems. Specifically it provides algorithms for
     # grouping teams.

data/lib/{tournament → tournament_system}/algorithm/util.rb

@@ -1,4 +1,4 @@
-module Tournament
+module TournamentSystem
   module Algorithm
     # This module provides utility functions for helping implement other
     # algorithms.

data/lib/{tournament → tournament_system}/driver.rb

@@ -1,22 +1,78 @@
-module Tournament
+module TournamentSystem
   # :reek:UnusedParameters
 
   # An interface for external tournament data.
   #
-  # To use any tournament system implemented in this gem, simply subclass this
-  # class and implement the interface functions.
+  # To use any tournament system implemented in this gem, simply subclass this class and implement the interface
+  # functions.
   #
-  # The interface is designed to be useable with arbitrary data,
-  # meaning that as long as your data is consistent it will work with this gem.
-  # Be it Ruby on Rails Models or simply integers.
+  # The interface is designed to be useable with arbitrary data, meaning that as long as your data is consistent it will
+  # work with this gem. Be it Ruby on Rails Models or simply integers.
   #
-  # Certain tournament systems will not make use of certain parts of this
-  # interface. You can for example leave out `#get_team_score` if you're not
-  # using the Swiss tournament system.
+  # Certain tournament systems will not make use of certain parts of this interface. You can for example leave out
+  # `#get_team_score` if you're not using the Swiss tournament system.
   #
-  # This class caches certain calculations/objects, it is designed to be a
-  # one-time use with any one tournament system. Reusing an instance may result
-  # in undefined behaviour.
+  # This class caches certain calculations/objects, it is designed to be a one-time use with any one tournament system.
+  # Reusing an instance is undefined behaviour.
+  #
+  # @example Example of Rails models and a tournament system driver
+  #   class Tournament < ActiveRecord::Base
+  #     has_many :matches
+  #     has_many :teams
+  #   end
+  #
+  #   class Match < ActiveRecord::Base
+  #     belongs_to :tournament
+  #     belongs_to :team1, class_name: 'Team'
+  #     belongs_to :team2, class_name: 'Team'
+  #     belongs_to :winner, class_name: 'Team'
+  #   end
+  #
+  #   class Team < ActiveRecord::Base
+  #     belongs_to :tournament
+  #
+  #     validates :seed, numericality: { only_integer: true }
+  #     validates :points, numericality: { only_integer: true }
+  #   end
+  #
+  #   class Driver < TournamentSystem
+  #     def initialize(tournament)
+  #       @tournament = tournament
+  #     end
+  #
+  #     def matches
+  #       @tournament.matches
+  #     end
+  #
+  #     def seeded_teams
+  #       @tournament.teams.order(:seed).to_a
+  #     end
+  #
+  #     def ranked_teams
+  #       @tournament.teams.order(:points).to_a
+  #     end
+  #
+  #     def get_match_winner(match)
+  #       match.winner
+  #     end
+  #
+  #     def get_match_teams(match)
+  #       [match.team1, match.team2]
+  #     end
+  #
+  #     def get_team_score(team)
+  #       team.points
+  #     end
+  #
+  #     def get_team_matches(team)
+  #       @tournament.matches.where(team1: team) +
+  #         @tournament.matches.where(team2: team)
+  #     end
+  #
+  #     def build_match(home_team, away_team)
+  #       @tournament.matches.create!(team1: home_team, team2: away_team)
+  #     end
+  #   end
   class Driver
     # rubocop:disable Lint/UnusedMethodArgument
     # :nocov:
@@ -66,6 +122,14 @@ module Tournament
       raise 'Not Implemented'
     end
 
+    # Required to implement: Get the matches a team has participated in.
+    #
+    # @param team [] a team, eg. one returned by {#seeded_teams}
+    # @return [Array<match>] a list of matches the team has played in
+    def get_team_matches(team)
+      raise 'Not Implemented'
+    end
+
     # Required to implement: Called when a match is created by a tournament system.
     #
     # @example rails
@@ -102,6 +166,13 @@ module Tournament
       @matches_hash ||= build_matches_hash
     end
 
+    # Get a hash of the matches teams have played in. Used by tournament systems.
+    #
+    # @return [Hash{team => Array<match>}]
+    def team_matches_hash
+      @team_matches_hash ||= build_team_matches_hash
+    end
+
     # Count the number of times each pair of teams has played already. Used by tournament systems.
     #
     # @param matches [Array<match>]
@@ -152,5 +223,12 @@ module Tournament
         counter[match] += 1
       end
     end
+
+    def build_team_matches_hash
+      seeded_teams.each_with_object({}) do |team, hash|
+        matches = get_team_matches(team)
+        hash[team] = matches
+      end
+    end
   end
 end

data/lib/tournament_system/driver_proxy.rb

@@ -0,0 +1,46 @@
+module TournamentSystem
+  # Proxies a driver, allowing overriding of certain functions.
+  #
+  # Used by tournament systems that build on top of others, with special behaviour.
+  # By default the behaviour is identical to the proxied driver.
+  class DriverProxy < Driver
+    # :nocov:
+
+    # @param target [Driver] the driver to proxy
+    def initialize(target)
+      @target = target
+    end
+
+    def matches
+      @target.matches
+    end
+
+    def seeded_teams
+      @target.seeded_teams
+    end
+
+    def ranked_teams
+      @target.ranked_teams
+    end
+
+    def get_match_winner(match)
+      @target.get_match_winner(match)
+    end
+
+    def get_match_teams(match)
+      @target.get_match_teams(match)
+    end
+
+    def get_team_score(team)
+      @target.get_team_score(team)
+    end
+
+    def get_team_matches(team)
+      @target.get_team_matches(team)
+    end
+
+    def build_match(home_team, away_team)
+      @target.build_match(home_team, away_team)
+    end
+  end
+end

data/lib/{tournament → tournament_system}/page_playoff.rb

@@ -1,7 +1,7 @@
-require 'tournament/algorithm/page_playoff'
-require 'tournament/algorithm/group_pairing'
+require 'tournament_system/algorithm/page_playoff'
+require 'tournament_system/algorithm/group_pairing'
 
-module Tournament
+module TournamentSystem
   # Implements the page playoff system.
   module PagePlayoff
     extend self

data/lib/{tournament → tournament_system}/round_robin.rb

@@ -1,7 +1,7 @@
-require 'tournament/algorithm/util'
-require 'tournament/algorithm/round_robin'
+require 'tournament_system/algorithm/util'
+require 'tournament_system/algorithm/round_robin'
 
-module Tournament
+module TournamentSystem
   # Implements the round-robin tournament system.
   module RoundRobin
     extend self

data/lib/{tournament → tournament_system}/single_elimination.rb

@@ -1,7 +1,7 @@
-require 'tournament/algorithm/single_bracket'
-require 'tournament/algorithm/group_pairing'
+require 'tournament_system/algorithm/single_bracket'
+require 'tournament_system/algorithm/group_pairing'
 
-module Tournament
+module TournamentSystem
   # Implements the single bracket elimination tournament system.
   module SingleElimination
     extend self

data/lib/{tournament → tournament_system}/swiss.rb

@@ -1,8 +1,9 @@
-require 'tournament/algorithm/swiss'
-require 'tournament/swiss/dutch'
+require 'tournament_system/algorithm/swiss'
+require 'tournament_system/swiss/dutch'
+require 'tournament_system/swiss/accelerated_dutch'
 
-module Tournament
-  # Implements the swiss tournament system
+module TournamentSystem
+  # Robust implementation of the swiss tournament system
   module Swiss
     extend self
 
@@ -23,6 +24,15 @@ module Tournament
       driver.create_matches(pairings)
     end
 
+    # Guesses the round number (starting from 0) from the maximum amount of matches any team has played.
+    # The guess will be wrong for long running competitions where teams are free to sign up and drop out at any time.
+    #
+    # @param driver [Driver]
+    # @return [Integer]
+    def guess_round(driver)
+      driver.team_matches_hash.values.map(&:length).max || 0
+    end
+
     # The minimum number of rounds to determine a number of winners.
     #
     # @param driver [Driver]

data/lib/tournament_system/swiss/accelerated_dutch.rb

@@ -0,0 +1,69 @@
+require 'tournament_system/swiss/dutch'
+require 'tournament_system/driver_proxy'
+
+module TournamentSystem
+  module Swiss
+    # A implementation of accelerated (dutch) swiss pairing
+    module AcceleratedDutch
+      extend self
+
+      # Pair teams using the accelerated (dutch) swiss pairing system.
+      #
+      # Behaves identical to the dutch pairing system, except that for the first N rounds the top half of the seeded
+      # teams is given a point bonus. This makes the first couple rounds of a tournament accelerate 1 round ahead of
+      # swiss.
+      #
+      # Options are passed to the dutch system and behave identically.
+      #
+      # @param driver [Driver]
+      # @option options [Integer] acceleration_rounds determines how many round to perform the acceleration for. This
+      #     should be shorter than the length of the tournament in order to produce fair results.
+      # @option options [Number] acceleration_points determines how many points to grant the teams. This should be
+      #     approximately equal to the number of points usually granted in one round.
+      # @return [Array<Array(team, team)>] the generated pairs of teams
+      def pair(driver, options = {})
+        acceleration_rounds = options[:acceleration_rounds] || 2
+        acceleration_points = options[:acceleration_points] || 1
+
+        # Accelerate for the first N rounds by replacing the driver with an accelerated one
+        driver = accelerate_driver(driver, acceleration_points) if Swiss.guess_round(driver) < acceleration_rounds
+
+        # Do a regular dutch pairing
+        Dutch.pair(driver, options)
+      end
+
+      private
+
+      def accelerate_driver(driver, acceleration_points)
+        teams = driver.seeded_teams
+        top_half = Set.new teams[0..teams.length / 2]
+
+        # Accelerated dutch is identical to dutch, except that we give the top half an extra point for the first 2
+        # rounds. To do that we just proxy the driver and add one point.
+        AcceleratedDutchDriverProxy.new(driver, top_half, acceleration_points)
+      end
+
+      # Driver proxy for implementing a score bonus
+      class AcceleratedDutchDriverProxy < DriverProxy
+        def initialize(target, accelerated_teams, acceleration_points)
+          super(target)
+
+          @accelerated_teams = accelerated_teams
+          @acceleration_points = acceleration_points
+        end
+
+        def get_team_score(team)
+          original_score = super(team)
+
+          if @accelerated_teams.include?(team)
+            original_score + @acceleration_points
+          else
+            original_score
+          end
+        end
+      end
+
+      private_constant :AcceleratedDutchDriverProxy
+    end
+  end
+end

data/lib/{tournament → tournament_system}/swiss/dutch.rb

@@ -1,20 +1,21 @@
 require 'ostruct'
 
-require 'tournament/algorithm/swiss'
-require 'tournament/algorithm/matching'
-require 'tournament/algorithm/group_pairing'
+require 'tournament_system/algorithm/swiss'
+require 'tournament_system/algorithm/matching'
+require 'tournament_system/algorithm/group_pairing'
 
-module Tournament
+module TournamentSystem
   module Swiss
-    # A simplified Dutch pairing system implementation.
+    # A Dutch pairing system implementation.
     module Dutch
       extend self
 
       # Pair teams using dutch pairing for a swiss system tournament.
       #
-      # Teams are initially grouped by their score and then slide paired ({Tournament::Algorithm::GroupPairing.slide}).
-      # If that fails to produce unique matches it will match teams by the minimum score difference, aniling duplicate
-      # matches (default) and optionally pushing byes to a certain side.
+      # Teams are initially grouped by their score and then slide paired
+      # ({TournamentSystem::Algorithm::GroupPairing.slide}). If that fails to produce unique matches it will match teams
+      # by the minimum score difference, aniling duplicate matches (default) and optionally pushing byes to a certain
+      # side.
       #
       # @param driver [Driver]
       # @option options [Boolean] allow_duplicates removes the penalty of duplicate matches from the pairing algorithm

data/lib/tournament_system/version.rb

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

data/tournament-system.gemspec

@@ -1,12 +1,10 @@
-# coding: utf-8
-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'tournament/version'
+require 'tournament_system/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'tournament-system'
-  spec.version       = Tournament::VERSION
+  spec.version       = TournamentSystem::VERSION
   spec.authors       = ['Benjamin Schaaf']
   spec.email         = ['ben.schaaf@gmail.com']
 
@@ -24,5 +22,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'graph_matching', '~> 0.1.1'
-  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'bundler', '~> 1.16.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tournament-system
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Benjamin Schaaf
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-29 00:00:00.000000000 Z
+date: 2018-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graph_matching
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: 1.16.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: 1.16.0
 description: 
 email:
 - ben.schaaf@gmail.com
@@ -54,23 +54,24 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/tournament-system.rb
-- lib/tournament.rb
-- lib/tournament/algorithm.rb
-- lib/tournament/algorithm/group_pairing.rb
-- lib/tournament/algorithm/matching.rb
-- lib/tournament/algorithm/page_playoff.rb
-- lib/tournament/algorithm/round_robin.rb
-- lib/tournament/algorithm/single_bracket.rb
-- lib/tournament/algorithm/swiss.rb
-- lib/tournament/algorithm/util.rb
-- lib/tournament/driver.rb
-- lib/tournament/page_playoff.rb
-- lib/tournament/round_robin.rb
-- lib/tournament/single_elimination.rb
-- lib/tournament/swiss.rb
-- lib/tournament/swiss/dutch.rb
-- lib/tournament/version.rb
+- lib/tournament_system.rb
+- lib/tournament_system/algorithm.rb
+- lib/tournament_system/algorithm/group_pairing.rb
+- lib/tournament_system/algorithm/matching.rb
+- lib/tournament_system/algorithm/page_playoff.rb
+- lib/tournament_system/algorithm/round_robin.rb
+- lib/tournament_system/algorithm/single_bracket.rb
+- lib/tournament_system/algorithm/swiss.rb
+- lib/tournament_system/algorithm/util.rb
+- lib/tournament_system/driver.rb
+- lib/tournament_system/driver_proxy.rb
+- lib/tournament_system/page_playoff.rb
+- lib/tournament_system/round_robin.rb
+- lib/tournament_system/single_elimination.rb
+- lib/tournament_system/swiss.rb
+- lib/tournament_system/swiss/accelerated_dutch.rb
+- lib/tournament_system/swiss/dutch.rb
+- lib/tournament_system/version.rb
 - tournament-system.gemspec
 homepage: https://github.com/ozfortress/tournament-system
 licenses:
@@ -92,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Implements various tournament systems

data/lib/tournament-system.rb

@@ -1,7 +0,0 @@
-require 'tournament/version'
-require 'tournament/driver'
-
-require 'tournament/swiss'
-require 'tournament/round_robin'
-require 'tournament/page_playoff'
-require 'tournament/single_elimination'

data/lib/tournament.rb

@@ -1,6 +0,0 @@
-# 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-independent way ({Driver}).
-module Tournament
-end

data/lib/tournament/version.rb

@@ -1,4 +0,0 @@
-module Tournament
-  # The current version of this gem.
-  VERSION = '1.0.2'.freeze
-end