basketball 0.0.9 → 0.0.11

data/lib/basketball/season/scheduler.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # This is the service class responsible for actually picking out free dates and 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 Scheduler
+      class BadConferencesSizeError < StandardError; end
+      class BadDivisionsSizeError < StandardError; end
+      class BadTeamsSizeError < StandardError; end
+
+      MIN_PRESEASON_GAMES_PER_TEAM = 3
+      MAX_PRESEASON_GAMES_PER_TEAM = 6
+      CONFERENCES_SIZE             = 2
+      DIVISIONS_SIZE               = 3
+      TEAMS_SIZE                   = 5
+
+      private_constant :MIN_PRESEASON_GAMES_PER_TEAM,
+                       :MAX_PRESEASON_GAMES_PER_TEAM,
+                       :CONFERENCES_SIZE,
+                       :DIVISIONS_SIZE,
+                       :TEAMS_SIZE
+
+      def schedule(league:, year: Time.now.year)
+        assert_properly_sized_league(league)
+
+        Calendar.new(**make_dates(year)).tap do |calendar|
+          schedule_exhibition!(calendar:, league:)
+          schedule_season!(calendar:, league:)
+        end
+      end
+
+      private
+
+      def make_dates(year)
+        {
+          exhibition_start_date: Date.new(year, 9, 30),
+          exhibition_end_date: Date.new(year, 10, 14),
+          regular_start_date: Date.new(year, 10, 18),
+          regular_end_date: Date.new(year + 1, 4, 29)
+        }
+      end
+
+      def assert_properly_sized_league(league)
+        if league.conferences.length != CONFERENCES_SIZE
+          raise BadConferencesSizeError, "there has to be #{CONFERENCES_SIZE} conferences"
+        end
+
+        league.conferences.each do |conference|
+          if conference.divisions.length != DIVISIONS_SIZE
+            raise BadDivisionsSizeError, "#{conference.id} should have exactly #{DIVISIONS_SIZE} divisions"
+          end
+
+          conference.divisions.each do |division|
+            if division.teams.length != TEAMS_SIZE
+              raise BadTeamsSizeError, "#{division.id} should have exactly #{TEAMS_SIZE} teams"
+            end
+          end
+        end
+      end
+
+      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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # 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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # 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_regular_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|
+          home_opponent, away_opponent =
+            if index.even?
+              [Opponent.from(team1), Opponent.from(team2)]
+            else
+              [Opponent.from(team2), Opponent.from(team1)]
+            end
+
+          Regular.new(date:, home_opponent:, away_opponent:)
+        end
+      end
+
+      def schedule_exhibition!(calendar:, league:)
+        league.teams.each do |team|
+          current_games = calendar.exhibitions_for(opponent: 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.exhibitions_for(opponent: other_team).length >= MAX_PRESEASON_GAMES_PER_TEAM
+
+            candidates = calendar.available_exhibition_matchup_dates(team, other_team)
+
+            next if candidates.empty?
+
+            date = candidates.sample
+            game = random_exhibition_game(date, team, other_team)
+
+            calendar.add!(game)
+
+            count += 1
+          end
+        end
+      end
+
+      def random_exhibition_game(date, team1, team2)
+        home_opponent, away_opponent =
+          if rand(1..2) == 1
+            [Opponent.from(team1), Opponent.from(team2)]
+          else
+            [Opponent.from(team2), Opponent.from(team1)]
+          end
+
+        Exhibition.new(date:, home_opponent:, away_opponent:)
+      end
+    end
+  end
+end

data/lib/basketball/season/standings.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Represents a League with each team's win/loss details.
+    class Standings
+      class TeamAlreadyRegisteredError < StandardError; end
+      class TeamNotRegisteredError < StandardError; end
+
+      def initialize
+        @records_by_id = {}
+      end
+
+      def register!(team)
+        raise TeamAlreadyRegisteredError, "#{team} already registered!" if team?(team)
+
+        records_by_id[team.id] = Record.new(id: team.id)
+
+        self
+      end
+
+      def records
+        records_by_id.values
+      end
+
+      def record_for(team)
+        raise TeamNotRegisteredError, "#{team} not registered" unless team?(team)
+
+        records_by_id.fetch(team.id)
+      end
+
+      def accept!(result)
+        [
+          record_for(result.home_opponent),
+          record_for(result.away_opponent)
+        ].each do |record|
+          record.accept!(result)
+        end
+
+        self
+      end
+
+      def team?(team)
+        records_by_id.key?(team.id)
+      end
+
+      def to_s
+        records.sort.reverse.map.with_index(1) { |r, i| "##{i} #{r}" }.join("\n")
+      end
+
+      private
+
+      attr_reader :records_by_id
+    end
+  end
+end

data/lib/basketball/season.rb

@@ -12,5 +12,11 @@ require_relative 'season/opponent'
 require_relative 'season/exhibition'
 require_relative 'season/regular'
 
+# Standings
+require_relative 'season/detail'
+require_relative 'season/record'
+require_relative 'season/standings'
+
 # Specific
 require_relative 'season/coordinator'
+require_relative 'season/scheduler'

data/lib/basketball/value_object.rb

@@ -1,37 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'value_object_dsl'
+
 module Basketball
   # A Value Object is something that has no specific identity, instead its identity is the sum of
   # the attribute values. Changing one will change the entire object's identity.
-  # Comes with a very simple DSL for specifying properties along with base equality and sorting methods.
+  # Comes with a very simple DSL provided by ValueObjectDSL for specifying properties along with
+  # base equality and sorting methods.
   class ValueObject
     include Comparable
-
-    class << self
-      def all_value_keys
-        @all_value_keys ||= ancestors.flat_map do |ancestor|
-          if ancestor < Basketball::ValueObject
-            ancestor.value_keys
-          else
-            []
-          end
-        end.uniq.sort
-      end
-
-      def all_sorted_value_keys
-        all_value_keys.sort
-      end
-
-      def value_keys
-        @value_keys ||= []
-      end
-
-      def value_reader(*keys)
-        keys.each { |k| value_keys << k.to_sym }
-
-        attr_reader(*keys)
-      end
-    end
+    extend ValueObjectDSL
 
     def to_s
       to_h.map { |k, v| "#{k}: #{v}" }.join(', ')
@@ -55,7 +33,7 @@ module Basketball
     alias eql? ==
 
     def hash
-      all_sorted_values.map(&:hash).hash
+      all_sorted_values.hash
     end
 
     def all_sorted_values

data/lib/basketball/value_object_dsl.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Basketball
+  # Class-level methods that extend core Ruby attr_* methods.
+  module ValueObjectDSL
+    def all_value_keys
+      @all_value_keys ||= ancestors.flat_map do |ancestor|
+        if ancestor < Basketball::ValueObject
+          ancestor.value_keys
+        else
+          []
+        end
+      end.uniq.sort
+    end
+
+    def all_sorted_value_keys
+      all_value_keys.sort
+    end
+
+    def value_keys
+      @value_keys ||= []
+    end
+
+    def value_reader(*keys)
+      keys.each { |k| value_keys << k.to_sym }
+
+      attr_reader(*keys)
+    end
+  end
+end

data/lib/basketball/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Basketball
-  VERSION = '0.0.9'
+  VERSION = '0.0.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: basketball
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.11
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-30 00:00:00.000000000 Z
+date: 2023-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slop
@@ -31,8 +31,9 @@ description: "    This library is meant to serve as the domain for a basketball
 email:
 - mattruggio@icloud.com
 executables:
-- basketball-coordinator
-- basketball-room
+- basketball
+- basketball-season-coordinator
+- basketball-draft-room
 extensions: []
 extra_rdoc_files: []
 files:
@@ -48,13 +49,18 @@ files:
 - README.md
 - Rakefile
 - basketball.gemspec
-- exe/basketball-coordinator
-- exe/basketball-room
+- exe/basketball
+- exe/basketball-draft-room
+- exe/basketball-season-coordinator
 - lib/basketball.rb
 - lib/basketball/app.rb
 - lib/basketball/app/coordinator_cli.rb
 - lib/basketball/app/coordinator_repository.rb
+- lib/basketball/app/document_repository.rb
 - lib/basketball/app/file_store.rb
+- lib/basketball/app/in_memory_store.rb
+- lib/basketball/app/league_repository.rb
+- lib/basketball/app/league_serializable.rb
 - lib/basketball/app/room_cli.rb
 - lib/basketball/app/room_repository.rb
 - lib/basketball/draft.rb
@@ -67,6 +73,11 @@ files:
 - lib/basketball/draft/skip.rb
 - lib/basketball/entity.rb
 - lib/basketball/org.rb
+- lib/basketball/org/conference.rb
+- lib/basketball/org/division.rb
+- lib/basketball/org/has_divisions.rb
+- lib/basketball/org/has_players.rb
+- lib/basketball/org/has_teams.rb
 - lib/basketball/org/league.rb
 - lib/basketball/org/player.rb
 - lib/basketball/org/position.rb
@@ -75,13 +86,18 @@ files:
 - lib/basketball/season/arena.rb
 - lib/basketball/season/calendar.rb
 - lib/basketball/season/coordinator.rb
+- lib/basketball/season/detail.rb
 - lib/basketball/season/exhibition.rb
 - lib/basketball/season/game.rb
 - lib/basketball/season/matchup.rb
 - lib/basketball/season/opponent.rb
+- lib/basketball/season/record.rb
 - lib/basketball/season/regular.rb
 - lib/basketball/season/result.rb
+- lib/basketball/season/scheduler.rb
+- lib/basketball/season/standings.rb
 - lib/basketball/value_object.rb
+- lib/basketball/value_object_dsl.rb
 - lib/basketball/version.rb
 homepage: https://github.com/mattruggio/basketball
 licenses: