sports-manager 0.0.1

data/lib/sports_manager/solution_drawer/mermaid/node_style.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class Mermaid
+      class NodeStyle
+        # TODO: Add an algorithms to dynamically create the colors
+        COLORS = %w[
+          #A9F9A9 #4FF7DE #FF6E41
+          #5FAD4E #009BFF #00FF00
+          #FF0000 #01FFFE #FFA6FE
+          #FFDB66 #006401 #010067
+          #95003A #007DB5 #FF00F6
+          #FFEEE8 #774D00 #90FB92
+          #0076FF #D5FF00 #FF937E
+          #6A826C #FF029D #FE8900
+          #7A4782 #7E2DD2 #85A900
+          #FF0056 #A42400 #00AE7E
+          #683D3B #BDC6FF #263400
+          #BDD393 #00B917 #9E008E
+          #001544 #C28C9F #FF74A3
+          #01D0FF #004754 #E56FFE
+          #788231 #0E4CA1 #91D0CB
+          #BE9970 #968AE8 #BB8800
+          #43002C #DEFF74 #00FFC6
+          #FFE502 #620E00 #008F9C
+          #98FF52 #7544B1 #B500FF
+          #00FF78 #005F39 #6B6882
+          #A75740 #A5FFD2 #FFB167
+        ].freeze
+
+        attr_reader :elements
+
+        def self.call(elements)
+          new(elements).to_params
+        end
+
+        def initialize(elements)
+          @elements = elements.map(&:to_s)
+        end
+
+        def to_params
+          { class_definitions: class_definitions, subgraph_colorscheme: subgraph_colorscheme }
+        end
+
+        def subgraph_colorscheme
+          elements.map do |element|
+            node_name = element.upcase
+            style_class = element
+
+            "#{node_name}:::#{style_class}"
+          end
+        end
+
+        def class_definitions
+          colorscheme.map do |element, properties|
+            attributes = properties
+              .map { |property| property.join(':') }
+              .join(', ')
+            "#{element} #{attributes}"
+          end
+        end
+
+        def colorscheme
+          elements.each_with_index.with_object({}) do |(element, index), scheme|
+            node_color = COLORS[index]
+            text_color = text_color(node_color)
+
+            scheme[element] = { fill: node_color, color: text_color }
+          end
+        end
+
+        # Internal: ripoff from stackoverflow
+        def text_color(color)
+          red, green, blue = color
+            .gsub('#', '')
+            .chars
+            .each_slice(2)
+            .map(&:join)
+            .map(&:hex)
+
+          formula = (red * 0.299) + (green * 0.587) + (blue * 0.114)
+
+          formula > 186 ? '#000000' : '#FFFFFF'
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/solution_drawer/mermaid/solution_gantt.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class Mermaid
+      class SolutionGantt
+        extend Forwardable
+
+        TIME_TEMPLATE = '%d/%m %H:%M'
+        TIME_INTERVAL = '1h' # TODO: make it dynamic
+
+        attr_reader :solution
+
+        def_delegators :solution, :fixtures, :acronyms
+
+        def self.draw(solution)
+          new(solution).draw
+        end
+
+        def initialize(solution)
+          @solution = solution
+        end
+
+        def draw
+          Gantt.draw(sections: sections)
+        end
+
+        def sections
+          fixtures
+            .group_by(&:court)
+            .yield_self { |sections_fixtures| build_sections(sections_fixtures) }
+        end
+
+        private
+
+        def build_sections(sections_fixtures)
+          sections_fixtures.transform_values do |fixtures|
+            fixtures.map(&method(:build_task))
+          end
+        end
+
+        def build_task(fixture)
+          category = fixture.category
+          match_id = fixture.match_id
+          slot = fixture.slot
+
+          category_acronym = acronyms[category].upcase
+          id = "#{category_acronym} M#{match_id}"
+          interval = TIME_INTERVAL
+          time = slot.strftime(TIME_TEMPLATE)
+
+          { id: id, interval: interval, time: time }
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/solution_drawer/mermaid/solution_graph.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class Mermaid
+      class SolutionGraph
+        attr_reader :solution
+
+        STYLE_CLASS_DEFINITION = '%<name> fill:%<fill>, color:%<color>'
+
+        LinkNode = Struct.new(:node_hash) do
+          def definition
+            "#{node_hash[:previous_name]} --> #{node_hash[:next_name]}"
+          end
+        end
+
+        def self.draw(solution)
+          new(solution).draw
+        end
+
+        def initialize(solution)
+          @solution = solution
+        end
+
+        def draw
+          Graph.draw(subgraphs: subgraphs, **node_style)
+        end
+
+        private
+
+        def subgraphs
+          solution
+            .fixtures_dependencies_by_category
+            .yield_self(&method(:build_subgraphs))
+            .yield_self(&method(:serialize))
+        end
+
+        def build_subgraphs(categories_fixtures)
+          categories_fixtures
+            .transform_values { |fixtures| build_nodes(fixtures) }
+            .transform_values { |nodes| (nodes | build_links(nodes)) }
+        end
+
+        def build_nodes(fixtures)
+          fixtures
+            .sort_by(&:match_id)
+            .map { |fixture| Node.for(fixture) }
+        end
+
+        def build_links(nodes)
+          nodes
+            .select(&:links?)
+            .flat_map { |linked_node| build_link(linked_node, nodes) }
+        end
+
+        def build_link(linked_node, nodes)
+          new_nodes = nodes
+            .select { |node| linked_node.depends_on?(node) }
+
+          new_nodes.map do |previous_node|
+            LinkNode.new({ previous_name: previous_node.name, next_name: linked_node.name })
+          end
+        end
+
+        def serialize(graph)
+          graph.transform_values { |nodes| nodes.map(&:definition) }
+        end
+
+        def node_style
+          courts = solution.courts.map { |n| "court#{n}" }
+          NodeStyle.call(courts)
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/solution_drawer/mermaid.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    # Public: draws the tournament solution to mermaid's charts
+    class Mermaid
+      extend Forwardable
+
+      attr_reader :tournament_solution
+
+      def_delegators :tournament_solution, :solutions,
+                     :total_solutions, :solved?
+
+      NO_SOLUTION = 'No solution found'
+
+      def self.draw(tournament_solution)
+        new(tournament_solution).draw
+      end
+
+      def initialize(tournament_solution)
+        @tournament_solution = tournament_solution
+      end
+
+      def draw
+        no_solution || draw_solution
+      end
+
+      private
+
+      def no_solution
+        return false if solved?
+
+        puts NO_SOLUTION
+
+        true
+      end
+
+      def draw_solution
+        puts 'Solutions:'
+        solutions.map.with_index(1, &method(:draw_all))
+        puts "Total solutions: #{total_solutions}"
+      end
+
+      def draw_all(solution, index)
+        puts '-' * 80
+        puts "Solutions #{index}"
+
+        puts 'Gantt:'
+        puts gantt(solution)
+
+        puts 'Graph:'
+        puts graph(solution)
+        puts '-' * 80
+      end
+
+      def gantt(solution)
+        SolutionGantt.new(solution).draw
+      end
+
+      def graph(solution)
+        SolutionGraph.new(solution).draw
+      end
+    end
+  end
+end

data/lib/sports_manager/solution_drawer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    attr_reader :tournament_solution
+
+    def initialize(tournament_solution)
+      @tournament_solution = tournament_solution
+    end
+
+    def none; end
+
+    def mermaid
+      Mermaid.draw(tournament_solution)
+    end
+
+    def cli
+      CLI.draw(tournament_solution)
+    end
+
+    # TODO: create json method | create class | move serialize class too
+  end
+end

data/lib/sports_manager/team.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: Participants in a team for a tournament category
+  class Team
+    attr_reader :category, :participants
+
+    def self.for(participants:, category:)
+      klass = case participants.size
+              when 1 then SingleTeam
+              when 2 then DoubleTeam
+              else raise StandardError,
+                         "Participants #{participants} is not " \
+                         'between 1 and 2'
+      end
+
+      klass.new(participants: participants, category: category)
+    end
+
+    def initialize(participants:, category: nil)
+      @category = category
+      @participants = participants
+    end
+
+    def name
+      participants
+        .flat_map(&:name)
+        .join(' e ')
+    end
+
+    def find_participant(id)
+      participants.find { |participant| participant.id == id }
+    end
+
+    def find_participants(ids)
+      unique_ids = ids.uniq
+      found_participants = unique_ids.map(&method(:find_participant)).compact
+      found_participants if found_participants.size == unique_ids.size
+    end
+
+    def ==(other)
+      instance_of?(other.class) &&
+        category == other.category &&
+        participants == other.participants
+    end
+  end
+end

data/lib/sports_manager/team_builder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class TeamBuilder
+    attr_reader :category, :subscriptions, :participants
+
+    def initialize(category:, subscriptions:)
+      @category = category
+      @subscriptions = subscriptions
+      @participants = subscriptions.flatten
+    end
+
+    def build
+      subscriptions.map(&method(:build_team))
+    end
+
+    private
+
+    def build_team(team)
+      team_participants = Utils::Array
+        .wrap(team)
+        .map { |participant| build_participant(participant) }
+
+      Team.for(category: category, participants: team_participants)
+    end
+
+    def build_participant(participant)
+      Participant.new(**participant)
+    end
+  end
+end

data/lib/sports_manager/timeslot.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: A available time in a court that can be scheduled
+  class Timeslot
+    include Comparable
+
+    attr_reader :court, :slot, :date
+
+    alias hour slot
+
+    def initialize(court:, date:, slot:)
+      @court = court
+      @date = date
+      @slot = slot
+    end
+
+    # TODO: timezone
+    def datetime
+      return slot if slot.is_a? Time
+
+      @datetime ||= DateTime.parse("#{date} #{hour}:00:00")
+    end
+
+    def <=>(other)
+      return false unless instance_of?(other.class)
+
+      datetime <=> other.datetime
+    end
+
+    def ==(other)
+      instance_of?(other.class) &&
+        court == other.court &&
+        datetime == other.datetime
+    end
+  end
+end

data/lib/sports_manager/timeslot_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # NOTE: maybe change the name since we are not creating a Timeslot object here
+  # Public: Builds the possible timeslots as Time objects
+  class TimeslotBuilder
+    require 'time'
+    require 'forwardable'
+    extend Forwardable
+
+    attr_reader :tournament_day
+
+    def_delegators :tournament_day, :start_hour, :end_hour, :date
+
+    def self.build(tournament_day:, interval:)
+      new(tournament_day: tournament_day, interval: interval).build
+    end
+
+    def initialize(tournament_day:, interval:)
+      @tournament_day = tournament_day
+      @interval = interval
+    end
+
+    def build
+      time_range.step(interval).map(&Time.method(:at))
+    end
+
+    private
+
+    def time_range
+      (start_time.to_i..end_time.to_i)
+    end
+
+    def interval
+      @interval * 60
+    end
+
+    def start_time
+      parse_time(start_hour)
+    end
+
+    def end_time
+      parse_time(end_hour)
+    end
+
+    def parse_time(time)
+      Time.parse("#{date}T#{time}:00:00")
+    end
+  end
+end

data/lib/sports_manager/tournament/setting.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class Tournament
+    # Public: The tournament's configurations
+    class Setting
+      attr_reader :match_time, :break_time, :courts, :tournament_days, :single_day_matches
+
+      def initialize(match_time:, break_time:, courts:, tournament_days:, single_day_matches:)
+        @match_time = match_time
+        @break_time = break_time
+        @courts = courts
+        @tournament_days = tournament_days
+        @single_day_matches = single_day_matches
+      end
+
+      def ==(other)
+        return false unless instance_of?(other.class)
+
+        match_time == other.match_time &&
+          break_time == other.break_time &&
+          courts == other.courts &&
+          tournament_days == other.tournament_days &&
+          single_day_matches == other.single_day_matches
+      end
+
+      def timeslots
+        @timeslots ||= tournament_days.flat_map(&method(:build_day_slots))
+      end
+
+      def court_list
+        @court_list ||= courts.times.to_a
+      end
+
+      private
+
+      def build_day_slots(tournament_day)
+        tournament_day
+          .timeslots(interval: break_time)
+          .yield_self { |slots| court_list.product(slots) }
+          .map { |(court, slot)| Timeslot.new(court: court, date: tournament_day, slot: slot) }
+      end
+    end
+  end
+end

data/lib/sports_manager/tournament.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: A tournament with different categories matches
+  class Tournament
+    extend Forwardable
+
+    attr_reader :settings, :groups
+
+    def_delegators :settings, :match_time, :break_time, :courts, :timeslots,
+                   :single_day_matches, :tournament_days
+
+    def initialize(settings: nil, groups: nil)
+      @settings = settings
+      @groups = groups
+    end
+
+    def ==(other)
+      settings == other.settings && groups == other.groups
+    end
+
+    def categories
+      @categories ||= groups.map(&:category)
+    end
+
+    def matches
+      @matches ||= groups.each_with_object({}) do |group, category_matches|
+        category_matches[group.category] = group.matches
+      end
+    end
+
+    def first_round_matches
+      categories.each_with_object({}) do |category, first_rounds|
+        first_rounds[category] = find_matches(category: category, round: 0)
+      end
+    end
+
+    def find_matches(category:, round:)
+      category_matches = groups
+        .find { |group| group.category == category }
+        &.find_matches(round)
+
+      category_matches || []
+    end
+
+    def total_matches
+      matches.values.map(&:size).sum
+    end
+
+    def participants
+      @participants ||= all_participants.uniq(&:id)
+    end
+
+    def multi_tournament_participants
+      @multi_tournament_participants ||= participants
+        .select { |participant| all_participants.count(participant) > 1 }
+    end
+
+    def find_participant_matches(participant)
+      groups.flat_map { |group| group.find_participant_matches(participant) }
+    end
+
+    private
+
+    def all_participants
+      @all_participants ||= groups.map(&:participants).flatten
+    end
+  end
+end