basketball 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 793bfe7afef52aa72d3f89c94541fc7d8f24b350d63cb7c75d7215c285695b74
-  data.tar.gz: 46a3ac7199fb534ff4827c8fe48bbe371c7f87bc623e579ffdce2310132a1263
+  metadata.gz: 262751c76037e2859937529aa23bdd456fd77779a090ed4e844830c428b09e75
+  data.tar.gz: 1a904f317fc3c1becfc381155a089d2ed0b041b60d358c1325459a363e6ce0ec
 SHA512:
-  metadata.gz: cf8c46719f3669a31c932d7dc2742c287666fcb305c90c596c87b79c37d4fb95aafa446c70575ed4d8d3750a3f3672646e9ee49c6a0cf95e4dd7eb092831670e
-  data.tar.gz: db01d3bfc4a8c1448875c5a099d0a33fd60ad60471ae5cda5f9eeeaf8a1fb2daa3e52d5ca2d8138867e42aaf6f54d259cdad7d3628cfbaa2d7bcf134fe5dc4b9
+  metadata.gz: 913504954c8c053fac3147468433d12b02ad5d6a7badc563587668c4d3943b898c49c951d69c393affc5f5e07d54257a5a004184e55a73f435af01344afa6baf
+  data.tar.gz: 791e48aa9711e33e29b994d0e811a735def017de757bc02c8f348b57f2ce0a42c1e5fbbd6737ed2525ddd9fbf3698c9fb77be991208a1b927e4b27063a2b9f04

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+#### 0.0.6 - May 11th, 2023
+
+* Added Scheduling module that can generate full schedules for entire league.
+* Drafting::Event does not have identity anymore (no current tangible benefit).
+
 #### 0.0.5 - May 5th, 2023
 
 * Remove the notion of Team in favor of a flat front office.

data/README.md

@@ -30,13 +30,13 @@ bundle binstubs basketball
 
 This library is broken down into several bounded contexts that can be consumed either via its Ruby API's or CLI through provided executable scripts:
 
-![Basketball Architecture - Overview.png](/docs/architecture/overview.png)
+![Basketball Architecture - Overview](/docs/architecture/overview.png)
 
 ## Drafting Module
 
 The drafting module is responsible for providing a turn-based iterator allowing the consumer to either manually pick or simulate picks.  Here is a cartoon showing the major components:
 
-![Basketball Architecture - Drafting.png](/docs/architecture/drafting.png)
+![Basketball Architecture - Drafting](/docs/architecture/drafting.png)
 
 Element      | Description
 :------------ | :-----------
@@ -47,7 +47,7 @@ Element      | Description
 **Front Office** | Identifiable as a team, contains configuration for how to auto-pick draft selections.
 **League** | Set of rosters that together form a cohesive league.
 **Pick Event** | Result event emitted when a player is manually selected.
-**Playe ** | Identitiable as a person able to be drafted.
+**Player** | Identitiable as a person able to be drafted.
 **Position** | Value object based on position code: PG, SG, SF, PF, and C.
 **Roster** | Identifiable as a team, set of players that make up a single team.
 **Sim Event** | Result event emitted when a player is automatically selected by a front office.
@@ -55,62 +55,137 @@ Element      | Description
 
 ### The Drafting CLI
 
-The drafting module is meant to be interfaces using its Ruby API by consuming applications.  It also ships with a CLI which a user can interact with to emulate "the draft process".  Technically speaking, the CLI provides an example application built on top of the Drafting module.  Each time a CLI command is executed, its results will be resaved, so the output file can then be used as the next command's input file to string together commands.  The following sections are example CLI interactions:
+The drafting module is meant to be interfaced with using its Ruby API by consuming applications.  It also ships with a CLI which a user can interact with to emulate "the draft process".  Technically speaking, the CLI provides an example application built on top of the Drafting module.  Each time a CLI command is executed, its results will be resaved, so the output file can then be used as the next command's input file to string together commands.  The following sections are example CLI interactions:
 
-#### Generate a Fresh Draft
+##### Generate a Fresh Draft
 
 ```zsh
 basketball-draft -o tmp/draft.json
 ```
 
-#### N Top Available Players
+##### N Top Available Players
 
 ```zsh
 basketball-draft -i tmp/draft.json -t 10
 ```
 
-#### N Top Available Players for a Position
+##### N Top Available Players for a Position
 
 ```zsh
 basketball-draft -i tmp/draft.json -t 10 -q PG
 ```
 
-#### Output Current Rosters
+##### Output Current Rosters
 
 ```zsh
 basketball-draft -i tmp/draft.json -r
 ```
 
-#### Output Event Log
+##### Output Event Log
 
 ```zsh
 basketball-draft -i tmp/draft.json -l
 ```
 
-#### Simulate N picks
+##### Simulate N Picks
 
 ```zsh
 basketball-draft -i tmp/draft.json -s 10
 ```
 
-#### Skip N picks
+##### Skip N Picks
 
 ```zsh
 basketball-draft -i tmp/draft.json -x 10
 ```
 
-#### Pick Players
+##### Pick Players
 
 ```zsh
 basketball-draft -i tmp/draft.json -p P-100,P-200,P-300
 ```
 
-#### Simulate the Rest of the Draft
+##### Simulate the Rest of the Draft
 
 ```zsh
 basketball-draft -i tmp/draft.json -a
 ```
 
+##### Help Menu
+
+```zsh
+basketball-draft -h
+```
+
+## Scheduling Module
+
+The Scheduling module is meant to take a League (conferences/divisions/teams) and turn it into a Calendar.  This Calendar creation is atomic - the full calendar will be generated completely all in one call.  Here is a cartoon showing the major components:
+
+![Basketball Architecture - Scheduling](/docs/architecture/scheduling.png)
+
+Element      | Description
+:------------ | :-----------
+**Away Team** | Team object designated as the away team for a Game.
+**Calendar Serializer** | Understands how to serialize and deserialize a Calendar object.
+**Calendar** | Hold a calendar for a year season.  Pass in a year and the Calendar will know how to mark important boundary dates (preseason start, preseason end, season start, and season end) and it knows how to ensure Calendar correctness regarding dates.
+**Conference** | Describes a conference in terms of structure; composed of an array of divisions (there can only 3).
+**Coordinator** | Service which can generate a Calendar from a League.
+**Division** | Describes a division in terms of structure; composed of an array of teams (there can only 5).
+**Game** | Matches up a date with two teams (home and away) to represent a scheduled matchup.
+**Home Team** | Team object designated as the home team for a Game.
+**League Serializer** | Understands how to serialize and deserialize a League object.
+**League** | Describes a league in terms of structure; composed of an array conferences (there can only be 2).
+**Scheduling** | Bounded context (sub-module) dealing with matchup and calendar generation.
+**Team** | Identified by an ID and described by a name: represents a basketball team that can be scheduled.
+
+##### Generate League
+
+```zsh
+basketball-schedule -o tmp/league.json
+```
+
+##### Generate Calendar From League
+
+```zsh
+basketball-schedule -i tmp/league.json -o tmp/calendar.json
+```
+
+##### Generate Calendar From League For a Specific Year
+
+```zsh
+basketball-schedule -i tmp/league.json -o tmp/calendar.json -y 2005
+```
+
+##### Output a Generated Calendar's Matchups
+
+```zsh
+basketball-schedule -c tmp/calendar.json
+```
+
+##### Output a Generated Calendar's Matchups For a Specific Team
+
+```zsh
+basketball-schedule -c tmp/calendar.json -t C0-D0-T0
+```
+
+##### Output a Generated Calendar's Matchups For a Specific Date
+
+```zsh
+basketball-schedule -c tmp/calendar.json -d 2005-02-03
+```
+
+##### Output a Generated Calendar's Matchups For a Specific Team and Date
+
+```zsh
+basketball-schedule -c tmp/calendar.json -d 2005-02-03 -t C0-D0-T0
+```
+
+##### Help Menu
+
+```zsh
+basketball-schedule -h
+```
+
 ## Contributing
 
 ### Development Environment Configuration

data/basketball.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   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-draft]
+  s.executables = %w[basketball-draft basketball-schedule]
   s.homepage    = 'https://github.com/mattruggio/basketball'
   s.license     = 'MIT'
   s.metadata    = {

data/exe/basketball-schedule

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'basketball'
+
+Basketball::Scheduling::CLI.new(args: ARGV).invoke!

data/lib/basketball/drafting/cli.rb

@@ -7,7 +7,7 @@ require_relative 'position'
 
 module Basketball
   module Drafting
-    # Example:
+    # Examples:
     #   exe/basketball-draft -o tmp/draft.json
     #   exe/basketball-draft -i tmp/draft.json -o tmp/draft-wip.json -s 26 -p P-5,P-10 -t 10 -q PG
     #   exe/basketball-draft -i tmp/draft-wip.json -x 2
@@ -69,7 +69,7 @@ module Basketball
 
       def slop_parse(args)
         Slop.parse(args) do |o|
-          o.banner = 'Usage: draft [options] ...'
+          o.banner = 'Usage: basketball-draft [options] ...'
 
           o.string  '-i', '--input',
                     'Path to load the engine from. If omitted then a new draft will be generated.'

data/lib/basketball/drafting/engine.rb

@@ -100,7 +100,6 @@ module Basketball
         return if done?
 
         event = SkipEvent.new(
-          id: SecureRandom.uuid,
           front_office: current_front_office,
           pick: current_pick,
           round: current_round,
@@ -126,7 +125,6 @@ module Basketball
           )
 
           event = SimEvent.new(
-            id: SecureRandom.uuid,
             front_office:,
             player:,
             pick: current_pick,
@@ -149,7 +147,6 @@ module Basketball
         return nil if done?
 
         event = PickEvent.new(
-          id: SecureRandom.uuid,
           front_office: current_front_office,
           player:,
           pick: current_pick,
@@ -206,11 +203,11 @@ module Basketball
 
         raise UnknownFrontOfficeError, "#{front_office} doesnt exist" unless front_offices.include?(event.front_office)
 
-        raise DupeEventError,          "#{event} is a dupe"                if events.include?(event)
-        raise EventOutOfOrder,         "#{event} has wrong pick"           if event.pick != current_pick
-        raise EventOutOfOrder,         "#{event} has wrong round"          if event.round != current_round
-        raise EventOutOfOrder,         "#{event} has wrong round_pick"     if event.round_pick != current_round_pick
-        raise EndOfDraftError,         "#{total_picks} pick limit reached" if events.length > total_picks + 1
+        raise DupeEventError,  "#{event} is a dupe"                if events.include?(event)
+        raise EventOutOfOrder, "#{event} has wrong pick"           if event.pick != current_pick
+        raise EventOutOfOrder, "#{event} has wrong round"          if event.round != current_round
+        raise EventOutOfOrder, "#{event} has wrong round_pick"     if event.round_pick != current_round_pick
+        raise EndOfDraftError, "#{total_picks} pick limit reached" if events.length > total_picks + 1
 
         events << event
 

data/lib/basketball/drafting/engine_serializer.rb

@@ -115,7 +115,6 @@ module Basketball
         events.map do |event|
           {
             type: event.class.name.split('::').last,
-            id: event.id,
             front_office: event.front_office.id,
             pick: event.pick,
             round: event.round,
@@ -157,7 +156,7 @@ module Basketball
 
       def deserialize_events(json, players, front_offices)
         (json.dig(:engine, :events) || []).map do |event_hash|
-          event_opts = event_hash.slice(:id, :pick, :round, :round_pick).merge(
+          event_opts = event_hash.slice(:pick, :round, :round_pick).merge(
             front_office: front_offices.find { |t| t.id == event_hash[:front_office] }
           )
 

data/lib/basketball/drafting/event.rb

@@ -2,11 +2,11 @@
 
 module Basketball
   module Drafting
-    class Event < Entity
-      attr_reader :pick, :round, :round_pick, :front_office
+    class Event < ValueObject
+      attr_reader_value :pick, :round, :round_pick, :front_office
 
-      def initialize(id:, front_office:, pick:, round:, round_pick:)
-        super(id)
+      def initialize(front_office:, pick:, round:, round_pick:)
+        super()
 
         raise ArgumentError, 'front_office required' unless front_office
 

data/lib/basketball/drafting/league.rb

@@ -5,7 +5,6 @@ require_relative 'roster'
 module Basketball
   module Drafting
     class League
-      class PlayerAlreadyRegisteredError < StandardError; end
       class RosterNotFoundError < StandardError; end
       class RosterAlreadyAddedError < StandardError; end
 

data/lib/basketball/drafting/pick_event.rb

@@ -5,10 +5,10 @@ require_relative 'event'
 module Basketball
   module Drafting
     class PickEvent < Event
-      attr_reader :player
+      attr_reader_value :player
 
-      def initialize(id:, front_office:, player:, pick:, round:, round_pick:)
-        super(id:, front_office:, pick:, round:, round_pick:)
+      def initialize(front_office:, player:, pick:, round:, round_pick:)
+        super(front_office:, pick:, round:, round_pick:)
 
         raise ArgumentError, 'player required' unless player
 

data/lib/basketball/drafting/roster.rb

@@ -3,7 +3,6 @@
 module Basketball
   module Drafting
     class Roster < Entity
-      class PlayerAlreadyRegisteredError < StandardError; end
       class PlayerRequiredError < StandardError; end
 
       attr_reader :name, :players

data/lib/basketball/drafting/sim_event.rb

@@ -3,10 +3,10 @@
 module Basketball
   module Drafting
     class SimEvent < Event
-      attr_reader :player
+      attr_reader_value :player
 
-      def initialize(id:, front_office:, player:, pick:, round:, round_pick:)
-        super(id:, front_office:, pick:, round:, round_pick:)
+      def initialize(front_office:, player:, pick:, round:, round_pick:)
+        super(front_office:, pick:, round:, round_pick:)
 
         raise ArgumentError, 'player required' unless player
 

data/lib/basketball/drafting.rb

@@ -1,3 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'drafting/cli'
+
+module Basketball
+  module Drafting
+    class PlayerAlreadyRegisteredError < StandardError; end
+  end
+end

data/lib/basketball/scheduling/calendar.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Scheduling
+    class Calendar < ValueObject
+      class TeamAlreadyBookedError < StandardError; end
+      class InvalidGameOrderError < StandardError; end
+      class OutOfBoundsError < StandardError; end
+
+      attr_reader :preseason_start_date,
+                  :preseason_end_date,
+                  :season_start_date,
+                  :season_end_date
+
+      attr_reader_value :year, :games
+
+      def initialize(year:, games: [])
+        super()
+
+        raise ArgumentError, 'year is required' unless year
+
+        @year                 = year
+        @preseason_start_date = Date.new(year, 9, 30)
+        @preseason_end_date   = Date.new(year, 10, 14)
+        @season_start_date    = Date.new(year, 10, 18)
+        @season_end_date      = Date.new(year + 1, 4, 29)
+        @games                = []
+
+        games.each { |game| add!(game) }
+
+        freeze
+      end
+
+      def add!(game)
+        assert_in_bounds(game)
+        assert_free_date(game)
+
+        @games << game
+
+        self
+      end
+
+      def preseason_games_for(date: nil, team: nil)
+        games_for(date:, team:).select { |game| game.is_a?(PreseasonGame) }
+      end
+
+      def season_games_for(date: nil, team: nil)
+        games_for(date:, team:).select { |game| game.is_a?(SeasonGame) }
+      end
+
+      def games_for(date: nil, team: nil)
+        games.select do |game|
+          (date.nil? || game.date == date) &&
+            (team.nil? || (game.home_team == team || game.away_team == team))
+        end
+      end
+
+      def available_preseason_dates_for(team)
+        all_preseason_dates - preseason_games_for(team:).map(&:date)
+      end
+
+      def available_season_dates_for(team)
+        all_season_dates - season_games_for(team:).map(&:date)
+      end
+
+      def available_preseason_matchup_dates(team1, team2)
+        available_team_dates       = available_preseason_dates_for(team1)
+        available_other_team_dates = available_preseason_dates_for(team2)
+
+        available_team_dates & available_other_team_dates
+      end
+
+      def available_season_matchup_dates(team1, team2)
+        available_team_dates       = available_season_dates_for(team1)
+        available_other_team_dates = available_season_dates_for(team2)
+
+        available_team_dates & available_other_team_dates
+      end
+
+      def teams
+        games.flat_map(&:teams)
+      end
+
+      def team(id)
+        teams.find { |t| t == Team.new(id:) }
+      end
+
+      private
+
+      def all_preseason_dates
+        (preseason_start_date..preseason_end_date).to_a
+      end
+
+      def all_season_dates
+        (season_start_date..season_end_date).to_a
+      end
+
+      def assert_free_date(game)
+        if games_for(date: game.date, team: game.home_team).any?
+          raise TeamAlreadyBookedError, "#{game.home_team} already playing on #{game.date}"
+        end
+
+        return unless games_for(date: game.date, team: game.away_team).any?
+
+        raise TeamAlreadyBookedError, "#{game.away_team} already playing on #{game.date}"
+      end
+
+      def assert_in_bounds(game)
+        if game.is_a?(PreseasonGame)
+          raise OutOfBoundsError, "#{game.date} is before preseason begins" if game.date < preseason_start_date
+          raise OutOfBoundsError, "#{game.date} is after preseason ends"    if game.date > preseason_end_date
+        elsif game.is_a?(SeasonGame)
+          raise OutOfBoundsError, "#{game.date} is before season begins" if game.date < season_start_date
+          raise OutOfBoundsError, "#{game.date} is after season ends"    if game.date > season_end_date
+        else
+          raise ArgumentError, "Dont know what this game type is: #{game.class.name}"
+        end
+      end
+    end
+  end
+end

data/lib/basketball/scheduling/calendar_serializer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'game'
+require_relative 'preseason_game'
+require_relative 'season_game'
+
+module Basketball
+  module Scheduling
+    class CalendarSerializer
+      GAME_CLASSES = {
+        'PreseasonGame' => PreseasonGame,
+        'SeasonGame' => SeasonGame
+      }.freeze
+
+      def deserialize(string)
+        json = JSON.parse(string, symbolize_names: true)
+
+        Calendar.new(
+          year: json[:year].to_i,
+          games: deserialize_games(json)
+        )
+      end
+
+      def serialize(calendar)
+        {
+          year: calendar.preseason_start_date.year,
+          teams: serialize_teams(calendar.games.flat_map(&:teams).uniq),
+          games: serialize_games(calendar.games)
+        }.to_json
+      end
+
+      private
+
+      ## Deserialization
+
+      def deserialize_games(json)
+        teams = deserialize_teams(json[:teams])
+
+        (json[:games] || []).map do |game_hash|
+          GAME_CLASSES.fetch(game_hash[:type]).new(
+            date: Date.parse(game_hash[:date]),
+            home_team: teams.fetch(game_hash[:home_team]),
+            away_team: teams.fetch(game_hash[:away_team])
+          )
+        end
+      end
+
+      def deserialize_teams(teams)
+        (teams || []).to_h do |id, team_hash|
+          team = Team.new(id:, name: team_hash[:name])
+
+          [
+            team.id,
+            team
+          ]
+        end
+      end
+
+      ## Serialization
+
+      def serialize_teams(teams)
+        teams.to_h do |team|
+          [
+            team.id,
+            {
+              name: team.name
+            }
+          ]
+        end
+      end
+
+      def serialize_games(games)
+        games.sort_by(&:date).map do |game|
+          {
+            type: game.class.name.split('::').last,
+            date: game.date,
+            home_team: game.home_team.id,
+            away_team: game.away_team.id
+          }
+        end
+      end
+    end
+  end
+end