basketball 0.0.7 → 0.0.9

data/lib/basketball/drafting/engine_serializer.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'front_office'
-require_relative 'player'
-require_relative 'pick_event'
-require_relative 'sim_event'
-require_relative 'skip_event'
-
-module Basketball
-  module Drafting
-    class EngineSerializer
-      EVENT_CLASSES = {
-        'PickEvent' => PickEvent,
-        'SimEvent' => SimEvent,
-        'SkipEvent' => SkipEvent
-      }.freeze
-
-      private_constant :EVENT_CLASSES
-
-      def to_hash(engine)
-        {
-          'info' => serialize_info(engine),
-          'engine' => serialize_engine(engine),
-          'league' => serialize_league(engine)
-        }
-      end
-
-      def from_hash(json)
-        front_offices = deserialize_front_offices(json)
-        players       = deserialize_players(json)
-        events        = deserialize_events(json, players, front_offices)
-
-        engine_opts = {
-          players:,
-          front_offices:,
-          events:
-        }
-
-        engine_opts[:rounds] = json.dig('engine', 'rounds') if json.dig('engine', 'rounds')
-
-        Engine.new(**engine_opts)
-      end
-
-      def deserialize(string)
-        json = JSON.parse(string)
-
-        from_hash(json)
-      end
-
-      def serialize(engine)
-        to_hash(engine).to_json
-      end
-
-      private
-
-      def serialize_engine(engine)
-        {
-          'rounds' => engine.rounds,
-          'front_offices' => serialize_front_offices(engine),
-          'players' => serialize_players(engine),
-          'events' => serialize_events(engine.events)
-        }
-      end
-
-      def serialize_info(engine)
-        {
-          'total_picks' => engine.total_picks,
-          'current_round' => engine.current_round,
-          'current_round_pick' => engine.current_round_pick,
-          'current_front_office' => engine.current_front_office&.id,
-          'current_pick' => engine.current_pick,
-          'remaining_picks' => engine.remaining_picks,
-          'done' => engine.done?
-        }
-      end
-
-      def serialize_league(engine)
-        league = engine.to_league
-
-        rosters = league.rosters.to_h do |roster|
-          [
-            roster.id,
-            {
-              'players' => roster.players.map(&:id)
-            }
-          ]
-        end
-
-        {
-          'free_agents' => league.free_agents.map(&:id),
-          'rosters' => rosters
-        }
-      end
-
-      def serialize_front_offices(engine)
-        engine.front_offices.to_h do |front_office|
-          [
-            front_office.id,
-            {
-              'name' => front_office.name,
-              'fuzz' => front_office.fuzz,
-              'depth' => front_office.depth,
-              'prioritized_positions' => front_office.prioritized_positions.map(&:code)
-            }
-          ]
-        end
-      end
-
-      def serialize_players(engine)
-        engine.players.to_h do |player|
-          [
-            player.id,
-            {
-              'first_name' => player.first_name,
-              'last_name' => player.last_name,
-              'overall' => player.overall,
-              'position' => player.position.code
-            }
-          ]
-        end
-      end
-
-      def serialize_events(events)
-        events.map do |event|
-          {
-            'type' => event.class.name.split('::').last,
-            'front_office' => event.front_office.id,
-            'pick' => event.pick,
-            'round' => event.round,
-            'round_pick' => event.round_pick
-          }.tap do |hash|
-            hash['player'] = event.player.id if event.respond_to?(:player)
-          end
-        end
-      end
-
-      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: front_office_hash['name'],
-            prioritized_positions:,
-            fuzz: front_office_hash['fuzz'],
-            depth: front_office_hash['depth']
-          }
-
-          FrontOffice.new(**front_office_opts)
-        end
-      end
-
-      def deserialize_players(json)
-        (json.dig('engine', 'players') || []).map do |id, player_hash|
-          player_opts = {
-            id:,
-            first_name: player_hash['first_name'],
-            last_name: player_hash['last_name'],
-            overall: player_hash['overall'],
-            position: Position.new(player_hash['position'])
-          }
-
-          Player.new(**player_opts)
-        end
-      end
-
-      def deserialize_events(json, players, front_offices)
-        (json.dig('engine', 'events') || []).map do |event_hash|
-          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'])
-
-          if [PickEvent, SimEvent].include?(class_constant)
-            event_opts[:player] = players.find { |p| p.id == event_hash['player'] }
-          end
-
-          class_constant.new(**event_opts)
-        end
-      end
-    end
-  end
-end

data/lib/basketball/drafting/front_office.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Drafting
-    class FrontOffice < Entity
-      MAX_DEPTH     = 3
-      MAX_FUZZ      = 2
-      MAX_POSITIONS = 12
-
-      private_constant :MAX_DEPTH, :MAX_FUZZ, :MAX_POSITIONS
-
-      attr_reader :prioritized_positions, :fuzz, :depth, :name
-
-      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
-
-        # fill in the rest of the queue here
-        need_count = MAX_POSITIONS - @prioritized_positions.length
-
-        @prioritized_positions += random_positions_queue[0...need_count]
-
-        freeze
-      end
-
-      def pick(undrafted_player_search:, drafted_players:, round:)
-        players = []
-
-        players = adaptive_search(undrafted_player_search:, drafted_players:) if depth >= round
-        players = balanced_search(undrafted_player_search:, drafted_players:) if players.empty?
-        players = top_players(undrafted_player_search:)                       if players.empty?
-
-        players[0..fuzz].sample
-      end
-
-      def to_s
-        "[#{super}] #{name}"
-      end
-
-      private
-
-      def adaptive_search(undrafted_player_search:, drafted_players:)
-        drafted_positions = drafted_players.map(&:position)
-
-        undrafted_player_search.query(exclude_positions: drafted_positions)
-      end
-
-      def balanced_search(undrafted_player_search:, drafted_players:)
-        players = []
-
-        # Try to find best pick for exact desired position.
-        # If you cant find one, then move to the next desired position until the end of the queue
-        available_prioritized_positions(drafted_players:).each do |position|
-          players = undrafted_player_search.query(position:)
-
-          break if players.any?
-        end
-
-        players = players.any? ? players : undrafted_player_search.query
-      end
-
-      def all_random_positions
-        Position::ALL_VALUES.to_a.shuffle.map { |v| Position.new(v) }
-      end
-
-      def random_positions_queue
-        all_random_positions + all_random_positions + [Position.random] + [Position.random]
-      end
-
-      def available_prioritized_positions(drafted_players:)
-        drafted_positions = drafted_players.map(&:position)
-        queue             = prioritized_positions.dup
-
-        drafted_positions.each do |drafted_position|
-          index = queue.index(drafted_position)
-
-          next unless index
-
-          queue.delete_at(index)
-
-          queue << drafted_position
-        end
-
-        queue
-      end
-    end
-  end
-end

data/lib/basketball/drafting/league.rb

@@ -1,70 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'event'
-
-module Basketball
-  module Drafting
-    class PickEvent < Event
-      attr_reader_value :player
-
-      def initialize(front_office:, player:, pick:, round:, round_pick:)
-        super(front_office:, pick:, round:, round_pick:)
-
-        raise ArgumentError, 'player required' unless player
-
-        @player = player
-
-        freeze
-      end
-
-      def to_s
-        "#{player} picked #{super}"
-      end
-    end
-  end
-end

data/lib/basketball/drafting/player.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Drafting
-    class Player < Entity
-      STAR_THRESHOLD         = 75
-      OVERALL_STAR_INDICATOR = '⭐'
-
-      private_constant :STAR_THRESHOLD, :OVERALL_STAR_INDICATOR
-
-      attr_reader :first_name, :last_name, :position, :overall
-
-      def initialize(id:, position:, first_name: '', last_name: '', overall: 0)
-        super(id)
-
-        raise ArgumentError, 'position is required' unless position
-
-        @first_name = first_name.to_s
-        @last_name  = last_name.to_s
-        @position   = position
-        @overall    = overall.to_i
-
-        freeze
-      end
-
-      def full_name
-        "#{first_name.strip} #{last_name.strip}".strip
-      end
-
-      def to_s
-        "[#{super}] #{full_name} (#{position}) #{overall} #{star_indicators.join(', ')}".strip
-      end
-
-      private
-
-      def star_indicators
-        [].tap do |indicators|
-          indicators << OVERALL_STAR_INDICATOR if overall >= STAR_THRESHOLD
-        end
-      end
-    end
-  end
-end

data/lib/basketball/drafting/roster.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Drafting
-    class Roster < Entity
-      class PlayerRequiredError < StandardError; end
-
-      attr_reader :name, :players
-
-      def initialize(id:, name: '', players: [])
-        super(id)
-
-        @name    = name.to_s
-        @players = players.each { |p| register!(p) }
-
-        freeze
-      end
-
-      def registered?(player)
-        players.include?(player)
-      end
-
-      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
-        (["[#{super}] #{name} Roster"] + players.map(&:to_s)).join("\n")
-      end
-    end
-  end
-end

data/lib/basketball/drafting/sim_event.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Drafting
-    class SimEvent < Event
-      attr_reader_value :player
-
-      def initialize(front_office:, player:, pick:, round:, round_pick:)
-        super(front_office:, pick:, round:, round_pick:)
-
-        raise ArgumentError, 'player required' unless player
-
-        @player = player
-
-        freeze
-      end
-
-      def to_s
-        "#{player} auto-picked #{super}"
-      end
-    end
-  end
-end

data/lib/basketball/drafting/skip_event.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'event'
-
-module Basketball
-  module Drafting
-    class SkipEvent < Event
-      def to_s
-        "skipped #{super}"
-      end
-    end
-  end
-end

data/lib/basketball/drafting.rb

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

data/lib/basketball/scheduling/calendar.rb

@@ -1,121 +0,0 @@
-# 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