basketball 0.0.4 → 0.0.6

data/lib/basketball/drafting/engine_serializer.rb

@@ -2,7 +2,6 @@
 
 require_relative 'front_office'
 require_relative 'player'
-require_relative 'team'
 require_relative 'pick_event'
 require_relative 'sim_event'
 require_relative 'skip_event'
@@ -19,14 +18,14 @@ module Basketball
       private_constant :EVENT_CLASSES
 
       def deserialize(string)
-        json        = JSON.parse(string, symbolize_names: true)
-        teams       = deserialize_teams(json)
-        players     = deserialize_players(json)
-        events = deserialize_events(json, players, teams)
+        json          = JSON.parse(string, symbolize_names: true)
+        front_offices = deserialize_front_offices(json)
+        players       = deserialize_players(json)
+        events        = deserialize_events(json, players, front_offices)
 
         engine_opts = {
           players:,
-          teams:,
+          front_offices:,
           events:
         }
 
@@ -39,7 +38,7 @@ module Basketball
         {
           info: serialize_info(engine),
           engine: serialize_engine(engine),
-          rosters: serialize_rosters(engine)
+          league: serialize_league(engine)
         }.to_json
       end
 
@@ -48,7 +47,7 @@ module Basketball
       def serialize_engine(engine)
         {
           rounds: engine.rounds,
-          teams: serialize_teams(engine),
+          front_offices: serialize_front_offices(engine),
           players: serialize_players(engine),
           events: serialize_events(engine.events)
         }
@@ -59,37 +58,40 @@ module Basketball
           total_picks: engine.total_picks,
           current_round: engine.current_round,
           current_round_pick: engine.current_round_pick,
-          current_team: engine.current_team&.id,
+          current_front_office: engine.current_front_office&.id,
           current_pick: engine.current_pick,
           remaining_picks: engine.remaining_picks,
-          done: engine.done?,
-          undrafted_players: engine.undrafted_players.map(&:id)
+          done: engine.done?
         }
       end
 
-      def serialize_rosters(engine)
-        engine.rosters.to_h do |roster|
+      def serialize_league(engine)
+        league = engine.to_league
+
+        rosters = league.rosters.to_h do |roster|
           [
             roster.id,
             {
-              events: roster.events.map(&:id),
               players: roster.players.map(&:id)
             }
           ]
         end
+
+        {
+          free_agents: league.free_agents.map(&:id),
+          rosters:
+        }
       end
 
-      def serialize_teams(engine)
-        engine.teams.to_h do |team|
+      def serialize_front_offices(engine)
+        engine.front_offices.to_h do |front_office|
           [
-            team.id,
+            front_office.id,
             {
-              name: team.name,
-              front_office: {
-                fuzz: team.front_office.fuzz,
-                depth: team.front_office.depth,
-                prioritized_positions: team.front_office.prioritized_positions
-              }
+              name: front_office.name,
+              fuzz: front_office.fuzz,
+              depth: front_office.depth,
+              prioritized_positions: front_office.prioritized_positions.map(&:code)
             }
           ]
         end
@@ -113,8 +115,7 @@ module Basketball
         events.map do |event|
           {
             type: event.class.name.split('::').last,
-            id: event.id,
-            team: event.team.id,
+            front_office: event.front_office.id,
             pick: event.pick,
             round: event.round,
             round_pick: event.round_pick
@@ -124,30 +125,21 @@ module Basketball
         end
       end
 
-      def deserialize_teams(json)
-        (json.dig(:engine, :teams) || []).map do |id, team_hash|
-          team_opts = {
+      def deserialize_front_offices(json)
+        (json.dig(:engine, :front_offices) || []).map do |id, front_office_hash|
+          prioritized_positions = (front_office_hash[:prioritized_positions] || []).map do |v|
+            Position.new(v)
+          end
+
+          front_office_opts = {
             id:,
-            name: team_hash[:name]
+            name: front_office_hash[:name],
+            prioritized_positions:,
+            fuzz: front_office_hash[:fuzz],
+            depth: front_office_hash[:depth]
           }
 
-          if team_hash.key?(:front_office)
-            front_office_hash = team_hash[:front_office] || {}
-
-            prioritized_positions = (front_office_hash[:prioritized_positions] || []).map do |v|
-              Position.new(v)
-            end
-
-            front_office_opts = {
-              prioritized_positions:,
-              fuzz: front_office_hash[:fuzz],
-              depth: front_office_hash[:depth]
-            }
-
-            team_opts[:front_office] = FrontOffice.new(**front_office_opts)
-          end
-
-          Team.new(**team_opts)
+          FrontOffice.new(**front_office_opts)
         end
       end
 
@@ -162,10 +154,10 @@ module Basketball
         end
       end
 
-      def deserialize_events(json, players, teams)
+      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(
-            team: teams.find { |t| t.id == event_hash[:team] }
+          event_opts = event_hash.slice(:pick, :round, :round_pick).merge(
+            front_office: front_offices.find { |t| t.id == event_hash[:front_office] }
           )
 
           class_constant = EVENT_CLASSES.fetch(event_hash[:type])

data/lib/basketball/drafting/event.rb

@@ -2,22 +2,22 @@
 
 module Basketball
   module Drafting
-    class Event < Entity
-      attr_reader :pick, :round, :round_pick, :team
+    class Event < ValueObject
+      attr_reader_value :pick, :round, :round_pick, :front_office
 
-      def initialize(id:, team:, pick:, round:, round_pick:)
-        super(id)
+      def initialize(front_office:, pick:, round:, round_pick:)
+        super()
 
-        raise ArgumentError, 'team required' unless team
+        raise ArgumentError, 'front_office required' unless front_office
 
-        @team       = team
-        @pick       = pick.to_i
-        @round      = round.to_i
-        @round_pick = round_pick.to_i
+        @front_office = front_office
+        @pick         = pick.to_i
+        @round        = round.to_i
+        @round_pick   = round_pick.to_i
       end
 
       def to_s
-        "##{pick} overall (R#{round}:P#{round_pick}) by #{team}"
+        "##{pick} overall (R#{round}:P#{round_pick}) by #{front_office}"
       end
     end
   end

data/lib/basketball/drafting/front_office.rb

@@ -2,18 +2,19 @@
 
 module Basketball
   module Drafting
-    class FrontOffice < ValueObject
+    class FrontOffice < Entity
       MAX_DEPTH     = 3
       MAX_FUZZ      = 2
       MAX_POSITIONS = 12
 
       private_constant :MAX_DEPTH, :MAX_FUZZ, :MAX_POSITIONS
 
-      attr_reader_value :prioritized_positions, :fuzz, :depth
+      attr_reader :prioritized_positions, :fuzz, :depth, :name
 
-      def initialize(prioritized_positions: [], fuzz: rand(0..MAX_FUZZ), depth: rand(0..MAX_DEPTH))
-        super()
+      def initialize(id:, name: '', prioritized_positions: [], fuzz: rand(0..MAX_FUZZ), depth: rand(0..MAX_DEPTH))
+        super(id)
 
+        @name                  = name
         @fuzz                  = fuzz.to_i
         @depth                 = depth.to_i
         @prioritized_positions = prioritized_positions
@@ -36,6 +37,10 @@ module Basketball
         players[0..fuzz].sample
       end
 
+      def to_s
+        "[#{super}] #{name}"
+      end
+
       private
 
       def adaptive_search(undrafted_player_search:, drafted_players:)

data/lib/basketball/drafting/league.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'roster'
+
+module Basketball
+  module Drafting
+    class League
+      class RosterNotFoundError < StandardError; end
+      class RosterAlreadyAddedError < StandardError; end
+
+      attr_reader :free_agents, :rosters
+
+      def initialize(free_agents: [], front_offices: [])
+        @rosters     = []
+        @free_agents = []
+
+        front_offices.each { |front_office| add_roster(front_office) }
+        free_agents.each   { |p| register!(player: p) }
+
+        freeze
+      end
+
+      def roster(front_office)
+        rosters.find { |r| r == front_office }
+      end
+
+      def register!(player:, front_office: nil)
+        raise PlayerRequiredError, 'player is required' unless player
+
+        rosters.each do |roster|
+          if roster.registered?(player)
+            raise PlayerAlreadyRegisteredError,
+                  "#{player} already registered to: #{roster.id}"
+          end
+        end
+
+        if free_agents.include?(player)
+          raise PlayerAlreadyRegisteredError,
+                "#{player} already registered as a free agent"
+        end
+
+        if front_office
+          roster = roster(front_office)
+
+          raise RosterNotFoundError, "Roster not found for: #{front_office}" unless roster
+
+          roster.sign!(player)
+        else
+          free_agents << player
+        end
+
+        self
+      end
+
+      def to_s
+        (['League'] + rosters.map(&:to_s)).join("\n")
+      end
+
+      private
+
+      def add_roster(front_office)
+        raise RosterAlreadyAddedError, "#{front_office} already added" if rosters.include?(front_office)
+
+        rosters << Roster.new(id: front_office.id, name: front_office.name)
+
+        self
+      end
+    end
+  end
+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:, team:, player:, pick:, round:, round_pick:)
-        super(id:, team:, 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

@@ -2,41 +2,35 @@
 
 module Basketball
   module Drafting
-    class Roster < ValueObject
-      extend Forwardable
+    class Roster < Entity
+      class PlayerRequiredError < StandardError; end
 
-      class WrongTeamEventError < StandardError; end
+      attr_reader :name, :players
 
-      attr_reader_value :team, :events
+      def initialize(id:, name: '', players: [])
+        super(id)
 
-      def_delegators :team, :id
+        @name    = name.to_s
+        @players = players.each { |p| register!(p) }
 
-      def initialize(team:, events: [])
-        super()
-
-        raise ArgumentError, 'team is required' unless team
-
-        other_teams_pick_event_ids = events.reject { |e| e.team == team }.map(&:id)
-
-        if other_teams_pick_event_ids.any?
-          raise WrongTeamEventError,
-                "Event(s): #{other_teams_pick_event_ids.join(',')} has wrong team"
-        end
-
-        @team   = team
-        @events = events
+        freeze
       end
 
-      def player_events
-        events.select { |e| e.respond_to?(:player) }
+      def registered?(player)
+        players.include?(player)
       end
 
-      def players
-        player_events.map(&:player)
+      def sign!(player)
+        raise PlayerRequiredError, 'player is required' unless player
+        raise PlayerAlreadyRegisteredError, "#{player} already registered for #{id}" if registered?(player)
+
+        players << player
+
+        self
       end
 
       def to_s
-        ([team.to_s] + players.map(&:to_s)).join("\n")
+        (["[#{super}] #{name} Roster"] + players.map(&:to_s)).join("\n")
       end
     end
   end

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:, team:, player:, pick:, round:, round_pick:)
-        super(id:, team:, 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