sports-manager 0.0.1

data/lib/sports_manager/matches_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class MatchesGenerator
+    def self.call(subscriptions_ids)
+      new(subscriptions_ids).call
+    end
+
+    def initialize(subscriptions_ids)
+      @subscriptions_ids = subscriptions_ids
+    end
+
+    def call
+      generate_matches(@subscriptions_ids)
+    end
+
+    private
+
+    attr_reader :subscriptions
+
+    def generate_matches(subscriptions_ids)
+      list = subscriptions_ids.dup
+      size = subscriptions_ids.size
+
+      number_of_matches = size.even? ? (size / 2) : ((size / 2) + 1)
+
+      number_of_matches.times.map do
+        match = [list.shift, list.pop].compact
+        match unless match.empty?
+      end.compact
+    end
+  end
+end

data/lib/sports_manager/nil_team.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: A representation of no Team used by next round matches that don't
+  # have a winner set yet.
+  class NilTeam
+    attr_reader :category, :participants
+
+    def initialize(category:)
+      @category = category
+      @participants = []
+    end
+
+    def name
+      ''
+    end
+
+    def ==(other)
+      return false unless instance_of? other.class
+
+      category == other.category
+    end
+  end
+end

data/lib/sports_manager/participant.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SportsManager
+  # Public: A team's player in a tournament
+  class Participant
+    include Comparable
+
+    attr_reader :id, :name
+
+    alias eql? <=>
+
+    def initialize(id:, name:)
+      @id = id
+      @name = name
+    end
+
+    def <=>(other)
+      return unless instance_of?(other.class)
+
+      id <=> other.id
+    end
+  end
+end

data/lib/sports_manager/single_team.rb

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

data/lib/sports_manager/solution_drawer/cli/solution_table.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class CLI
+      class SolutionTable
+        TIME_TEMPLATE = '%d/%m at %H:%M'
+
+        attr_reader :fixtures
+
+        def initialize(solution)
+          @fixtures = solution.fixtures
+        end
+
+        def draw
+          Table.draw(formatted_fixtures)
+        end
+
+        private
+
+        def formatted_fixtures
+          fixtures.map(&method(:serialized_fixture))
+        end
+
+        def serialized_fixture(fixture)
+          {
+            category: fixture.category,
+            id: fixture.match_id,
+            round: fixture.round,
+            participants: fixture.title,
+            court: fixture.court,
+            time: fixture.slot.strftime(TIME_TEMPLATE)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/solution_drawer/cli/table.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class CLI
+      # Public: creates a table based on a list of hashes containing the
+      # name of the columns and their values
+      #
+      # Example:
+      # data = [
+      #   { a: [1, 2, 3],    b: 10_000,     c: 'ABCDEFGHIJKLMNOP' },
+      #   { a: [4, 5, 6, 7], b: 20_000_000, c: 'QRSTUVWXYZ' }
+      # ]
+      #
+      #       a       |    b     |        c
+      #  -------------|----------|-----------------
+      #  1, 2, 3      | 10000    | ABCDEFGHIJKLMNOP
+      #  4, 5, 6, 7   | 20000000 | QRSTUVWXYZ
+      class Table
+        attr_reader :data
+
+        SECTION_SEPARATOR = '-|-'
+        COLUMN_SEPARATOR = ' | '
+        ROW_SEPARATOR = '-'
+
+        def self.draw(data)
+          new(data).draw
+        end
+
+        def initialize(data)
+          @data = data
+        end
+
+        def draw
+          [header_row, separator, *content_rows].join("\n")
+        end
+
+        private
+
+        def header
+          @header ||= data.flat_map(&:keys).uniq
+        end
+
+        def header_row
+          header
+            .map { |column| column.to_s.center(widths[column]) }
+            .join(COLUMN_SEPARATOR)
+        end
+
+        def separator
+          header
+            .map { |column| ROW_SEPARATOR * widths[column] }
+            .join(SECTION_SEPARATOR)
+        end
+
+        def content_rows
+          data
+            .map(&method(:row_content))
+            .map { |row| row.join(COLUMN_SEPARATOR) }
+        end
+
+        def row_content(row)
+          row.map do |(column, value)|
+            column_padding = widths[column]
+
+            Array(value)
+              .join(', ')
+              .ljust(column_padding)
+          end
+        end
+
+        # Internal: sets the longest width for each column
+        def widths
+          @widths ||= data
+            .flat_map(&:to_a)
+            .each_with_object(headers_width) do |(key, value), columns_width|
+            column_size = columns_width[key].to_i
+            value_size = value.to_s.size
+
+            columns_width[key] = [column_size, value_size].max
+          end
+        end
+
+        # Internal: sets the starting width for each column based on
+        # their names
+        def headers_width
+          header.each_with_object({}) do |column, width|
+            width[column.to_sym] = column.to_s.size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports_manager/solution_drawer/cli.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    # Public: Outputs the tournament's timetable solutions to stdout
+    # TODO: allow to pass which stdout will be used. puts|Logger|other
+    class CLI
+      extend Forwardable
+
+      attr_reader :tournament_solution
+
+      def_delegators :tournament_solution, :solutions,
+                     :total_solutions, :solved?
+
+      NO_SOLUTION = 'No solution found'
+      START_NUMBER = 1
+
+      def self.draw(tournament_solution)
+        new(tournament_solution).draw
+      end
+
+      def initialize(tournament_solution)
+        @tournament_solution = tournament_solution
+      end
+
+      def draw
+        no_solution || draw_solutions
+      end
+
+      private
+
+      def no_solution
+        return false if solved?
+
+        puts NO_SOLUTION
+
+        true
+      end
+
+      def draw_solutions
+        puts(
+          output_header,
+          output_solutions,
+          output_footer
+        )
+      end
+
+      def output_header
+        "Tournament Timetable:\n\n"
+      end
+
+      def output_solutions
+        solutions_tables.join("\n")
+      end
+
+      def output_footer
+        "Total solutions: #{total_solutions}"
+      end
+
+      def solutions_tables
+        solutions.map.with_index(START_NUMBER, &method(:draw_solution))
+      end
+
+      def draw_solution(solution, number)
+        table_data = SolutionTable.new(solution).draw
+
+        <<~MESSAGE
+          Solution #{number}
+          #{table_data}
+
+        MESSAGE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class Mermaid
+      class ByeNode
+        extend Forwardable
+
+        attr_reader :fixture
+
+        def_delegators :fixture, :match_id, :category, :title
+
+        def initialize(fixture)
+          @fixture = fixture
+        end
+
+        def name
+          "#{category}_#{match_id}"
+        end
+
+        def definition
+          "#{name}[\"#{description}\"]:::#{style_class}"
+        end
+
+        def style_class
+          'court'
+        end
+
+        def description
+          "#{match_id}\\n#{title}"
+        end
+
+        def links?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class Mermaid
+      class Gantt
+        extend Forwardable
+
+        attr_reader :configurations
+
+        DISPLAY_MODE = {
+          compact: 'compact',
+          empty: nil
+        }.freeze
+
+        FIELDS = %i[
+          display_mode
+          title
+          date_format
+          axis_format
+          tick_interval
+          sections
+        ].freeze
+
+        DEFAULT_CONFIGURATIONS = {
+          display_mode: :compact,
+          title: 'Tournament Schedule',
+          date_format: 'DD/MM HH:mm',
+          axis_format: '%H:%M',
+          tick_interval: '1hour',
+          sections: ''
+        }.freeze
+
+        TEMPLATE = <<~GANTT.chomp
+          ---
+          displayMode: %<display_mode>s
+          ---
+          gantt
+            title %<title>s
+            dateFormat %<date_format>s
+            axisFormat %<axis_format>s
+            tickInterval %<tick_interval>s
+
+          %<sections>s
+        GANTT
+
+        TASK_TEMPLATE = '    %<id>s: %<time>s, %<interval>s'
+
+        def self.draw(configurations = {})
+          new
+            .add_configurations(configurations)
+            .draw
+        end
+
+        def initialize
+          @configurations = {}
+        end
+
+        def draw
+          format(TEMPLATE, gantt_configurations)
+        end
+
+        def add_display_mode(mode = :compact)
+          configurations[:display_mode] = DISPLAY_MODE[mode.to_sym]
+
+          self
+        end
+
+        def add_title(title)
+          configurations[:title] = title
+
+          self
+        end
+
+        def add_date_format(format)
+          configurations[:date_format] = format
+
+          self
+        end
+
+        def add_axis_format(format)
+          configurations[:axis_format] = format
+
+          self
+        end
+
+        def add_tick_interval(format)
+          configurations[:tick_interval] = format
+
+          self
+        end
+
+        def add_sections(sections_tasks)
+          configurations[:sections] = sections_tasks
+            .map { |(section, tasks)| build_section(section, tasks) }
+            .join("\n")
+
+          self
+        end
+
+        def add_configurations(configurations)
+          configurations.slice(*FIELDS).each do |field, value|
+            public_send("add_#{field}", value)
+          end
+
+          self
+        end
+
+        private
+
+        def gantt_configurations
+          DEFAULT_CONFIGURATIONS
+            .merge(configurations)
+            .slice(*FIELDS)
+        end
+
+        def build_section(section, tasks)
+          section_name = "  section #{section}"
+          section_tasks = tasks.map { |fields| format(TASK_TEMPLATE, fields) }
+
+          [section_name, section_tasks].join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class Mermaid
+      class Graph
+        attr_reader :configurations
+
+        FIELDS = %i[
+          subgraphs
+          class_definitions
+          subgraph_colorscheme
+        ].freeze
+
+        TEMPLATE = <<~GRAPH.chomp
+          graph LR
+          %<class_definitions>s
+          %<subgraph_colorscheme>s
+          %<subgraphs>s
+        GRAPH
+
+        SUBGRAPH = <<~GRAPH.chomp
+          subgraph %<name>s
+            direction LR
+
+            %<nodes>s
+          end
+        GRAPH
+
+        STYLE = <<~GRAPH.chomp
+          classDef %<class_definition>s
+        GRAPH
+
+        # TODO: move to class and make dynamic based on input
+        DEFAULT_STYLE_CONFIGURATIONS = {
+          class_definitions: [
+            'court0 fill:#a9f9a9',
+            'court1 fill:#4ff7de',
+            'court_default fill:#aff7de'
+          ],
+          subgraph_colorscheme: [
+            'COURT_0:::court0',
+            'COURT_1:::court1',
+            'COURT:::court_default',
+            'COURT_0 --- COURT_1 --- COURT'
+          ]
+        }.freeze
+
+        def self.draw(configurations = {})
+          new
+            .add_configurations(configurations)
+            .draw
+        end
+
+        def initialize
+          @configurations = {}
+        end
+
+        def draw
+          format(TEMPLATE, graph_configurations)
+        end
+
+        def add_configurations(configurations)
+          DEFAULT_STYLE_CONFIGURATIONS
+            .merge(configurations)
+            .slice(*FIELDS)
+            .each { |field, value| public_send("add_#{field}", value) }
+
+          self
+        end
+
+        def add_subgraphs(subgraphs)
+          configurations[:subgraphs] = subgraphs
+            .map { |(name, nodes)| build_subgraph(name, nodes) }
+            .join("\n")
+
+          self
+        end
+
+        def add_class_definitions(class_definitions)
+          configurations[:class_definitions] = class_definitions
+            .map { |class_definition| format(STYLE, class_definition: class_definition) }
+            .join("\n")
+
+          self
+        end
+
+        def add_subgraph_colorscheme(subgraph_colorscheme)
+          nodes = subgraph_colorscheme.join("\n  ")
+          colorscheme = format(SUBGRAPH, name: 'colorscheme', nodes: nodes)
+
+          configurations[:subgraph_colorscheme] = colorscheme
+
+          self
+        end
+
+        private
+
+        def graph_configurations
+          configurations.slice(*FIELDS)
+        end
+
+        def build_subgraph(name, nodes)
+          subgraph_nodes = nodes.join("\n  ")
+
+          format(SUBGRAPH, name: name, nodes: subgraph_nodes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SportsManager
+  class SolutionDrawer
+    class Mermaid
+      class Node
+        extend Forwardable
+        TIME_TEMPLATE = '%d/%m %H:%M'
+
+        attr_reader :fixture
+
+        def_delegators :fixture, :match_id, :category, :title, :court
+
+        def self.for(fixture)
+          node_class = fixture.playable? ? self : ByeNode
+
+          node_class.new(fixture)
+        end
+
+        def initialize(fixture)
+          @fixture = fixture
+        end
+
+        def name
+          "#{category}_#{match_id}"
+        end
+
+        # Internal: my_node[This is a node]:::awesome_style
+        def definition
+          "#{name}[#{description}]:::#{style_class}"
+        end
+
+        def style_class
+          "court#{court}"
+        end
+
+        def description
+          "#{match_id}\\n#{title}\\n#{slot}"
+        end
+
+        def slot
+          fixture.slot.strftime(TIME_TEMPLATE)
+        end
+
+        def links?
+          fixture.dependencies?
+        end
+
+        def depends_on?(node)
+          fixture.depends_on?(node.fixture)
+        end
+      end
+    end
+  end
+end