basketball 0.0.4 → 0.0.6

data/lib/basketball/scheduling/cli.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative 'calendar_serializer'
+require_relative 'conference'
+require_relative 'coordinator'
+require_relative 'division'
+require_relative 'league'
+require_relative 'league_serializer'
+require_relative 'team'
+
+module Basketball
+  module Scheduling
+    # Examples:
+    #   exe/basketball-schedule -o tmp/league.json
+    #   exe/basketball-schedule -i tmp/league.json -o tmp/calendar.json
+    #   exe/basketball-schedule -i tmp/league.json -o tmp/calendar.json -y 2005
+    #   exe/basketball-schedule -c tmp/calendar.json
+    #   exe/basketball-schedule -c tmp/calendar.json -t C0-D0-T0
+    #   exe/basketball-schedule -c tmp/calendar.json -d 2005-02-03
+    #   exe/basketball-schedule -c tmp/calendar.json -d 2005-02-03 -t C0-D0-T0
+    class CLI
+      attr_reader :opts,
+                  :league_serializer,
+                  :calendar_serializer,
+                  :io,
+                  :coordinator
+
+      def initialize(args:, io: $stdout)
+        @io                  = io
+        @opts                = slop_parse(args)
+        @league_serializer   = LeagueSerializer.new
+        @calendar_serializer = CalendarSerializer.new
+        @coordinator         = Coordinator.new
+
+        freeze
+      end
+
+      def invoke!
+        if output?
+          out_dir = File.dirname(output)
+          FileUtils.mkdir_p(out_dir)
+        end
+
+        if output? && no_input?
+          execute_with_no_input
+        elsif output?
+          execute_with_input
+        end
+
+        output_cal_query if cal
+
+        self
+      end
+
+      private
+
+      def output_cal_query
+        contents      = File.read(cal)
+        calendar      = calendar_serializer.deserialize(contents)
+        team_instance = team ? calendar.team(team) : nil
+        games         = calendar.games_for(date:, team: team_instance).sort_by(&:date)
+        pre_counter   = 1
+        counter       = 1
+
+        io.puts("Games for [team: #{team}, date: #{date}]")
+        games.each do |game|
+          if game.is_a?(PreseasonGame)
+            io.puts("##{pre_counter} - #{game}")
+            pre_counter += 1
+          else
+            io.puts("##{counter} - #{game}")
+            counter += 1
+          end
+        end
+      end
+
+      def execute_with_input
+        io.puts("Loading league from: #{input}")
+
+        contents = File.read(input)
+        league   = league_serializer.deserialize(contents)
+
+        io.puts("Generating calendar for the year #{year}...")
+
+        calendar = coordinator.schedule(league:, year:)
+        contents = calendar_serializer.serialize(calendar)
+
+        File.write(output, contents)
+
+        io.puts("Calendar written to: #{output}")
+      end
+
+      def execute_with_no_input
+        league   = generate_league
+        contents = league_serializer.serialize(league)
+
+        File.write(output, contents)
+
+        io.puts("League written to: #{output}")
+      end
+
+      def cal
+        opts[:cal].to_s.empty? ? nil : opts[:cal]
+      end
+
+      def team
+        opts[:team].to_s.empty? ? nil : opts[:team]
+      end
+
+      def date
+        opts[:date].to_s.empty? ? nil : Date.parse(opts[:date])
+      end
+
+      def year
+        opts[:year].to_s.empty? ? Date.today.year : opts[:year]
+      end
+
+      def no_input?
+        input.to_s.empty?
+      end
+
+      def input
+        opts[:input]
+      end
+
+      def output?
+        !output.to_s.empty?
+      end
+
+      def output
+        opts[:output]
+      end
+
+      def generate_conferences
+        2.times.map do |i|
+          id = "C#{i}"
+
+          Conference.new(
+            id:,
+            name: Faker::Esport.league,
+            divisions: generate_divisions("#{id}-")
+          )
+        end
+      end
+
+      def generate_divisions(id_prefix)
+        3.times.map do |j|
+          id = "#{id_prefix}D#{j}"
+
+          Division.new(
+            id:,
+            name: Faker::Address.community,
+            teams: generate_teams("#{id}-")
+          )
+        end
+      end
+
+      def generate_teams(id_prefix)
+        5.times.map do |k|
+          Team.new(
+            id: "#{id_prefix}T#{k}",
+            name: Faker::Team.name
+          )
+        end
+      end
+
+      def generate_league
+        League.new(conferences: generate_conferences)
+      end
+
+      def slop_parse(args)
+        Slop.parse(args) do |o|
+          o.banner = 'Usage: basketball-schedule [options] ...'
+
+          output_description = <<~DESC
+            If input path is omitted then a new league will be written to this path.
+            If an input path is specified then a Calendar will be written to the output path.
+          DESC
+
+          # League and Calendar Generation Interface
+          o.string  '-i', '--input',  'Path to load the League from. If omitted then a new league will be generated.'
+          o.string  '-o', '--output', output_description
+          o.integer '-y', '--year',   'Year to use to generate a calendar for (defaults to current year).'
+
+          # Calendar Query Interface
+          o.string  '-c', '--cal',  'Path to load a Calendar from. If omitted then no matchups will be outputted.'
+          o.string  '-d', '--date', 'Filter matchups to just the date specified (requires --cal option).'
+          o.string  '-t', '--team', 'Filter matchups to just the team ID specified (requires --cal option).'
+
+          o.on '-h', '--help', 'Print out help, like this is doing right now.' do
+            io.puts(o)
+            exit
+          end
+        end.to_h
+      end
+    end
+  end
+end

data/lib/basketball/scheduling/conference.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Scheduling
+    class Conference < Entity
+      DIVISIONS_SIZE = 3
+
+      attr_reader :name, :divisions
+
+      def initialize(id:, name: '', divisions: [])
+        super(id)
+
+        @name      = name.to_s
+        @divisions = []
+
+        divisions.each { |d| register_division!(d) }
+
+        if divisions.length != DIVISIONS_SIZE
+          raise BadDivisionsSizeError, "#{id} should have exactly #{DIVISIONS_SIZE} divisions"
+        end
+
+        freeze
+      end
+
+      def to_s
+        (["[#{super}] #{name}"] + divisions.map(&:to_s)).join("\n")
+      end
+
+      def division?(division)
+        divisions.include?(division)
+      end
+
+      def teams
+        divisions.flat_map(&:teams)
+      end
+
+      def team?(team)
+        teams.include?(team)
+      end
+
+      private
+
+      def register_division!(division)
+        raise ArgumentError, 'division is required' unless division
+        raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
+
+        division.teams.each do |team|
+          raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
+        end
+
+        divisions << division
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/scheduling/coordinator.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative 'calendar'
+
+module Basketball
+  module Scheduling
+    # This is the service class responsible for actually picking out free dates ane pairing up teams to
+    # play each other.  This is a reasonable naive first pass at some underlying match-making algorithms
+    # but could definitely use some help with the complexity/runtime/etc.
+    class Coordinator
+      MIN_PRESEASON_GAMES_PER_TEAM = 4
+      MAX_PRESEASON_GAMES_PER_TEAM = 6
+
+      private_constant :MIN_PRESEASON_GAMES_PER_TEAM,
+                       :MAX_PRESEASON_GAMES_PER_TEAM
+
+      def schedule(year:, league:)
+        Calendar.new(year:).tap do |calendar|
+          schedule_preseason!(calendar:, league:)
+          schedule_season!(calendar:, league:)
+        end
+      end
+
+      private
+
+      def base_matchup_count(league, team1, team2)
+        # Same Conference, Same Division
+        if league.division_for(team1) == league.division_for(team2)
+          4
+        # Same Conference, Different Division  and one of 4/10 that play 3 times
+        elsif league.conference_for(team1) == league.conference_for(team2)
+          3
+        # Different Conference
+        else
+          2
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # This method derives the plan for which a schedule can be generated from.
+      def matchup_plan(league)
+        matchups    = {}
+        game_counts = league.teams.to_h { |t| [t, 0] }
+        teams       = game_counts.keys
+
+        (0...teams.length).each do |i|
+          team1 = teams[i]
+
+          (i + 1...teams.length).each do |j|
+            team2              = teams[j]
+            key                = [team1, team2].sort
+            count              = base_matchup_count(league, team1, team2)
+            matchups[key]      = count
+            game_counts[team1] += count
+            game_counts[team2] += count
+          end
+        end
+
+        # Each team will play 6 games against conference opponents in other divisions.
+        # The fours hash will be that plan.
+        find_fours(league).each do |team, opponents|
+          next if game_counts[team] == 82
+
+          opponents.each do |opponent|
+            next if game_counts[team] == 82
+            next if game_counts[opponent] == 82
+
+            game_counts[team] += 1
+            game_counts[opponent] += 1
+
+            key = [team, opponent].sort
+
+            matchups[key] += 1
+          end
+        end
+
+        matchups
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # I am not liking this algorithm implementation at all but it will seemingly produce a valid
+      # result about 1 out of every 1000 cycles. I have yet to spot the assignment pattern to make
+      # this way more deterministic.
+      def find_fours(league)
+        balanced     = false
+        count        = 0
+        four_tracker = {}
+
+        until balanced
+          # Let's not completely thrash our CPUs in case this algorithm hits an infinite loop.
+          # Instead, lets hard-fail against a hard boundary.
+          raise ArgumentError, 'we spent too much CPU time and didnt resolve fours' if count > 100_000
+
+          four_tracker = league.teams.to_h { |team| [team, []] }
+
+          league.teams.each do |team|
+            opponents = league.cross_division_opponents_for(team).shuffle
+
+            opponents.each do |opponent|
+              if four_tracker[team].length < 6 && four_tracker[opponent].length < 6
+                four_tracker[opponent] << team
+                four_tracker[team] << opponent
+              end
+            end
+          end
+
+          good = true
+
+          # trip-wire: if one team isnt balanced then we are not balanced
+          four_tracker.each { |_k, v| good = false if v.length < 6 }
+
+          balanced = good
+
+          count += 1
+        end
+
+        four_tracker
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def schedule_season!(calendar:, league:)
+        matchups = matchup_plan(league)
+
+        matchups.each do |(team1, team2), count|
+          candidates = calendar.available_season_matchup_dates(team1, team2)
+          dates      = candidates.sample(count)
+          games      = balanced_games(dates, team1, team2)
+
+          games.each { |game| calendar.add!(game) }
+        end
+      end
+
+      def balanced_games(dates, team1, team2)
+        dates.map.with_index(1) do |date, index|
+          if index.even?
+            SeasonGame.new(date:, home_team: team1, away_team: team2)
+          else
+            SeasonGame.new(date:, home_team: team2, away_team: team1)
+          end
+        end
+      end
+
+      def schedule_preseason!(calendar:, league:)
+        league.teams.each do |team|
+          current_games = calendar.preseason_games_for(team:)
+          count         = current_games.length
+
+          next if count >= MIN_PRESEASON_GAMES_PER_TEAM
+
+          other_teams = (league.teams - [team]).shuffle
+
+          other_teams.each do |other_team|
+            break if count > MIN_PRESEASON_GAMES_PER_TEAM
+            next  if calendar.preseason_games_for(team: other_team).length >= MAX_PRESEASON_GAMES_PER_TEAM
+
+            candidates = calendar.available_preseason_matchup_dates(team, other_team)
+
+            next if candidates.empty?
+
+            date = candidates.sample
+            game = random_preseason_game(date, team, other_team)
+
+            calendar.add!(game)
+
+            count += 1
+          end
+        end
+      end
+
+      def random_preseason_game(date, team1, team2)
+        if rand(1..2) == 1
+          PreseasonGame.new(date:, home_team: team1, away_team: team2)
+        else
+          PreseasonGame.new(date:, home_team: team2, away_team: team1)
+        end
+      end
+    end
+  end
+end

data/lib/basketball/scheduling/division.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Scheduling
+    class Division < Entity
+      TEAMS_SIZE = 5
+
+      attr_reader :name, :teams
+
+      def initialize(id:, name: '', teams: [])
+        super(id)
+
+        @name  = name.to_s
+        @teams = []
+
+        teams.each { |t| register_team!(t) }
+
+        raise BadTeamsSizeError, "#{id} should have exactly #{TEAMS_SIZE} teams" if teams.length != TEAMS_SIZE
+
+        freeze
+      end
+
+      def to_s
+        (["[#{super}] #{name}"] + teams.map(&:to_s)).join("\n")
+      end
+
+      def team?(team)
+        teams.include?(team)
+      end
+
+      private
+
+      def register_team!(team)
+        raise ArgumentError, 'team is required' unless team
+        raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
+
+        teams << team
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/scheduling/game.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Scheduling
+    class Game < ValueObject
+      attr_reader_value :date, :home_team, :away_team
+
+      def initialize(date:, home_team:, away_team:)
+        super()
+
+        raise ArgumentError, 'date is required'             unless date
+        raise ArgumentError, 'home_team is required'        unless home_team
+        raise ArgumentError, 'away_team is required'        unless away_team
+        raise ArgumentError, 'teams cannot play themselves' if home_team == away_team
+
+        @date      = date
+        @home_team = home_team
+        @away_team = away_team
+
+        freeze
+      end
+
+      def teams
+        [home_team, away_team]
+      end
+
+      def to_s
+        "#{date} - #{away_team} at #{home_team}"
+      end
+    end
+  end
+end

data/lib/basketball/scheduling/league.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Scheduling
+    class League
+      class UnknownTeamError < StandardError; end
+
+      class << self
+        def generate_random; end
+      end
+
+      CONFERENCES_SIZE = 2
+
+      attr_reader :conferences
+
+      def initialize(conferences: [])
+        @conferences = []
+
+        conferences.each { |c| register_conference!(c) }
+
+        if conferences.length != CONFERENCES_SIZE
+          raise BadConferencesSizeError, "there has to be #{CONFERENCES_SIZE} conferences"
+        end
+
+        freeze
+      end
+
+      def to_s
+        (['League'] + conferences.map(&:to_s)).join("\n")
+      end
+
+      def divisions
+        conferences.flat_map(&:divisions)
+      end
+
+      def conference?(conference)
+        conferences.include?(conference)
+      end
+
+      def division?(division)
+        divisions.include?(division)
+      end
+
+      def team?(team)
+        teams.include?(team)
+      end
+
+      def teams
+        conferences.flat_map do |conference|
+          conference.divisions.flat_map(&:teams)
+        end
+      end
+
+      def conference_for(team)
+        conferences.find { |c| c.divisions.find { |d| d.teams.include?(team) } }
+      end
+
+      def division_for(team)
+        conference_for(team)&.divisions&.find { |d| d.teams.include?(team) }
+      end
+
+      # Same conference, same division
+      def division_opponents_for(team)
+        division = division_for(team)
+
+        return nil unless division
+
+        division.teams - [team]
+      end
+
+      # Same conference, different division
+      def cross_division_opponents_for(team)
+        conference = conference_for(team)
+        division   = division_for(team)
+
+        return nil unless conference && division
+
+        other_divisions = conference.divisions - [division]
+
+        other_divisions.flat_map(&:teams)
+      end
+
+      # Different conference
+      def cross_conference_opponents_for(team)
+        conference = conference_for(team)
+
+        return nil unless conference
+
+        other_conferences = conferences - [conference]
+
+        other_conferences.flat_map { |c| c.divisions.flat_map(&:teams) }
+      end
+
+      private
+
+      def register_conference!(conference)
+        raise ArgumentError, 'conference is required' unless conference
+        raise ConferenceAlreadyRegisteredError, "#{conference} already registered" if conference?(conference)
+
+        conference.divisions.each do |division|
+          raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
+
+          division.teams.each do |team|
+            raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
+          end
+        end
+
+        conferences << conference
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/scheduling/league_serializer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Scheduling
+    class LeagueSerializer
+      def deserialize(string)
+        json        = JSON.parse(string, symbolize_names: true)
+        conferences = deserialize_conferences(json[:conferences])
+
+        League.new(conferences:)
+      end
+
+      def serialize(league)
+        {
+          conferences: serialize_conferences(league.conferences)
+        }.to_json
+      end
+
+      private
+
+      ## Deserialization
+
+      def deserialize_conferences(conferences)
+        (conferences || []).map do |conference_id, conference_hash|
+          Conference.new(
+            id: conference_id,
+            name: conference_hash[:name],
+            divisions: deserialize_divisions(conference_hash[:divisions])
+          )
+        end
+      end
+
+      def deserialize_divisions(divisions)
+        (divisions || []).map do |division_id, division_hash|
+          Division.new(
+            id: division_id,
+            name: division_hash[:name],
+            teams: deserialize_teams(division_hash[:teams])
+          )
+        end
+      end
+
+      def deserialize_teams(teams)
+        (teams || []).map do |team_id, team_hash|
+          Team.new(
+            id: team_id,
+            name: team_hash[:name]
+          )
+        end
+      end
+
+      ## Serialization
+
+      def serialize_conferences(conferences)
+        conferences.to_h do |conference|
+          [
+            conference.id,
+            {
+              name: conference.name,
+              divisions: serialize_divisions(conference.divisions)
+            }
+          ]
+        end
+      end
+
+      def serialize_divisions(divisions)
+        divisions.to_h do |division|
+          [
+            division.id,
+            {
+              name: division.name,
+              teams: serialize_teams(division.teams)
+            }
+          ]
+        end
+      end
+
+      def serialize_teams(teams)
+        teams.to_h do |team|
+          [
+            team.id,
+            {
+              name: team.name
+            }
+          ]
+        end
+      end
+    end
+  end
+end