sports-manager 0.0.1

data/lib/sports-manager.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'csp-resolver'
+require 'forwardable'
+require 'ostruct'
+require_relative 'sports_manager/version'
+require_relative 'sports_manager/helper'
+require_relative 'sports_manager/team'
+require_relative 'sports_manager/single_team'
+require_relative 'sports_manager/double_team'
+require_relative 'sports_manager/json_helper'
+require_relative 'sports_manager/matches/algorithms/single_elimination_algorithm'
+require_relative 'sports_manager/algorithms/ordering/multiple_matches_participant'
+require_relative 'sports_manager/algorithms/filtering/no_overlap'
+require_relative 'sports_manager/constraints/all_different_constraint'
+require_relative 'sports_manager/constraints/no_overlapping_constraint'
+require_relative 'sports_manager/constraints/match_constraint'
+require_relative 'sports_manager/constraints/multi_category_constraint'
+require_relative 'sports_manager/constraints/next_round_constraint'
+require_relative 'sports_manager/tournament_problem_builder'
+require_relative 'sports_manager/tournament_solution'
+require_relative 'sports_manager/participant'
+require_relative 'sports_manager/solution_drawer'
+require_relative 'sports_manager/matches_generator'
+require_relative 'sports_manager/tournament_builder'
+require_relative 'sports_manager/constraint_builder'
+require_relative 'sports_manager/tournament_solution/bye_fixture'
+require_relative 'sports_manager/tournament_solution/fixture'
+require_relative 'sports_manager/tournament_solution/solution'
+require_relative 'sports_manager/tournament_solution/serializer'
+require_relative 'sports_manager/solution_drawer/cli'
+require_relative 'sports_manager/tournament'
+require_relative 'sports_manager/tournament_day'
+require_relative 'sports_manager/tournament/setting'
+require_relative 'sports_manager/group_builder'
+require_relative 'sports_manager/match'
+require_relative 'sports_manager/matches/next_round'
+require_relative 'sports_manager/group'
+require_relative 'sports_manager/solution_drawer/cli/solution_table'
+require_relative 'sports_manager/tournament_day/validator'
+require_relative 'sports_manager/timeslot_builder'
+require_relative 'sports_manager/timeslot'
+require_relative 'sports_manager/bye_match'
+require_relative 'sports_manager/nil_team'
+require_relative 'sports_manager/match_builder'
+require_relative 'sports_manager/team_builder'
+require_relative 'sports_manager/solution_drawer/cli/table'
+require_relative 'sports_manager/tournament_generator'
+require_relative 'sports_manager/solution_drawer/mermaid/gantt'
+require_relative 'sports_manager/solution_drawer/mermaid/graph'
+require_relative 'sports_manager/solution_drawer/mermaid/node'
+require_relative 'sports_manager/solution_drawer/mermaid/node_style'
+require_relative 'sports_manager/solution_drawer/mermaid/bye_node'
+require_relative 'sports_manager/solution_drawer/mermaid/solution_graph'
+require_relative 'sports_manager/solution_drawer/mermaid/solution_gantt'
+require_relative 'sports_manager/solution_drawer/mermaid'
+
+module SportsManager
+end

data/lib/sports_manager/algorithms/filtering/no_overlap.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Algorithms
+    module Filtering
+      class NoOverlap
+        extend Forwardable
+
+        attr_reader :tournament
+
+        def_delegators :tournament, :match_time
+
+        def self.for(dependency:, problem: nil) # rubocop:disable Lint/UnusedMethodArgument
+          new(dependency)
+        end
+
+        def initialize(tournament)
+          @tournament = tournament
+        end
+
+        def call(values:, assignment_values: [])
+          unassigned_values = values - assignment_values
+
+          unassigned_values.reject do |timeslot|
+            timeslot_range = to_range(timeslot.slot)
+
+            assignment_values.any? do |assignment_value|
+              next if timeslot.court != assignment_value.court
+
+              assigned_range = to_range(assignment_value.slot)
+
+              overlap?(timeslot_range, assigned_range)
+            end
+          end
+        end
+
+        private
+
+        def overlap?(time_range1, time_range2)
+          time_range1.cover?(time_range2.first) ||
+            time_range2.cover?(time_range1.first)
+        end
+
+        def to_range(value)
+          end_value = value + (match_time * 60)
+
+          (value...end_value)
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/algorithms/ordering/multiple_matches_participant.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Algorithms
+    module Ordering
+      class MultipleMatchesParticipant
+        attr_reader :tournament
+
+        def self.for(dependency:, problem: nil) # rubocop:disable Lint/UnusedMethodArgument
+          new(dependency)
+        end
+
+        def initialize(tournament)
+          @tournament = tournament
+        end
+
+        def call(variables)
+          variables.sort_by(&method(:sort))
+        end
+
+        private
+
+        def sort(variable)
+          participants = variable.participants
+
+          multi_matches = boolean_to_integer multi_matches?(participants)
+
+          duplicate_ids = sorted_duplicates(participants)
+          duplicate_ids_size = minimum(duplicate_ids.size)
+          number_of_participants = minimum(participants.size)
+
+          [
+            multi_matches,
+            duplicate_ids_size,
+            duplicate_ids,
+            number_of_participants,
+            variable.id
+          ]
+        end
+
+        def multi_matches?(participants)
+          !(multiple_participants & participants).empty?
+        end
+
+        def sorted_duplicates(participants)
+          participants
+            .select { |participant| multiple_participants.include? participant }
+            .map(&:id)
+            .sort
+        end
+
+        def multiple_participants
+          tournament.multi_tournament_participants
+        end
+
+        # Internal: Gives preference for positive finite values over zero
+        # or infinity values when ordering.
+        def minimum(number)
+          values = [number, Float::INFINITY]
+
+          values.min_by do |value|
+            [
+              boolean_to_integer(value.positive?),
+              boolean_to_integer(value.finite?)
+            ]
+          end
+        end
+
+        # TODO: permit set as ascending or descending and swap -1 and 1
+        # Internal: Truthy values should have a precedence over falsey in
+        # ascending order
+        def boolean_to_integer(truthyness)
+          truthyness ? -1 : 1
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/bye_match.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: a Match where it has only one team.
+  # This match is a placeholder used to create the next rounds.
+  # The team in this match will automatically play on the next round.
+  class ByeMatch
+    attr_reader :id, :category, :team1, :team2, :round, :teams, :depends_on
+
+    def initialize(category:, id: nil, team1: nil, team2: nil, round: 0, depends_on: []) # rubocop:disable Metrics/ParameterLists, Lint/UnusedMethodArgument
+      @id = id
+      @category = category
+      @team1 = team1
+      @team2 = team2
+      @round = round
+      @teams = [team1, team2].compact
+      @depends_on = []
+    end
+
+    def playable?
+      false
+    end
+
+    def participants
+      @participants ||= teams.map(&:participants).flatten
+    end
+
+    def dependencies?
+      false
+    end
+
+    def dependencies
+      []
+    end
+
+    def playable_dependencies
+      []
+    end
+
+    def previous_matches?
+      false
+    end
+
+    def previous_matches
+      []
+    end
+
+    def title
+      teams_names.join.concat(' | BYE')
+    end
+
+    def teams_names
+      teams.map(&:name).reject(&:empty?)
+    end
+
+    def ==(other)
+      return false unless instance_of?(other.class)
+
+      id == other.id && category == other.category && round == other.round
+    end
+  end
+end

data/lib/sports_manager/constraint_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class ConstraintBuilder
+    attr_reader :tournament, :constraints
+
+    DEFAULT_CONSTRAINTS = [
+      Constraints::AllDifferentConstraint,
+      Constraints::NoOverlappingConstraint,
+      Constraints::MatchConstraint,
+      Constraints::MultiCategoryConstraint,
+      Constraints::NextRoundConstraint
+    ].freeze
+
+    def self.build(tournament:, csp:, constraints: nil)
+      new(tournament: tournament, constraints: constraints).build(csp)
+    end
+
+    def initialize(tournament:, constraints: nil)
+      @tournament = tournament
+      @constraints = constraints || DEFAULT_CONSTRAINTS
+    end
+
+    def build(csp)
+      constraints.map do |constraint|
+        constraint.for_tournament(tournament: tournament, csp: csp)
+      end
+    end
+  end
+end

data/lib/sports_manager/constraints/all_different_constraint.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Constraints
+    # Public: Constraint to all timeslot assignments be different for
+    # each match
+    class AllDifferentConstraint < ::CSP::Constraint
+      attr_reader :matches
+
+      def self.for_tournament(tournament:, csp:)
+        csp.add_constraint(new(tournament.matches.values.flatten))
+      end
+
+      def initialize(matches)
+        super
+        @matches = matches
+      end
+
+      def satisfies?(assignment)
+        assignment.values == assignment.values.uniq
+      end
+    end
+  end
+end

data/lib/sports_manager/constraints/match_constraint.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Constraints
+    # Public: Restrict match to be set only after the previous matches
+    # it depends on are scheduled.
+    class MatchConstraint < ::CSP::Constraint
+      attr_reader :target_match, :matches
+
+      def self.for_tournament(tournament:, csp:)
+        tournament.matches.each do |(_category, matches)|
+          matches.select(&:previous_matches?).each do |match|
+            csp.add_constraint(
+              new(target_match: match, matches: match.previous_matches)
+            )
+          end
+        end
+      end
+
+      def initialize(target_match:, matches:)
+        super([target_match] + matches)
+        @target_match = target_match
+        @matches = matches
+      end
+
+      def satisfies?(assignment)
+        return true unless variables.all? { |variable| assignment.key?(variable) }
+
+        target_time = assignment[target_match]
+
+        matches
+          .map { |match| assignment[match] }
+          .all? { |time| time < target_time }
+      end
+    end
+  end
+end

data/lib/sports_manager/constraints/multi_category_constraint.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Constraints
+    class MultiCategoryConstraint < ::CSP::Constraint
+      attr_reader :target_participant, :matches,
+                  :match_time, :break_time, :minimum_match_gap
+
+      MINUTE = 60
+
+      def self.for_tournament(tournament:, csp:)
+        tournament.multi_tournament_participants.each do |participant|
+          matches = tournament.find_participant_matches(participant)
+
+          constraint = new(
+            target_participant: participant,
+            matches: matches,
+            match_time: tournament.match_time,
+            break_time: tournament.break_time
+          )
+
+          csp.add_constraint(constraint)
+        end
+      end
+
+      def initialize(target_participant:, matches:, match_time:, break_time:)
+        super(matches)
+        @target_participant = target_participant
+        @matches = matches
+        @match_time = match_time
+        @break_time = break_time
+        @minimum_match_gap = match_time + break_time
+      end
+
+      # TODO: See if needs review in case of solution of split timeslots under match_time
+      def satisfies?(assignment)
+        return true unless variables.all? { |variable| assignment.key?(variable) }
+
+        timeslots = assignment.slice(*variables).values.map(&:slot)
+
+        timeslots.combination(2).all? do |timeslot1, timeslot2|
+          diff_in_minutes = (timeslot1 - timeslot2).abs / MINUTE
+
+          diff_in_minutes >= minimum_match_gap
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/constraints/next_round_constraint.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Constraints
+    class NextRoundConstraint < ::CSP::Constraint
+      attr_reader :target_match, :matches,
+                  :match_time, :break_time, :minimum_match_gap
+
+      MINUTE = 60
+
+      def self.for_tournament(tournament:, csp:)
+        tournament
+          .matches.values.flatten
+          .select(&:previous_matches?)
+          .each do |match|
+            csp.add_constraint new(
+              target_match: match,
+              matches: match.previous_matches,
+              match_time: tournament.match_time,
+              break_time: tournament.break_time
+            )
+          end
+      end
+
+      def initialize(target_match:, matches:, match_time:, break_time:)
+        super([target_match] + matches)
+        @target_match = target_match
+        @matches = matches
+        @match_time = match_time
+        @break_time = break_time
+        @minimum_match_gap = match_time + break_time
+      end
+
+      def satisfies?(assignment)
+        return true unless variables.all? { |variable| assignment.key?(variable) }
+
+        match_time = assignment[target_match].slot
+        matches_timeslots = assignment.slice(*matches).values.map(&:slot)
+
+        matches_timeslots.all? do |timeslot|
+          diff_in_minutes = (timeslot - match_time).abs / MINUTE
+
+          diff_in_minutes >= minimum_match_gap
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/constraints/no_overlapping_constraint.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Constraints
+    class NoOverlappingConstraint < ::CSP::Constraint
+      attr_reader :matches, :match_time
+
+      def self.for_tournament(tournament:, csp:)
+        csp.add_constraint(
+          new(
+            matches: tournament.matches.values.flatten,
+            match_time: tournament.match_time
+          )
+        )
+      end
+
+      def initialize(matches:, match_time:)
+        super(matches)
+        @matches = matches
+        @match_time = match_time
+      end
+
+      def satisfies?(assignment)
+        return true unless variables.all? { |variable| assignment.key?(variable) }
+
+        variables
+          .map { |variable| assignment[variable] }
+          .group_by(&:court)
+          .none? { |_, timeslots| timeslots_overlap?(timeslots: timeslots) }
+      end
+
+      private
+
+      def timeslots_overlap?(timeslots:)
+        timeslots
+          .map(&:slot)
+          .map(&method(:to_range))
+          .combination(2)
+          .any?(&method(:overlap?))
+      end
+
+      def overlap?(*ranges)
+        time_range1, time_range2 = ranges.flatten
+        time_range1.cover?(time_range2.first) ||
+          time_range2.cover?(time_range1.first)
+      end
+
+      def to_range(value)
+        end_value = value + (match_time * 60)
+
+        (value...end_value)
+      end
+    end
+  end
+end

data/lib/sports_manager/double_team.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # TODO: keep only team
+  class DoubleTeam < Team
+  end
+end

data/lib/sports_manager/group.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # TODO: change the name Group. In terms of sports tournament it means something else.
+  # Public: A category with teams and matches between them
+  class Group
+    attr_reader :category, :all_matches, :teams
+
+    def self.for(category:, subscriptions:, matches:, tournament_type:)
+      GroupBuilder.new(category: category, subscriptions: subscriptions, matches: matches,
+                       tournament_type: tournament_type).build
+    end
+
+    def initialize(category: nil, matches: nil, teams: nil)
+      @category = category
+      @all_matches = matches
+      @teams = teams
+    end
+
+    def participants
+      @participants ||= teams.map(&:participants).flatten
+    end
+
+    def matches
+      @matches ||= all_matches.select(&:playable?)
+    end
+
+    def first_round_matches
+      find_matches(0)
+    end
+
+    def find_matches(round_number)
+      matches.select { |match| match.round == round_number }
+    end
+
+    def find_participant_matches(participant)
+      matches.select do |match|
+        match.participants.include? participant
+      end
+    end
+  end
+end

data/lib/sports_manager/group_builder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: Builds a group with matches, teams, and participants from a payload
+  #
+  # category      - The matches' category.
+  # subscriptions - The players subscribed. Doubles are represented as a nested list.
+  # matches       - A list of matches. Each match is represented by a list of
+  #                 players that will be participaing in it.
+  #
+  # Example 1: A Team of one player
+  # Mixed single category with subscribed players: João, Marcelo, Bruno, and Fábio.
+  # The initial matches will be:
+  #   * João vs Fábio
+  #   * Marcelo vs Bruno
+  #
+  #   category: :mixed_single
+  #   subscriptions: [
+  #     { id: 1, name: "João"},
+  #     { id: 2, name: "Marcelo" },
+  #     { id: 15, name: 'Bruno' },
+  #     { id: 16, name: 'Fábio' }
+  #   ]
+  #   matches: [
+  #     [1,16],
+  #     [2,15]
+  #   ]
+  #
+  # Example 2: A team of two players
+  # Women's double category with subscribed players: Laura, Karina, Camila,
+  # Bruna, Carolina, Patricia, Jéssica, and Daniela.
+  #
+  # The initial matches will be:
+  #   * Laura and Karina vs Jéssica and Daniela
+  #   * Camila and Bruna vs Carolina and Patricia
+  #
+  #   category: :womens_double
+  #   subscriptions: [
+  #     [{ id: 17, name: 'Laura' },    { id: 18, name: 'Karina' }],
+  #     [{ id: 19, name: 'Camila' },   { id: 20, name: 'Bruna' }],
+  #     [{ id: 29, name: 'Carolina' }, { id: 30, name: 'Patricia' }],
+  #     [{ id: 31, name: 'Jéssica' },  { id: 32, name: 'Daniela' }]
+  #   ]
+  #   matches: [
+  #     [[17, 18], [31, 32]],
+  #     [[19, 20], [29, 30]]
+  #   ]
+  class GroupBuilder
+    attr_reader :category, :subscriptions, :matches, :tournament_type
+
+    def initialize(category:, subscriptions:, matches:, tournament_type:)
+      @category = category
+      @subscriptions = subscriptions
+      @matches = matches
+      @tournament_type = tournament_type
+    end
+
+    def build
+      Group.new(category: category, matches: builded_matches, teams: teams)
+    end
+
+    private
+
+    def builded_matches
+      MatchBuilder.new(category: category, matches: matches, teams: teams, tournament_type: tournament_type).build
+    end
+
+    def teams
+      TeamBuilder.new(category: category, subscriptions: subscriptions).build
+    end
+  end
+end