basketball 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dca22b3ec7251a012db2afed77f3bda87bd8b59bb59e6084fff80096efcb802a
-  data.tar.gz: 55973e68a7aece1571d926f21e5866e045322e1009b9a5139a959d5059e1b150
+  metadata.gz: 95fd9cb9bb1c51ed7a76e5640f5297ea463b412803bcfacf8c47ea8b9abc5b21
+  data.tar.gz: 726e72b88fd8c81a30bfb4e47742e07fd97ba88fd86d9695852b0733ee6c0e5f
 SHA512:
-  metadata.gz: af6b695d1ad8bd581822ffe6fe61421c5839a51e880f0d143060656a8e916e11ff8ae4ae5293e9babb2d8f45646b643d30b7753c03141f8d0c321b4010eca14d
-  data.tar.gz: d0addd9247f2a3b945874d628eec04e44cb826db2578d493bd99cc242beb8e78041084bf3fbffa53b6a00f2a2b788abb8540894e1caf9db5b0031a01357d5bc1
+  metadata.gz: b00a86aca794ea7b1ccbba172bc0fd63cfbbf4b8ff5eee2a7763f3877d8669a2b23141109fbf78461d9bd5b475e6a758381cc24c3a5d0e8b2e6dcb17f69e97bf
+  data.tar.gz: 5b8d75ca8cb88dc6733d1453d485a9fe8842a2e98d601f3870837bf3197718d181b77a475960202320be2d92a651ed5d741719e1d90882984d6286f629d2cd6d

data/README.md

@@ -12,11 +12,15 @@ Element      | Description
 :------------ | :-----------
 **Arena** | Determines exhibition and regular season game outcomes.
 **Assessment** | When the Room needs to know who a Front Office wants to select, the Room will send the Front Office an Assessment. The Assessment is a report of where the team currently stands: players picked, players available, and round information.
-**basketball-room** | Command-line executable script illustrating an example of how to subclass and consume the drafting module.
-**Calendar** | Stores important boundary dates (preseason start, preseason end, season start, and season end).
-**Coordinator CLI** | Underlying Ruby class that powers the `basketball-coordinator` script. Basically a terminal wrapper over the Coordinator object.
+**basketball-draft-room** | Command-line executable script showing an example of how to consume the draft room aggregate root.
+**basketball-season-coordinator** | Command-line executable script showing an example of how to consume the season coordinator aggregate root.
+**Calendar** | Stores important boundary dates (exhibition start, exhibition end, season start, and season end).
+**Conference** | A collection of Divisions.
+**Coordinator CLI** | Underlying Ruby class that powers the `basketball-season-coordinator` script. Basically a terminal wrapper over the Coordinator object.
 **Coordinator Repository** | Understands how to save and load Coordinator objects from JSON files on disk.
 **Coordinator** | Object which can take a League, Calendar, Games, and an Arena and provide an iterable interface to enumerate through days and simulate games as results.
+**Detail** | Re-representation of a Result object but from a specific team's perspective.
+**Division** | A collection of teams.
 **Draft** | Bounded context (sub-module) dealing with running a round-robin player draft for teams.
 **Exhibition** | Pre-season game which has no impact to team record.
 **External Dependency** | Some outside system which this library or portions of this library are dependent on.
@@ -25,19 +29,22 @@ Element      | Description
 **Front Office** | Identifiable as a team, contains logic for how to auto-pick draft selections.  Meant to be subclassed and extended to include more intricate player selection logic as the base will simply randomly select a player.
 **Game** | Matches up a date with two teams (home and away) to represent a coordinatord match-up.
 **League Repository** | Understands how to save and load League objects from JSON files on disk.
-**League** | Describes a league in terms of structure composed of teams and players.
+**League** | Describes a league in terms of structure composed of conferences, divisions, teams, and players.
 **Match** | When the Coordinator needs an Arena instance to select a game winner, it will send the Arena a Match. A match is Game but also includes the active roster (players) for both teams that will participate in the game.
 **Org** | Bounded context (sub-module) dealing with overall organizational structure of a sports assocation.
 **Pick** | Result event emitted when a player is automatically or manually selected.
 **Player** | Identitiable as a person able to be drafted.  Meant to be subclassed and extended to include more intricate descriptions of a specific sport player, such as abilities, ratings, and statistics.  Right now it has none of these types of traits and it meant to only serve as the base with only an overall attribute.
+**Record** | Represents a team's overall record.
 **Regular** | Game that counts towards regular season record.
 **Result** | The outcome of a game (typically with a home and away score).
-**Room CLI** | Underlying Ruby class that powers the `basketball-room` script. Basically a terminal wrapper for the Room object.
+**Room CLI** | Underlying Ruby class that powers the `basketball-draft-room` script. Basically a terminal wrapper for the Room object.
 **Room Repository** | Understands how to save and load Room objects from JSON files on disk.
 **Room** | Main object responsible for providing an iterable interface capable of executing a draft, pick by pick.
+**Scheduler** | Knows how to take a League and a year and generate a game-populated calendar.
 **Scout** | Knows how to stack rank lists of players.
 **Season** | Bounded context (sub-module) dealing with calendar and matchup generation.
 **Skip** | Result event emitted when a front office decides to skip a round.
+**Standings** | Synthesizes teams and results into team standings with win/loss records and more.
 **Store** | Interface for the underlying Repository persistence layer.  While a Document Repository is mainly responsible for serialization/de-serialization, the store actually knows how to read/write the data.
 **Team Group** | Set of rosters that together form a cohesive league.
 **Team** | Member of a league and signs players.  Has games assigned and played.
@@ -72,61 +79,61 @@ This library ships with an example of how the Draft module could be used impleme
 ###### Generate a Fresh Draft
 
 ```zsh
-basketball-room -o tmp/draft.json
+basketball-draft-room -o tmp/draft.json
 ```
 
 ###### N Top Available Players
 
 ```zsh
-basketball-room -i tmp/draft.json -t 10
+basketball-draft-room -i tmp/draft.json -t 10
 ```
 
 ###### N Top Available Players for a Position
 
 ```zsh
-basketball-room -i tmp/draft.json -t 10 -q PG
+basketball-draft-room -i tmp/draft.json -t 10 -q PG
 ```
 
 ###### Output League
 
 ```zsh
-basketball-room -i tmp/draft.json -l
+basketball-draft-room -i tmp/draft.json -l
 ```
 
 ###### Output Event Log
 
 ```zsh
-basketball-room -i tmp/draft.json -e
+basketball-draft-room -i tmp/draft.json -e
 ```
 
 ###### Simulate N Picks
 
 ```zsh
-basketball-room -i tmp/draft.json -s 10
+basketball-draft-room -i tmp/draft.json -s 10
 ```
 
 ###### Skip N Picks
 
 ```zsh
-basketball-room -i tmp/draft.json -x 10
+basketball-draft-room -i tmp/draft.json -x 10
 ```
 
 ###### Pick Players
 
 ```zsh
-basketball-room -i tmp/draft.json -p P-100,P-200,P-300
+basketball-draft-room -i tmp/draft.json -p P-100,P-200,P-300
 ```
 
 ###### Simulate the Rest of the Draft
 
 ```zsh
-basketball-room -i tmp/draft.json -a
+basketball-draft-room -i tmp/draft.json -a
 ```
 
 ###### Help Menu
 
 ```zsh
-basketball-room -h
+basketball-draft-room -h
 ```
 
 ### Season Module
@@ -143,37 +150,37 @@ This library ships with an example of how the Season module could be used implem
 ###### Generate Random coordinator
 
 ```zsh
-exe/basketball-coordinator -o tmp/coordinator.json
+exe/basketball-season-coordinator -o tmp/coordinator.json
 ```
 
 ###### Sim One Day and Save to New File
 
 ```zsh
-exe/basketball-coordinator -i tmp/coordinator.json -o tmp/coordinator2.json -d 1
+exe/basketball-season-coordinator -i tmp/coordinator.json -o tmp/coordinator2.json -d 1
 ```
 
 ###### Output Event Log
 
 ```zsh
-exe/basketball-coordinator -i tmp/coordinator.json -e
+exe/basketball-season-coordinator -i tmp/coordinator.json -e
 ```
 
 ###### Sim Two Days and Save To Input File
 
 ```zsh
-exe/basketball-coordinator -i tmp/coordinator.json -d 2
+exe/basketball-season-coordinator -i tmp/coordinator.json -d 2
 ```
 
 ###### Sim Rest of Calendar
 
 ```zsh
-exe/basketball-coordinator -i tmp/coordinator.json -a
+exe/basketball-season-coordinator -i tmp/coordinator.json -a
 ```
 
 ###### Help Menu
 
 ```zsh
-basketball-coordinator -h
+basketball-season-coordinator -h
 ```
 
 ## Contributing

data/basketball.gemspec

@@ -11,14 +11,20 @@ Gem::Specification.new do |s|
     This library is meant to serve as the domain for a basketball league/season simulator/turn-based game. It models core ideas such as: players, general managers, draft strategy, drafting, season generation, season simultation, playoff generation, playoff simulation, and more.
   DESC
 
-  s.authors     = ['Matthew Ruggio']
-  s.email       = ['mattruggio@icloud.com']
-  s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(.github|bin|docs|spec)/}) }
-  s.bindir      = 'exe'
-  s.executables = %w[basketball-coordinator basketball-room]
-  s.homepage    = 'https://github.com/mattruggio/basketball'
-  s.license     = 'MIT'
-  s.metadata    = {
+  s.authors = ['Matthew Ruggio']
+  s.email   = ['mattruggio@icloud.com']
+  s.files   = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(.github|bin|docs|spec)/}) }
+  s.bindir  = 'exe'
+
+  s.executables = %w[
+    basketball
+    basketball-season-coordinator
+    basketball-draft-room
+  ]
+
+  s.homepage = 'https://github.com/mattruggio/basketball'
+  s.license  = 'MIT'
+  s.metadata = {
     'bug_tracker_uri' => 'https://github.com/mattruggio/basketball/issues',
     'changelog_uri' => 'https://github.com/mattruggio/basketball/blob/main/CHANGELOG.md',
     'documentation_uri' => 'https://www.rubydoc.info/gems/basketball',

data/exe/basketball

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'basketball'
+
+# This is an example integration script tying all the contexts together.
+# This is definitely subject to change as this library gets extended further.
+
+store                  = Basketball::App::FileStore.new
+room_repository        = Basketball::App::RoomRepository.new(store)
+league_repository      = Basketball::App::LeagueRepository.new(store)
+coordinator_repository = Basketball::App::CoordinatorRepository.new(store)
+scheduler              = Basketball::Season::Scheduler.new
+
+seed_path  = ARGV[0].to_s.empty? ? File.join('spec', 'fixtures', 'seed.json') : ARGV[0]
+output_dir = ARGV[1].to_s.empty? ? 'tmp' : ARGV[1]
+seed       = JSON.parse(File.read(seed_path), symbolize_names: true)
+
+league_path = File.join(output_dir, '00-league.json')
+
+File.write(league_path, seed[:league].to_json)
+
+front_offices = seed.dig(:league, :conferences).flat_map do |c|
+  c[:divisions].flat_map do |d|
+    d[:teams].flat_map do |t|
+      { id: t[:id] }
+    end
+  end
+end
+
+room = {
+  rounds: 12,
+  front_offices:,
+  players: seed[:players]
+}
+
+room_input_path = File.join(output_dir, '01-room-input.json')
+
+File.write(room_input_path, room.to_json)
+
+room = room_repository.load(room_input_path)
+
+room.sim_rest!
+
+room_output_path = File.join(output_dir, '02-room-output.json')
+
+room_repository.save(room_output_path, room)
+
+league = league_repository.load(league_path)
+
+room.teams.each do |team|
+  team.players.each do |player|
+    league.sign!(team:, player:)
+  end
+end
+
+scheduler_input_path = File.join(output_dir, '03-scheduler-input.json')
+
+league_repository.save(scheduler_input_path, league)
+
+calendar     = scheduler.schedule(league:)
+current_date = calendar.exhibition_start_date
+coordinator  = Basketball::Season::Coordinator.new(league:, calendar:, current_date:)
+
+coordinator_input_path = File.join(output_dir, '04-coordinator-input.json')
+
+coordinator_repository.save(coordinator_input_path, coordinator)
+
+coordinator.sim_rest!
+
+coordinator_output_path = File.join(output_dir, '05-coordinator-output.json')
+
+coordinator_repository.save(coordinator_output_path, coordinator)
+
+preseason_standings = Basketball::Season::Standings.new
+season_standings = Basketball::Season::Standings.new
+
+league.teams.each do |team|
+  preseason_standings.register!(team)
+  season_standings.register!(team)
+end
+
+coordinator.exhibition_results.each { |result| preseason_standings.accept!(result) }
+coordinator.regular_results.each    { |result| season_standings.accept!(result) }
+
+puts 'Preseason Standings'
+puts preseason_standings
+puts '--------------------------------------------'
+puts 'Season Standings'
+puts season_standings

data/lib/basketball/app/coordinator_cli.rb

@@ -3,13 +3,13 @@
 module Basketball
   module App
     # Examples:
-    #   exe/basketball-coordinator -o tmp/coordinator.json
-    #   exe/basketball-coordinator -i tmp/coordinator.json -o tmp/coordinator2.json -d 1
-    #   exe/basketball-coordinator -i tmp/coordinator2.json -e
-    #   exe/basketball-coordinator -i tmp/coordinator2.json -o tmp/coordinator2.json -d 2
-    #   exe/basketball-coordinator -i tmp/coordinator2.json -a
+    #   exe/basketball-season-coordinator -o tmp/coordinator.json
+    #   exe/basketball-season-coordinator -i tmp/coordinator.json -o tmp/coordinator2.json -d 1
+    #   exe/basketball-season-coordinator -i tmp/coordinator2.json -e
+    #   exe/basketball-season-coordinator -i tmp/coordinator2.json -o tmp/coordinator2.json -d 2
+    #   exe/basketball-season-coordinator -i tmp/coordinator2.json -a
     #
-    #   exe/basketball-coordinator -o tmp/coordinator.json -ae
+    #   exe/basketball-season-coordinator -o tmp/coordinator.json -ae
     class CoordinatorCLI
       attr_reader :opts, :io, :coordinator_repository
 
@@ -56,7 +56,7 @@ module Basketball
         else
           io.puts("#{coordinator.days_left} Remaining day(s) (#{coordinator.total_days} total)")
           io.puts("Currently on: #{coordinator.current_date}")
-          io.puts("#{coordinator.exhibitions_left} Remaining preseason (#{coordinator.total_exhibitions} total)")
+          io.puts("#{coordinator.exhibitions_left} Remaining exhibition (#{coordinator.total_exhibitions} total)")
           io.puts("#{coordinator.regulars_left} Remaining season (#{coordinator.total_regulars} total)")
         end
       end
@@ -104,69 +104,46 @@ module Basketball
         path
       end
 
-      def make_league(team_count: 2, players_per_team_count: 4)
-        Org::League.new.tap do |league|
-          team_count.times do |i|
-            team = Org::Team.new(id: "T-#{i}")
-
-            players_per_team_count.times do |j|
-              player = Org::Player.new(
-                id: "T-#{i}-P-#{j}",
-                overall: rand(20..100),
-                position: Org::Position.random
-              )
-
-              team.sign!(player)
-            end
-
-            league.register!(team)
+      def make_league
+        Org::League.new(
+          conferences: 2.times.map do |i|
+            conference_id = "C#{i}"
+
+            Org::Conference.new(
+              id: conference_id,
+              divisions: 3.times.map do |j|
+                division_id = "#{conference_id}-D#{j}"
+
+                Org::Division.new(
+                  id: division_id,
+                  teams: 5.times.map do |k|
+                    team_id = "#{division_id}-T#{k}"
+
+                    Org::Team.new(
+                      id: team_id,
+                      players: 12.times.map do |l|
+                        player_id = "#{team_id}-P#{l}"
+
+                        Org::Player.new(
+                          id: player_id,
+                          overall: rand(20..100),
+                          position: Org::Position.random
+                        )
+                      end
+                    )
+                  end
+                )
+              end
+            )
           end
-        end
-      end
-
-      def make_calendar(league:)
-        preseason_start_date = Date.new(2000, 1, 1)
-        season_start_date = Date.new(2000, 1, 11)
-
-        exhibitions = make_games(
-          start_date: preseason_start_date,
-          count: 10,
-          league:,
-          game_class: Season::Exhibition
         )
-
-        regulars = make_games(
-          start_date: season_start_date,
-          count: 10,
-          league:,
-          game_class: Season::Regular
-        )
-
-        Season::Calendar.new(
-          preseason_start_date:,
-          preseason_end_date: Date.new(2000, 1, 10),
-          season_start_date:,
-          season_end_date: Date.new(2000, 1, 20),
-          games: exhibitions + regulars
-        )
-      end
-
-      def make_games(start_date:, count:, league:, game_class:)
-        count.times.map do |i|
-          home_team, away_team = league.teams.sample(2)
-
-          game_class.new(
-            date: start_date + i,
-            home_opponent: Season::Opponent.new(id: home_team.id),
-            away_opponent: Season::Opponent.new(id: away_team.id)
-          )
-        end
       end
 
       def make_coordinator
         league       = make_league
-        current_date = Date.new(2000, 1, 1)
-        calendar     = make_calendar(league:)
+        year         = Time.now.year
+        calendar     = Season::Scheduler.new.schedule(league:, year:)
+        current_date = calendar.games.min_by(&:date).date
 
         Season::Coordinator.new(
           calendar:,
@@ -227,7 +204,7 @@ module Basketball
 
       def slop_parse(args)
         Slop.parse(args) do |o|
-          o.banner = 'Usage: basketball-coordinator [options] ...'
+          o.banner = 'Usage: basketball-season-coordinator [options] ...'
 
           input_description = <<~DESC
             Path to load the Coordinator from. If omitted then a new coordinator will be created.

data/lib/basketball/app/coordinator_repository.rb

@@ -26,6 +26,7 @@ module Basketball
 
       def to_h(coordinator)
         {
+          id: coordinator.id,
           calendar: serialize_calendar(coordinator.calendar),
           current_date: coordinator.current_date.to_s,
           results: serialize_results(coordinator.results),
@@ -41,10 +42,10 @@ module Basketball
 
       def serialize_calendar(calendar)
         {
-          preseason_start_date: calendar.preseason_start_date.to_s,
-          preseason_end_date: calendar.preseason_end_date.to_s,
-          season_start_date: calendar.season_start_date.to_s,
-          season_end_date: calendar.season_end_date.to_s,
+          exhibition_start_date: calendar.exhibition_start_date.to_s,
+          exhibition_end_date: calendar.exhibition_end_date.to_s,
+          regular_start_date: calendar.regular_start_date.to_s,
+          regular_end_date: calendar.regular_end_date.to_s,
           games: serialize_games(calendar.games)
         }
       end
@@ -76,10 +77,10 @@ module Basketball
 
       def deserialize_calendar(calendar_hash)
         Season::Calendar.new(
-          preseason_start_date: Date.parse(calendar_hash[:preseason_start_date]),
-          preseason_end_date: Date.parse(calendar_hash[:preseason_end_date]),
-          season_start_date: Date.parse(calendar_hash[:season_start_date]),
-          season_end_date: Date.parse(calendar_hash[:season_end_date]),
+          exhibition_start_date: Date.parse(calendar_hash[:exhibition_start_date]),
+          exhibition_end_date: Date.parse(calendar_hash[:exhibition_end_date]),
+          regular_start_date: Date.parse(calendar_hash[:regular_start_date]),
+          regular_end_date: Date.parse(calendar_hash[:regular_end_date]),
           games: deserialize_games(calendar_hash[:games])
         )
       end

data/lib/basketball/app/league_serializable.rb

@@ -8,46 +8,91 @@ module Basketball
 
       def serialize_league(league)
         {
-          teams: league.teams.map { |team| serialize_team(team) }
+          id: league.id,
+          conferences: serialize_conferences(league.conferences)
         }
       end
 
-      def serialize_team(team)
-        {
-          id: team.id,
-          players: team.players.map { |player| serialize_player(player) }
-        }
+      def serialize_conferences(conferences)
+        conferences.map do |conference|
+          {
+            id: conference.id,
+            divisions: serialize_divisions(conference.divisions)
+          }
+        end
       end
 
-      def serialize_player(player)
-        {
-          id: player.id,
-          overall: player.overall,
-          position: player.position&.code
-        }
+      def serialize_divisions(divisions)
+        divisions.map do |division|
+          {
+            id: division.id,
+            teams: serialize_teams(division.teams)
+          }
+        end
+      end
+
+      def serialize_teams(teams)
+        teams.map do |team|
+          {
+            id: team.id,
+            players: serialize_players(team.players)
+          }
+        end
+      end
+
+      def serialize_players(players)
+        players.map do |player|
+          {
+            id: player.id,
+            overall: player.overall,
+            position: player.position&.code
+          }
+        end
       end
 
       # Deserialization
 
       def deserialize_league(league_hash)
-        team_hashes = league_hash[:teams] || []
-        teams       = team_hashes.map { |team_hash| deserialize_team(team_hash) }
+        Org::League.new(
+          conferences: deserialize_conferences(league_hash[:conferences])
+        )
+      end
 
-        Org::League.new(teams:)
+      def deserialize_conferences(conference_hashes)
+        (conference_hashes || []).map do |conference_hash|
+          Org::Conference.new(
+            id: conference_hash[:id],
+            divisions: deserialize_divisions(conference_hash[:divisions])
+          )
+        end
       end
 
-      def deserialize_team(team_hash)
-        players = (team_hash[:players] || []).map { |player_hash| deserialize_player(player_hash) }
+      def deserialize_divisions(division_hashes)
+        (division_hashes || []).map do |division_hash|
+          Org::Division.new(
+            id: division_hash[:id],
+            teams: deserialize_teams(division_hash[:teams])
+          )
+        end
+      end
 
-        Org::Team.new(id: team_hash[:id], players:)
+      def deserialize_teams(team_hashes)
+        (team_hashes || []).map do |team_hash|
+          Org::Team.new(
+            id: team_hash[:id],
+            players: deserialize_players(team_hash[:players])
+          )
+        end
       end
 
-      def deserialize_player(player_hash)
-        Org::Player.new(
-          id: player_hash[:id],
-          overall: player_hash[:overall],
-          position: Org::Position.new(player_hash[:position])
-        )
+      def deserialize_players(player_hashes)
+        (player_hashes || []).map do |player_hash|
+          Org::Player.new(
+            id: player_hash[:id],
+            overall: player_hash[:overall],
+            position: Org::Position.new(player_hash[:position])
+          )
+        end
       end
     end
   end