sports-manager 0.0.1

data/lib/sports_manager/tournament_builder.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: A step-by-step tournament constructor (Builder Pattern)
+  class TournamentBuilder
+    attr_reader :matches, :subscriptions,
+                :categories, :configurations,
+                :tournament_days, :tournament
+
+    DEFAULT_CONFIGURATIONS = {
+      courts: 1,
+      match_time: 60,
+      break_time: 10,
+      single_day_matches: false,
+      tournament_type: Matches::Algorithms::SingleEliminationAlgorithm
+    }.freeze
+
+    def initialize
+      @matches = {}
+      @subscriptions = {}
+      @categories = []
+      @tournament_days = []
+      @configurations = DEFAULT_CONFIGURATIONS
+    end
+
+    def build
+      Tournament.new(settings: settings, groups: groups)
+    end
+
+    def add_matches(matches)
+      matches.each do |category, category_matches|
+        add_match(category: category, category_matches: category_matches)
+      end
+
+      self
+    end
+
+    def add_match(category:, category_matches:)
+      return self if [category, category_matches].any?(nil)
+
+      @matches.merge!(category => category_matches)
+
+      self
+    end
+
+    def add_subscription(category:, participants:)
+      @subscriptions.merge!(category => participants)
+
+      self
+    end
+
+    def add_subscriptions(subscriptions)
+      subscriptions.each do |category, participants|
+        add_subscription(category: category, participants: participants)
+      end
+
+      self
+    end
+
+    def add_configuration(key:, value:)
+      return self if [key, value].any?(nil)
+
+      @configurations = @configurations.merge(key.to_sym => value)
+
+      self
+    end
+
+    def add_configurations(params)
+      params.each { |key, value| add_configuration(key: key, value: value) }
+
+      self
+    end
+
+    def add_schedule(tournament_days)
+      tournament_days.each do |date, period|
+        add_date(
+          date: date,
+          start_hour: period[:start],
+          end_hour: period[:end]
+        )
+      end
+      self
+    end
+
+    def add_date(date:, start_hour:, end_hour:)
+      @tournament_days << TournamentDay.for(
+        date: date,
+        start_hour: start_hour,
+        end_hour: end_hour
+      )
+
+      self
+    end
+
+    private
+
+    def groups
+      categories = subscriptions.keys
+
+      categories.map do |category|
+        category_subscriptions = subscriptions[category]
+        category_matches = matches[category]
+
+        Group.for(
+          category: category,
+          subscriptions: category_subscriptions,
+          matches: category_matches,
+          tournament_type: configurations[:tournament_type]
+        )
+      end
+    end
+
+    def settings
+      Tournament::Setting.new(
+        tournament_days: tournament_days,
+        match_time: configurations[:match_time],
+        break_time: configurations[:break_time],
+        courts: configurations[:courts],
+        single_day_matches: configurations[:single_day_matches]
+      )
+    end
+  end
+end

data/lib/sports_manager/tournament_day/validator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class TournamentDay
+    # Public: Validates tournament day's date and time range
+    class Validator
+      extend Forwardable
+
+      DateParsingError = Class.new(StandardError) do
+        def initialize(date)
+          message = "It is not possible to parse Date: #{date}"
+          super(message)
+        end
+      end
+
+      InvalidHour = Class.new(StandardError) do
+        def initialize(start_hour, end_hour)
+          message = 'start_hour and end_hour must be between 0 and 23. ' \
+                    "start_hour: #{start_hour}, end_hour: #{end_hour}"
+          super(message)
+        end
+      end
+
+      MIN_HOUR = 0
+      MAX_HOUR = 23
+
+      attr_reader :tournament_day
+
+      def_delegators :tournament_day, :start_hour, :end_hour, :date
+
+      def initialize(tournament_day)
+        @tournament_day = tournament_day
+      end
+
+      def validate!
+        return true if valid?
+        raise DateParsingError, date unless parseable_date?
+
+        raise InvalidHour.new(start_hour, end_hour)
+      end
+
+      def valid?
+        parseable_date? && in_day_range?
+      end
+
+      private
+
+      def parseable_date?
+        !!parse_date
+      end
+
+      def parse_date
+        @parse_date ||= begin
+          Date.strptime(date, '%Y-%m-%d')
+        rescue StandardError
+          nil
+        end
+      end
+
+      def in_day_range?
+        [start_hour, end_hour].all?(&method(:day_range?))
+      end
+
+      def day_range?(hour)
+        hour.between?(MIN_HOUR, MAX_HOUR)
+      end
+    end
+  end
+end

data/lib/sports_manager/tournament_day.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# TODO: revisit this logic
+module SportsManager
+  # Public: One of the tournament's day with their specific date, duration,
+  # and timeslots available
+  class TournamentDay
+    include Comparable
+
+    MAX_HOUR = 24
+    ONE_HOUR = 60
+
+    attr_reader :start_hour, :end_hour, :date
+
+    def self.for(date:, start_hour:, end_hour:)
+      new(date: date, start_hour: start_hour, end_hour: end_hour)
+    end
+
+    def initialize(date:, start_hour:, end_hour:)
+      @date = date.to_s
+      @start_hour = start_hour.to_i
+      @end_hour = end_hour.to_i
+      Validator.new(self).validate!
+    end
+
+    def timeslots(interval: ONE_HOUR)
+      TimeslotBuilder.build(tournament_day: self, interval: interval)
+    end
+
+    def total_time
+      @total_time ||= end_hour - start_hour if start_hour <= end_hour
+    end
+
+    def <=>(other)
+      return unless instance_of?(other.class)
+
+      equality(other).find(-> { 0 }, &:nonzero?)
+    end
+
+    private
+
+    def equality(other)
+      [
+        date <=> other.date,
+        start_hour <=> other.start_hour,
+        end_hour <=> other.end_hour
+      ]
+    end
+  end
+end

data/lib/sports_manager/tournament_generator.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize
+module SportsManager
+  # Public:Tournament Solver
+  #               _TEAM A______
+  #      MATCH 1               \_TEAM B______
+  #               _TEAM B______/             \
+  #                                MATCH 5    \_TEAM B___
+  #               _TEAM C______               /          \
+  #      MATCH 2               \_TEAM C______/            \
+  #               _TEAM D______/                           \
+  #                                             MATCH 7     \__TEAM E__
+  #               _TEAM E______                             /
+  #      MATCH 3               \_TEAM E______              /
+  #               _TEAM F______/             \            /
+  #                                MATCH 6    \_TEAM E___/
+  #               _TEAM G______               /
+  #      MATCH 4               \_TEAM G______/
+  #               _TEAM H______/
+  class TournamentGenerator
+    extend Forwardable
+
+    attr_reader :format, :tournament, :variables, :domains,
+                :ordering, :filtering, :csp
+
+    attr_accessor :days, :subscriptions, :matches, :courts, :game_length, :rest_break, :single_day_matches,
+                  :tournament_type
+
+    def_delegators :tournament, :match_time, :timeslots
+
+    def self.example(type = :simple, format: :cli)
+      params = Helper.public_send(type)
+
+      new(format: format)
+        .add_days(params[:when])
+        .add_subscriptions(params[:subscriptions])
+        .add_matches(params[:matches])
+        .add_courts(params[:courts])
+        .add_game_length(params[:game_length])
+        .add_rest_break(params[:rest_break])
+        .enable_single_day_matches(params[:single_day_matches])
+        .call
+    end
+
+    def initialize(format: :cli)
+      @format = format
+      @days = {}
+      @subscriptions = {}
+      @matches = {}
+      @ordering = Algorithms::Ordering::MultipleMatchesParticipant
+      @filtering = Algorithms::Filtering::NoOverlap
+    end
+
+    def add_day(day, start, finish)
+      days[day.to_sym] = { start: start, end: finish }
+      self
+    end
+
+    def add_days(days)
+      days.each do |day, time_hash|
+        add_day(day, time_hash[:start], time_hash[:end])
+      end
+      self
+    end
+
+    def add_subscription(category, subscription)
+      subscriptions[category] ||= []
+      subscriptions[category] << subscription
+      self
+    end
+
+    def add_subscriptions_per_category(category, subscriptions)
+      subscriptions.each { |subscription| add_subscription(category, subscription) }
+      self
+    end
+
+    def add_subscriptions(subscriptions)
+      subscriptions.each do |category, subscriptions_per_category|
+        add_subscriptions_per_category(category, subscriptions_per_category)
+      end
+      self
+    end
+
+    def add_match(category, match)
+      matches[category] ||= []
+      matches[category] << match
+      self
+    end
+
+    def add_matches_per_category(category, matches)
+      matches.each { |match| add_match(category, match) }
+      self
+    end
+
+    def add_matches(matches)
+      matches.each do |category, matches_per_category|
+        add_matches_per_category(category, matches_per_category)
+      end
+      self
+    end
+
+    def add_courts(number_of_courts)
+      @courts = number_of_courts
+      self
+    end
+
+    def add_game_length(game_length)
+      @game_length = game_length
+      self
+    end
+
+    def add_rest_break(rest_break)
+      @rest_break = rest_break
+      self
+    end
+
+    def enable_single_day_matches(single_day_matches)
+      @single_day_matches = single_day_matches
+      self
+    end
+
+    def single_elimination_algorithm
+      @tournament_type = Matches::Algorithms::SingleEliminationAlgorithm
+      self
+    end
+
+    def call
+      setup
+
+      solutions = csp.solve
+
+      TournamentSolution
+        .new(tournament: tournament, solutions: solutions)
+        .tap(&method(:print_solution))
+    end
+
+    private
+
+    def setup
+      @tournament = build_tournament
+
+      @variables = @tournament.matches.values.flat_map(&:itself)
+
+      @domains = @variables.each_with_object({}) do |variable, domains|
+        domains[variable] = timeslots.sort_by(&:slot)
+      end
+
+      # TODO: Add a ordering specific for domains
+      @csp = TournamentProblemBuilder
+        .new(tournament)
+        .add_variables(variables)
+        .add_domains(domains)
+        .add_ordering(ordering)
+        .add_filtering(filtering)
+        .add_constraint(Constraints::AllDifferentConstraint)
+        .add_constraint(Constraints::NoOverlappingConstraint)
+        .add_constraint(Constraints::MatchConstraint)
+        .add_constraint(Constraints::MultiCategoryConstraint)
+        .add_constraint(Constraints::NextRoundConstraint)
+        .build
+    end
+
+    def build_tournament
+      TournamentBuilder
+        .new
+        .add_matches(matches)
+        .add_subscriptions(subscriptions)
+        .add_schedule(days)
+        .add_configuration(key: :courts, value: courts)
+        .add_configuration(key: :match_time, value: game_length)
+        .add_configuration(key: :break_time, value: rest_break)
+        .add_configuration(key: :single_day_matches, value: single_day_matches)
+        .add_configuration(key: :tournament_type, value: tournament_type)
+        .build
+    end
+
+    def print_solution(tournament_solution)
+      SolutionDrawer.new(tournament_solution).public_send(format)
+    end
+  end
+end
+# rubocop:enable Metrics/AbcSize

data/lib/sports_manager/tournament_problem_builder.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # TODO: better name this
+  # Public: Builds a CSP for Tournament Scheduling.
+  #
+  # Usage example:
+  # builder = ProblemBuilder.new(tournament)
+  #
+  # builder
+  #   .add_variables(variables)
+  #   .add_domains(domains)
+  #   .add_ordering(NoOrder)
+  #   .add_filtering(NoFilter)
+  #
+  # builder
+  #   .add_constraint(AllDifferentConstraint)
+  #   .add_constraint(NoOverlapping)
+  #
+  # csp = builder.build
+  class TournamentProblemBuilder
+    attr_reader :variables, :domains, :constraints, :max_solutions,
+                :filtering_algorithm, :ordering_algorithm, :tournament
+
+    MINIMUM_SOLUTIONS = 1
+
+    def initialize(tournament)
+      @variables = []
+      @domains = {}
+      @constraints = []
+
+      @filtering_algorithm = nil
+      @ordering_algorithm = nil
+
+      @max_solutions = MINIMUM_SOLUTIONS
+
+      @tournament = tournament
+    end
+
+    def add_variables(variables)
+      @variables = variables
+
+      self
+    end
+
+    def add_domains(domains)
+      @domains = domains
+
+      self
+    end
+
+    def add_ordering(ordering_algorithm_class)
+      @ordering_algorithm = ordering_algorithm_class
+
+      self
+    end
+
+    def add_filtering(filtering_algorithm_class)
+      @filtering_algorithm = filtering_algorithm_class
+
+      self
+    end
+
+    # TODO: change to pass symbol instead of class?
+    def add_constraint(constraint_class)
+      @constraints |= Utils::Array.wrap(constraint_class)
+
+      self
+    end
+
+    def add_max_solutions(max_solutions)
+      @max_solutions = [max_solutions, MINIMUM_SOLUTIONS].find(&:positive?)
+
+      self
+    end
+
+    def build
+      csp.tap do |problem|
+        variables.each do |variable|
+          problem.add_variable(variable, domains: domains[variable])
+        end
+        problem.add_ordering ordering(problem)
+        problem.add_filtering filtering(problem)
+        build_constraint(problem)
+      end
+    end
+
+    private
+
+    def csp
+      CSP::Problem.new(max_solutions: max_solutions)
+    end
+
+    def ordering(problem)
+      ordering_algorithm.for(problem: problem, dependency: tournament)
+    end
+
+    def filtering(problem)
+      filtering_algorithm.for(problem: problem, dependency: tournament)
+    end
+
+    def build_constraint(csp)
+      ConstraintBuilder.build(tournament: tournament, csp: csp, constraints: constraints)
+    end
+  end
+end

data/lib/sports_manager/tournament_solution/bye_fixture.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class TournamentSolution
+    # Public: A placeholder fixture for byes.
+    class ByeFixture
+      extend Forwardable
+
+      attr_reader :match, :category
+
+      def_delegator :match, :id, :match_id
+      def_delegators :match, :title, :depends_on, :playable?,
+                     :dependencies, :dependencies?
+
+      def initialize(match)
+        @match = match
+        @category = match.category
+      end
+    end
+  end
+end

data/lib/sports_manager/tournament_solution/fixture.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class TournamentSolution
+    # Public: A schedule for the participating teams.
+    class Fixture
+      extend Forwardable
+
+      attr_reader :match, :timeslot, :category
+
+      def_delegator :match, :id, :match_id
+      def_delegators :match, :title, :depends_on, :playable?,
+                     :dependencies, :dependencies?, :round
+      def_delegators :timeslot, :court, :slot
+
+      def self.build_fixtures(fixtures)
+        fixtures.map { |(match, timeslot)| new(match: match, timeslot: timeslot) }
+      end
+
+      def initialize(match:, timeslot:)
+        @match = match
+        @timeslot = timeslot
+        @category = match.category
+      end
+
+      def depends_on?(fixture)
+        depends_on
+          .map(&:id)
+          .include?(fixture.match_id)
+      end
+
+      def bye_dependencies
+        depends_on
+          .reject(&:playable?)
+          .map { |bye| ByeFixture.new(bye) }
+      end
+    end
+  end
+end

data/lib/sports_manager/tournament_solution/serializer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class TournamentSolution
+    # NOTE: Maybe temporary? should each object override as_json?
+    class Serializer
+      include JsonHelper
+      extend Forwardable
+
+      attr_reader :tournament_solution
+
+      def initialize(tournament_solution)
+        @tournament_solution = tournament_solution
+        @tournament = tournament_solution.tournament
+        @solutions = tournament_solution.solutions
+      end
+
+      def as_json(*)
+        {
+          tournament: tournament,
+          solutions: solutions
+        }.as_json
+      end
+
+      private
+
+      def tournament
+        {
+          settings: settings,
+          groups: groups,
+          participants: participants
+        }.as_json
+      end
+
+      def solutions
+        @solutions
+          .map(&method(:build_solution))
+          .as_json
+      end
+
+      def settings
+        setting = @tournament.settings
+
+        params = {
+          match_time: setting.match_time,
+          break_time: setting.break_time,
+          courts: setting.court_list,
+          single_day_matches: setting.single_day_matches
+        }
+
+        params.as_json
+      end
+
+      def groups
+        @tournament.groups.map do |group|
+          {
+            category: group.category,
+            matches: build_matches(group)
+          }
+        end
+      end
+
+      def participants
+        @tournament
+          .participants
+          .sort_by(&:id)
+          .as_json
+      end
+
+      def build_solution(solution)
+        fixtures = solution
+          .fixtures
+          .map(&method(:build_fixture))
+
+        { fixtures: fixtures }
+      end
+
+      def build_fixture(fixture)
+        {
+          match: {
+            id: fixture.match_id,
+            title: fixture.title,
+            category: fixture.category
+          },
+          timeslot: {
+            court: fixture.court,
+            slot: fixture.slot
+          }
+        }
+      end
+
+      def build_matches(group)
+        matches = group
+          .all_matches
+          .sort_by { |match| [match.round, match.id] }
+
+        matches.map do |match|
+          {
+            id: match.id,
+            round: match.round,
+            playing: match.title
+          }
+        end
+      end
+    end
+  end
+end