sports-manager 0.0.1

data/lib/sports_manager/helper.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength, Metrics/ModuleLength
+module SportsManager
+  # Public: Predefined payloads for validation
+  module Helper
+    module_function
+
+    def minimal
+      {
+        when: {
+          '2023-09-09': { start: 9, end: 20 }
+        },
+        courts: 1,
+        game_length: 60,
+        rest_break: 30,
+        single_day_matches: false,
+        subscriptions: {
+          mixed_single: [{ id: 1, name: 'João' }, { id: 34, name: 'Cleber' }]
+        },
+        matches: {
+          mixed_single: [[1, 34]]
+        }
+      }
+    end
+
+    def simple
+      {
+        when: {
+          '2023-09-09': { start: 9, end: 20 }
+        },
+        courts: 1,
+        game_length: 60,
+        rest_break: 30,
+        single_day_matches: false,
+        subscriptions: {
+          mixed_single: [
+            { id: 1, name: 'João' },    { id: 5, name: 'Carlos' },
+            { id: 10, name: 'Daniel' }, { id: 17, name: 'Laura' },
+            { id: 25, name: 'Joana' },  { id: 29, name: 'Carolina' },
+            { id: 33, name: 'Erica' },  { id: 34, name: 'Cleber' }
+          ]
+        },
+        matches: {
+          mixed_single: [[1, 34], [5, 33], [10, 29], [17, 25]]
+        }
+      }
+    end
+
+    def simple_multi_court
+      simple.merge(courts: 2)
+    end
+
+    def simple_odd_matches
+      {
+        when: {
+          '2023-09-09': { start: 9, end: 20 }
+        },
+        courts: 2,
+        game_length: 60,
+        rest_break: 30,
+        single_day_matches: false,
+        subscriptions: {
+          mixed_single: [
+            { id: 1, name: 'João' },    { id: 5, name: 'Carlos' },
+            { id: 10, name: 'Daniel' }, { id: 29, name: 'Carolina' },
+            { id: 33, name: 'Erica' },  { id: 34, name: 'Cleber' }
+          ]
+        },
+        matches: {
+          mixed_single: [[1], [5, 34], [10, 29], [33]]
+        }
+      }
+    end
+
+    def complete
+      {
+        when: {
+          '2023-09-09': { start: 9, end: 20 },
+          '2023-09-10': { start: 9, end: 13 }
+        },
+        courts: 2,
+        game_length: 60,
+        rest_break: 30,
+        single_day_matches: false,
+        subscriptions: {
+          mens_single: [
+            { id: 1, name: 'João' },      { id: 2, name: 'Marcelo' },
+            { id: 3, name: 'José' },      { id: 4, name: 'Pedro' },
+            { id: 5, name: 'Carlos' },    { id: 6, name: 'Leandro' },
+            { id: 7, name: 'Leonardo' },  { id: 8, name: 'Cláudio' },
+            { id: 9, name: 'Alexandre' }, { id: 10, name: 'Daniel' },
+            { id: 11, name: 'Marcos' },   { id: 12, name: 'Henrique' },
+            { id: 13, name: 'Joaquim' },  { id: 14, name: 'Alex' },
+            { id: 15, name: 'Bruno' },    { id: 16, name: 'Fábio' }
+          ]
+        },
+        matches: {
+          mens_single: [
+            [1, 16],
+            [2, 15],
+            [3, 14],
+            [4, 13],
+            [5, 12],
+            [6, 11],
+            [7, 10],
+            [8, 9]
+          ]
+        }
+      }
+    end
+
+    def complex
+      {
+        when: {
+          '2023-09-09': { start: 9, end: 20 },
+          '2023-09-10': { start: 9, end: 13 }
+        },
+        courts: 2,
+        game_length: 60,
+        rest_break: 30,
+        single_day_matches: false,
+        subscriptions: {
+          mens_single: [
+            { id: 1, name: 'João' },      { id: 2, name: 'Marcelo' },
+            { id: 3, name: 'José' },      { id: 4, name: 'Pedro' },
+            { id: 5, name: 'Carlos' },    { id: 6, name: 'Leandro' },
+            { id: 7, name: 'Leonardo' },  { id: 8, name: 'Cláudio' },
+            { id: 9, name: 'Alexandre' }, { id: 10, name: 'Daniel' },
+            { id: 11, name: 'Marcos' },   { id: 12, name: 'Henrique' },
+            { id: 13, name: 'Joaquim' },  { id: 14, name: 'Alex' },
+            { id: 15, name: 'Bruno' },    { id: 16, name: 'Fábio' }
+          ],
+          womens_double: [
+            [{ id: 17, name: 'Laura' },    { id: 18, name: 'Karina' }],
+            [{ id: 19, name: 'Camila' },   { id: 20, name: 'Bruna' }],
+            [{ id: 21, name: 'Aline' },    { id: 22, name: 'Cintia' }],
+            [{ id: 23, name: 'Maria' },    { id: 24, name: 'Elis' }],
+            [{ id: 25, name: 'Joana' },    { id: 26, name: 'Izadora' }],
+            [{ id: 27, name: 'Claudia' },  { id: 28, name: 'Marina' }],
+            [{ id: 29, name: 'Carolina' }, { id: 30, name: 'Patricia' }],
+            [{ id: 31, name: 'Jéssica' },  { id: 32, name: 'Daniela' }]
+          ],
+          mixed_single: [
+            { id: 1, name: 'João' },    { id: 5, name: 'Carlos' },
+            { id: 10, name: 'Daniel' }, { id: 17, name: 'Laura' },
+            { id: 25, name: 'Joana' },  { id: 29, name: 'Carolina' },
+            { id: 33, name: 'Erica' },  { id: 34, name: 'Cleber' }
+          ]
+        },
+        matches: {
+          mens_single: [
+            [1, 16],
+            [2, 15],
+            [3, 14],
+            [4, 13],
+            [5, 12],
+            [6, 11],
+            [7, 10],
+            [8, 9]
+          ],
+          womens_double: [
+            [[17, 18], [31, 32]],
+            [[19, 20], [29, 30]],
+            [[21, 22], [27, 28]],
+            [[23, 24], [25, 26]]
+          ],
+          mixed_single: [
+            [1, 34],
+            [5, 33],
+            [10, 29],
+            [17, 25]
+          ]
+        }
+      }
+    end
+
+    def duplicate
+      {
+        when: { '2023-09-09': { start: 9, end: 20 } },
+        courts: 1,
+        game_length: 60,
+        rest_break: 30,
+        single_day_matches: false,
+        subscriptions: {
+          mens_single: [
+            { id: 1, name: 'João' },
+            { id: 2, name: 'Marcelo' }
+          ],
+          mixed_single: [
+            { id: 1, name: 'João' },
+            { id: 5, name: 'Carlos' },
+            { id: 10, name: 'Daniel' },
+            { id: 17, name: 'Laura' }
+          ]
+        },
+        matches: {
+          mens_single: [[1, 2]],
+          mixed_single: [[1, 10], [5, 17]]
+        }
+      }
+    end
+
+    def no_solution
+      {
+        when: {
+          '2023-09-09': { start: 9, end: 10 }
+        },
+        courts: 1,
+        game_length: 60,
+        rest_break: 30,
+        single_day_matches: false,
+        subscriptions: {
+          mixed_single: [
+            { id: 1, name: 'João' },    { id: 5, name: 'Carlos' },
+            { id: 10, name: 'Daniel' }, { id: 17, name: 'Laura' },
+            { id: 25, name: 'Joana' },  { id: 29, name: 'Carolina' },
+            { id: 33, name: 'Erica' },  { id: 34, name: 'Cleber' }
+          ]
+        },
+        matches: {
+          mixed_single: [[1, 34], [5, 33], [10, 29], [17, 25]]
+        }
+      }
+    end
+  end
+end
+# rubocop:enable Metrics/MethodLength, Metrics/ModuleLength

data/lib/sports_manager/json_helper.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module JsonHelper
+    def as_json(_options = nil)
+      instance_variables.each_with_object({}) do |var, hash|
+        key = var.to_s.delete('@').to_sym
+        value = instance_variable_get(var)
+        hash[key] = JsonHelper.convert_value(value)
+      end
+    end
+
+    def self.deep_symbolize_keys(object)
+      case object
+      when Hash
+        object.each_with_object({}) do |(k, v), result|
+          key = begin
+            k.to_sym
+          rescue StandardError
+            k
+          end
+          result[key] = deep_symbolize_keys(v)
+        end
+      when Array
+        object.map { |v| deep_symbolize_keys(v) }
+      else
+        object
+      end
+    end
+
+    def self.convert_value(value)
+      case value
+      when Hash
+        value.transform_keys(&:to_sym).transform_values { |v| convert_value(v) }
+      when Array
+        value.map { |v| convert_value(v) }
+      else
+        value.respond_to?(:as_json) ? value.as_json : value
+      end
+    end
+
+    def self.convert_custom_object(object)
+      object.instance_variables.each_with_object({}) do |var, hash|
+        key = var.to_s.delete('@').to_sym
+        hash[key] = convert_value(object.instance_variable_get(var))
+      end
+    end
+  end
+end
+
+class Hash
+  def as_json(_options = nil)
+    transform_keys(&:to_s).transform_values do |value|
+      value.respond_to?(:as_json) ? value.as_json : value
+    end
+  end
+
+  def deep_symbolize_keys
+    SportsManager::JsonHelper.deep_symbolize_keys(self)
+  end
+end
+
+class Array
+  def as_json(_options = nil)
+    map do |value|
+      value.respond_to?(:as_json) ? value.as_json : value
+    end
+  end
+
+  def deep_symbolize_keys
+    SportsManager::JsonHelper.deep_symbolize_keys(self)
+  end
+end
+
+class Symbol
+  def as_json(_options = nil)
+    to_s
+  end
+end
+
+class Numeric
+  def as_json(_options = nil)
+    self
+  end
+end
+
+class String
+  def as_json(_options = nil)
+    self
+  end
+end
+
+class TrueClass
+  def as_json(_options = nil)
+    self
+  end
+end
+
+class FalseClass
+  def as_json(_options = nil)
+    self
+  end
+end
+
+class NilClass
+  def as_json(_options = nil)
+    self
+  end
+end
+
+class Time
+  def as_json(_options = nil)
+    xmlschema(3)
+  end
+end
+
+class Object
+  def as_json(options = nil)
+    if respond_to?(:attributes)
+      attributes.as_json(options)
+    else
+      instance_variables.each_with_object({}) do |var, hash|
+        key = var.to_s.delete('@').to_sym
+        value = instance_variable_get(var)
+        hash[key] = SportsManager::JsonHelper.convert_value(value)
+      end
+    end
+  end
+end

data/lib/sports_manager/match.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: A category's match with teams, which rounds is ocurring and which
+  # matches its depends on before happening.
+  class Match
+    attr_reader :id, :category, :team1, :team2, :round, :teams, :depends_on
+
+    def self.build_next_match(category:, depends_on:, id: nil, round: 0)
+      new(
+        id: id,
+        category: category,
+        round: round,
+        depends_on: depends_on,
+        team1: NilTeam.new(category: category),
+        team2: NilTeam.new(category: category)
+      )
+    end
+
+    def initialize(category:, id: nil, team1: nil, team2: nil, round: 0, depends_on: []) # rubocop:disable Metrics/ParameterLists
+      @id = id
+      @category = category
+      @team1 = team1
+      @team2 = team2
+      @round = round
+      @teams = [team1, team2].compact
+      @depends_on = depends_on
+    end
+
+    def playable?
+      true
+    end
+
+    def participants
+      @participants ||= teams.map(&:participants).flatten
+    end
+
+    def dependencies?
+      depends_on && !depends_on.empty?
+    end
+
+    def dependencies
+      @dependencies ||= depends_on
+        .flat_map { |match| [match, *match.depends_on] }
+    end
+
+    def playable_dependencies
+      depends_on.select(&:playable?)
+    end
+
+    def previous_matches?
+      previous_matches && !previous_matches.empty?
+    end
+
+    def previous_matches
+      playable_dependencies.flat_map { |match| [match, *match.previous_matches] }
+    end
+
+    def title(title_format: 'M%<id>s')
+      match_participants = if previous_matches?
+        depends_on_names(title_format)
+      else
+        teams_names
+      end
+
+      match_participants.join(' vs. ')
+    end
+
+    def teams_names
+      teams.map(&:name)
+    end
+
+    def ==(other)
+      return false unless instance_of?(other.class)
+
+      id == other.id && category == other.category && round == other.round
+    end
+
+    private
+
+    def depends_on_names(title_format)
+      depends_on.map do |match|
+        if match.playable?
+          format(title_format, id: match.id)
+        else
+          match.teams_names.join(' vs.')
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/match_builder.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: Build matches objects from category, teams, and list of matches.
+  class MatchBuilder
+    attr_reader :category, :matches, :teams, :builded_matches, :tournament_type
+
+    INITIAL_ID = 1
+    DEFAULT_MATCH_CLASS = Match
+    BYE_MATCH_CLASS = ByeMatch
+    NIL_TEAM = NilTeam
+
+    def initialize(category:, matches:, teams:, tournament_type:)
+      @category = category
+      @teams = teams
+      @matches = matches_completer(matches)
+      @builded_matches = []
+      @tournament_type = tournament_type
+    end
+
+    def build
+      return build_already_generated_matches if generated_matches_structure?
+
+      build_matches
+    end
+
+    private
+
+    def participant_ids
+      return matches unless generated_matches_structure?
+
+      matches.map do |match|
+        match[:participants]
+      end
+    end
+
+    def generated_matches_structure?
+      matches&.first.is_a?(Hash)
+    end
+
+    def build_already_generated_matches
+      matches.each do |match|
+        builded_matches << build_match(match_id: match[:id],
+                                       participant_ids: match[:participants] || [],
+                                       round: match[:round] || 0,
+                                       depends_on: match[:depends_on] || [])
+      end
+      builded_matches
+    end
+
+    def build_matches
+      initial_matches | future_matches
+    end
+
+    def initial_matches
+      @initial_matches ||= participant_ids.map.with_index(INITIAL_ID) do |participant_ids, match_id|
+        build_match(match_id: match_id, participant_ids: participant_ids)
+      end
+    end
+
+    def build_match(match_id:, participant_ids:, round: 0, depends_on: [])
+      participant_ids
+        .map { |id| Array(id) }
+        .map { |id_array| find_team(id_array) }
+        .yield_self do |team1, team2|
+        initialize_match(match_id: match_id, teams: [team1, team2], round: round,
+                         depends_on: depends_on, participant_ids: participant_ids)
+      end
+    end
+
+    def find_team(participant_ids)
+      teams.find do |team|
+        team.find_participants(participant_ids)
+      end
+    end
+
+    def initialize_match(match_id:, teams:, round:, depends_on: [], participant_ids: [])
+      klass = match_class(teams: teams, participant_ids: participant_ids)
+      team1, team2 = teams.map { |team| team || NIL_TEAM.new(category: category) }
+
+      depends_on_matches = builded_matches.map do |match|
+        depends_on.include?(match.id) ? match : nil
+      end.compact
+
+      klass.new(category: category, team1: team1, team2: team2, id: match_id, round: round,
+                depends_on: depends_on_matches)
+    end
+
+    def match_class(teams:, participant_ids:)
+      return BYE_MATCH_CLASS if teams.any?(&:nil?) && participant_ids.size == 1
+
+      DEFAULT_MATCH_CLASS
+    end
+
+    def future_matches
+      Matches::NextRound
+        .new(category: category, base_matches: initial_matches, algorithm: tournament_type)
+        .next_matches
+    end
+
+    def subscriptions_ids
+      teams.select { |team| team.category == category }
+        .map { |team| team.participants.map(&:id) }
+    end
+
+    def matches_completer(matches)
+      return MatchesGenerator.call(subscriptions_ids) if matches.nil? || matches.empty?
+
+      matches
+    end
+  end
+end

data/lib/sports_manager/matches/algorithms/single_elimination_algorithm.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Matches
+    module Algorithms
+      # TODO: implement
+      # Public: Algorithm for building the rounds and matches in a
+      # Single Elimination Tournament. This format is also known as Knockout
+      class SingleEliminationAlgorithm
+        attr_reader :category, :opening_round_matches, :opening_round_size
+
+        def initialize(category:, matches:)
+          @category = category
+          @opening_round_matches = matches
+          @opening_round_size = matches.size
+        end
+
+        # TODO: BYE, odd matches
+        def next_matches
+          return @next_matches if defined? @next_matches
+
+          matches = opening_round_matches.dup
+
+          remaining_matches.times.reduce(0) do |count, _|
+            team1 = count
+            team2 = team1 + 1
+
+            matches << build_next_match(matches[team1], matches[team2], matches.size + 1)
+
+            team2 + 1
+          end
+
+          @next_matches = matches - opening_round_matches
+        end
+
+        # TODO: make use of it later
+        def needs_bye?
+          !power_of_two?
+        end
+
+        # Internal: The number of matches required to find a winner, without a
+        # third place match, is the number of players/teams minus one.
+        def total_matches
+          return 0 if teams_size.zero?
+
+          teams_size - 1
+        end
+
+        # Internal: The number of rounds is the closest Log2N for N players.
+        def total_rounds
+          return 0 if teams_size.zero?
+
+          Math.log2(teams_size).ceil
+        end
+
+        def round_for_match(match_number)
+          return 0 if match_number.zero? || opening_round_size.zero?
+
+          rounds = total_rounds
+
+          (1..rounds).each do |round|
+            matches_in_round = 2**(rounds - round)
+
+            return round if match_number <= matches_in_round
+
+            match_number -= matches_in_round
+          end
+        end
+
+        private
+
+        def teams_size
+          @teams_size ||= opening_round_size * 2
+        end
+
+        def power_of_two?
+          opening_round_size.to_s(2).count('1') == 1
+        end
+
+        def remaining_matches
+          total_matches - opening_round_size
+        end
+
+        def build_next_match(match1, match2, id)
+          depends_on = [match1, match2]
+          dependencies = depends_on.map(&:depends_on).flatten
+          round = dependencies && !dependencies.empty? ? (dependencies.size / 2) : 1
+
+          Match.build_next_match(category: category, depends_on: depends_on, round: round, id: id)
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/matches/next_round.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SportsManager
+  module Matches
+    # Public: Determinates the next rounds and their dependencies
+    class NextRound
+      attr_reader :category, :base_matches, :match_maker
+
+      # NOTE: maybe move logic to class method and just return the algorithm
+      # NOTE: maybe keep it if mixing multiple formats and put decision logic in here
+      # TODO: implement round-robin
+      # TODO: implement to consider: start w round-robin followed by knockout
+      DEFAULT_ALGORITHM = Algorithms::SingleEliminationAlgorithm
+
+      def initialize(category:, base_matches:, algorithm: DEFAULT_ALGORITHM)
+        @category = category
+        @base_matches = base_matches
+        @match_maker = algorithm.new(category: category, matches: base_matches)
+      end
+
+      def next_matches
+        match_maker.next_matches
+      end
+
+      def total_matches
+        match_maker.total_matches
+      end
+
+      def total_rounds
+        match_maker.total_rounds
+      end
+
+      def round_for_match(match_number)
+        match_maker.round_for_match(match_number)
+      end
+    end
+  end
+end