basketball 0.0.8 → 0.0.9

data/lib/basketball/draft/front_office.rb

@@ -2,22 +2,34 @@
 
 module Basketball
   module Draft
+    # A team will send their front office to a draft room to make draft selections.
     class FrontOffice < Entity
-      MAX_DEPTH     = 3
-      MAX_FUZZ      = 2
+      # The higher the number the more the front office will make more top-player-based decisions
+      # over position-based decisions.
+      DEFAULT_MAX_STAR_LEVEL = 5
+
+      # Riskier front offices may choose to not draft the top player.  The higher the number the more
+      # they will not select the top player available.
+      DEFAULT_MAX_RISK_LEVEL = 5
+
       MAX_POSITIONS = 12
 
-      private_constant :MAX_DEPTH, :MAX_FUZZ, :MAX_POSITIONS
+      private_constant :DEFAULT_MAX_STAR_LEVEL, :DEFAULT_MAX_RISK_LEVEL, :MAX_POSITIONS
 
-      attr_reader :prioritized_positions, :fuzz, :depth, :name
+      attr_reader :prioritized_positions, :risk_level, :star_level, :scout
 
-      def initialize(id:, name: '', prioritized_positions: [], fuzz: rand(0..MAX_FUZZ), depth: rand(0..MAX_DEPTH))
+      def initialize(
+        id:,
+        prioritized_positions: [],
+        risk_level: rand(0..DEFAULT_MAX_RISK_LEVEL),
+        star_level: rand(0..DEFAULT_MAX_STAR_LEVEL)
+      )
         super(id)
 
-        @name                  = name
-        @fuzz                  = fuzz.to_i
-        @depth                 = depth.to_i
+        @risk_level            = risk_level.to_i
+        @star_level            = star_level.to_i
         @prioritized_positions = prioritized_positions
+        @scout                 = Scout.new
 
         # fill in the rest of the queue here
         need_count = MAX_POSITIONS - @prioritized_positions.length
@@ -27,51 +39,46 @@ module Basketball
         freeze
       end
 
-      def pick(undrafted_player_search:, drafted_players:, round:)
+      def pick(assessment)
         players = []
+        players = adaptive_search(assessment) if star_level >= assessment.round
+        players = balanced_search(assessment) if players.empty?
+        players = top_players(assessment)     if players.empty?
 
-        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}"
+        players[0..risk_level].sample
       end
 
       private
 
-      def adaptive_search(undrafted_player_search:, drafted_players:)
-        drafted_positions = drafted_players.map(&:position)
+      def adaptive_search(assessment)
+        drafted_positions = assessment.drafted_players.map(&:position)
 
-        undrafted_player_search.query(exclude_positions: drafted_positions)
+        scout.top_for(players: assessment.undrafted_players, exclude_positions: drafted_positions)
       end
 
-      def balanced_search(undrafted_player_search:, drafted_players:)
+      def balanced_search(assessment)
         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:)
+        available_prioritized_positions(assessment.drafted_players).each do |position|
+          players = scout.top_for(players: assessment.undrafted_players, position:)
 
           break if players.any?
         end
 
-        players = players.any? ? players : undrafted_player_search.query
+        players = players.any? ? players : scout.top_for
       end
 
       def all_random_positions
-        Position::ALL_VALUES.to_a.shuffle.map { |v| Position.new(v) }
+        Org::Position::ALL_VALUES.to_a.shuffle.map { |v| Org::Position.new(v) }
       end
 
       def random_positions_queue
-        all_random_positions + all_random_positions + [Position.random] + [Position.random]
+        all_random_positions + all_random_positions + [Org::Position.random] + [Org::Position.random]
       end
 
-      def available_prioritized_positions(drafted_players:)
+      def available_prioritized_positions(drafted_players)
         drafted_positions = drafted_players.map(&:position)
         queue             = prioritized_positions.dup
 

data/lib/basketball/draft/{pick_event.rb → pick.rb}

@@ -1,25 +1,32 @@
 # frozen_string_literal: true
 
-require_relative 'event'
-
 module Basketball
   module Draft
-    class PickEvent < Event
-      attr_reader_value :player
+    # Room event where a player is selected.
+    class Pick < Event
+      value_reader :player, :auto
 
-      def initialize(front_office:, player:, pick:, round:, round_pick:)
+      def initialize(front_office:, player:, pick:, round:, round_pick:, auto: false)
         super(front_office:, pick:, round:, round_pick:)
 
         raise ArgumentError, 'player required' unless player
 
         @player = player
+        @auto   = auto
 
         freeze
       end
 
       def to_s
-        "#{player} picked #{super}"
+        "#{super} #{auto ? 'auto-' : ''}picked #{player}"
+      end
+
+      def ==(other)
+        super &&
+          player == other.player &&
+          auto == other.auto
       end
+      alias eql? ==
     end
   end
 end

data/lib/basketball/draft/room.rb

@@ -1,142 +1,146 @@
 # frozen_string_literal: true
 
-require_relative 'league'
-
 module Basketball
   module Draft
+    # Main pick-by-pick iterator object which will round-robin rotate team selections.
     class Room
       class AlreadyPickedError < StandardError; end
-      class DupeEventError < StandardError; end
+      class EndOfDraftError < StandardError; end
       class EventOutOfOrderError < StandardError; end
-      class UnknownPlayerError < StandardError; end
+      class FrontOfficeAlreadyRegisteredError < StandardError; end
+      class PlayerAlreadyAddedError < StandardError; end
       class UnknownFrontOfficeError < StandardError; end
-      class EndOfDraftError < StandardError; end
-
-      DEFAULT_ROUNDS = 12
-
-      private_constant :DEFAULT_ROUNDS
+      class UnknownPlayerError < StandardError; end
 
-      attr_reader :events, :rounds
+      attr_reader :rounds, :players, :front_offices, :events, :id
 
-      def initialize(players: [], front_offices: [], events: [], rounds: DEFAULT_ROUNDS)
-        @players_by_id       = players.to_h { |p| [p.id, p] }
-        @front_offices_by_id = front_offices.to_h { |fo| [fo.id, fo] }
-        @events              = []
-        @rounds              = rounds.to_i
+      def initialize(front_offices:, rounds:, players: [], events: [])
+        raise InvalidRoundsError, "#{rounds} should be a positive number" unless rounds.positive?
 
-        # Each one will be validated for correctness.
-        events.each { |e| play!(e) }
+        @rounds        = rounds
+        @players       = []
+        @front_offices = []
+        @events        = []
 
-        freeze
+        front_offices.each { |front_office| register!(front_office) }
+        players.each       { |player| add_player!(player) }
+        events.each        { |event| add_event!(event) }
       end
 
-      def to_league
-        League.new(front_offices:).tap do |league|
-          player_events.each do |event|
-            league.register!(player: event.player, front_office: event.front_office)
-          end
+      # This method will return a materialized list of teams and their selections.
+      def league
+        Org::League.new.tap do |league|
+          front_offices.each do |front_office|
+            team = Org::Team.new(id: front_office.id)
+
+            league.register!(team)
 
-          undrafted_players.each do |player|
-            league.register!(player:)
+            drafted_players(front_office).each do |player|
+              league.sign!(player:, team:)
+            end
           end
         end
       end
 
-      def to_s
-        events.join("\n")
-      end
-
-      def front_offices
-        front_offices_by_id.values
-      end
+      ### Peek Methods
 
-      def players
-        players_by_id.values
+      def assessment
+        Assessment.new(
+          drafted_players: drafted_players(front_office),
+          undrafted_players:,
+          pick:,
+          round:,
+          round_pick:
+        )
       end
 
       def total_picks
         rounds * front_offices.length
       end
 
-      def current_round
+      def round
         return if done?
 
-        (current_pick / front_offices.length.to_f).ceil
+        (pick / front_offices.length.to_f).ceil
       end
 
-      def current_round_pick
+      def round_pick
         return if done?
 
-        mod = current_pick % front_offices.length
+        mod = pick % front_offices.length
 
         mod.positive? ? mod : front_offices.length
       end
 
-      def current_front_office
+      def front_office
         return if done?
 
-        front_offices[current_round_pick - 1]
+        front_offices[round_pick - 1]
       end
 
-      def current_pick
+      def pick
         return if done?
 
-        internal_current_pick
+        internal_pick
       end
 
       def remaining_picks
-        total_picks - internal_current_pick + 1
+        total_picks - internal_pick + 1
       end
 
       def done?
-        internal_current_pick > total_picks
+        internal_pick > total_picks
       end
 
       def not_done?
         !done?
       end
 
+      def drafted_players(front_office = nil)
+        raise UnknownFrontOfficeError, "#{front_office} doesnt exist" if front_office && !registered?(front_office)
+
+        player_events.each_with_object([]) do |e, memo|
+          next unless front_office.nil? || e.front_office == front_office
+
+          memo << e.player
+        end
+      end
+
+      def undrafted_players
+        players - drafted_players
+      end
+
+      ### Event Methods
+
       def skip!
         return if done?
 
-        event = SkipEvent.new(
-          front_office: current_front_office,
-          pick: current_pick,
-          round: current_round,
-          round_pick: current_round_pick
-        )
+        event = Skip.new(front_office:, pick:, round:, round_pick:)
 
-        play!(event)
+        add_event!(event)
 
         event
       end
 
-      def sim!(times = nil)
-        counter = 0
-        events  = []
+      def sim!
+        return if done?
+
+        player = front_office.pick(assessment)
+        event  = Pick.new(front_office:, pick:, round:, round_pick:, player:, auto: true)
 
-        until done? || (times && counter >= times)
-          front_office = current_front_office
+        add_event!(event)
 
-          player = front_office.pick(
-            undrafted_player_search:,
-            drafted_players: drafted_players(front_office),
-            round: current_round
-          )
+        event
+      end
 
-          event = SimEvent.new(
-            front_office:,
-            player:,
-            pick: current_pick,
-            round: current_round,
-            round_pick: current_round_pick
-          )
+      def sim_rest!
+        events = []
 
-          play!(event)
+        while not_done?
+          event = sim!
 
-          yield(event) if block_given?
+          yield event if block_given?
 
-          counter += 1
           events << event
         end
 
@@ -146,76 +150,72 @@ module Basketball
       def pick!(player)
         return nil if done?
 
-        event = PickEvent.new(
-          front_office: current_front_office,
-          player:,
-          pick: current_pick,
-          round: current_round,
-          round_pick: current_round_pick
-        )
-
-        play!(event)
-      end
-
-      def undrafted_players
-        players - drafted_players
-      end
+        event = Pick.new(front_office:, pick:, round:, round_pick:, player:)
 
-      def undrafted_player_search
-        PlayerSearch.new(undrafted_players)
+        add_event!(event)
       end
 
       private
 
-      attr_reader :players_by_id, :front_offices_by_id
+      attr_writer :id
 
       def player_events
         events.select { |e| e.respond_to?(:player) }
       end
 
-      def internal_current_pick
-        events.length + 1
+      # rubocop:disable Metrics/AbcSize
+      def add_event!(event)
+        raise EndOfDraftError, "#{total_picks} pick limit reached" if done?
+        raise UnknownFrontOfficeError, "#{front_office} doesnt exist" unless front_offices.include?(event.front_office)
+        raise EventOutOfOrderError, "#{event.front_office} cant pick right now" if event.front_office != front_office
+        raise EventOutOfOrderError, "#{event} has wrong pick" if event.pick != pick
+        raise EventOutOfOrderError, "#{event} has wrong round" if event.round != round
+        raise EventOutOfOrderError, "#{event} has wrong round_pick" if event.round_pick != round_pick
+
+        assert_player(event)
+
+        events << event
+
+        event
       end
+      # rubocop:enable Metrics/AbcSize
 
-      def drafted_players(front_office = nil)
-        player_events.each_with_object([]) do |e, memo|
-          next unless front_office.nil? || e.front_office == front_office
+      def assert_player(event)
+        return unless event.respond_to?(:player)
 
-          memo << e.player
-        end
+        raise AlreadyPickedError, "#{event.player} was already picked" if drafted_players.include?(event.player)
+        raise UnknownPlayerError, "#{event.player} doesnt exist" unless players.include?(event.player)
       end
 
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-      def play!(event)
-        if event.respond_to?(:player) && drafted_players.include?(event.player)
-          raise AlreadyPickedError, "#{player} was already picked"
-        end
+      def internal_pick
+        events.length + 1
+      end
 
-        if event.respond_to?(:player) && !players.include?(event.player)
-          raise UnknownPlayerError, "#{event.player} doesnt exist"
-        end
+      def registered?(front_office)
+        front_offices.include?(front_office)
+      end
 
-        if event.front_office != current_front_office
-          raise EventOutOfOrder, "#{event} #{event.front_office} cant pick right now"
-        end
+      def register!(front_office)
+        raise ArgumentError, 'front_office required' unless front_office
+        raise FrontOfficeAlreadyRegisteredError, "#{front_office} already registered" if registered?(front_office)
 
-        raise UnknownFrontOfficeError, "#{front_office} doesnt exist" unless front_offices.include?(event.front_office)
+        front_offices << 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
+        self
+      end
 
-        events << event
+      def player?(player)
+        players.include?(player)
+      end
 
-        event
+      def add_player!(player)
+        raise ArgumentError, 'player required' unless player
+        raise PlayerAlreadyAddedError, "#{player} already added" if player?(player)
+
+        players << player
+
+        self
       end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/basketball/draft/{player_search.rb → scout.rb}

@@ -2,14 +2,9 @@
 
 module Basketball
   module Draft
-    class PlayerSearch
-      attr_reader :players
-
-      def initialize(players = [])
-        @players = players
-      end
-
-      def query(position: nil, exclude_positions: [])
+    # A Scout knows how to process a set of players and figure out who the top prospects are.
+    class Scout
+      def top_for(players: [], position: nil, exclude_positions: [])
         filtered_players = players
 
         if position
@@ -24,7 +19,7 @@ module Basketball
           end
         end
 
-        filtered_players.sort_by(&:overall).reverse
+        filtered_players.sort_by { |p| [p.overall, p.id] }.reverse
       end
     end
   end

data/lib/basketball/draft/skip.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Draft
+    # Room event which indicates a front office has intentionally skipped a selection.
+    class Skip < Event
+      def to_s
+        "#{super} skipped"
+      end
+    end
+  end
+end

data/lib/basketball/draft.rb

@@ -1,9 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'draft/cli'
+# Services
+require_relative 'draft/scout'
 
-module Basketball
-  module Draft
-    class PlayerAlreadyRegisteredError < StandardError; end
-  end
-end
+# Common
+require_relative 'draft/assessment'
+require_relative 'draft/event'
+require_relative 'draft/front_office'
+
+# Event Subclasses
+require_relative 'draft/pick'
+require_relative 'draft/skip'
+
+# Specific
+require_relative 'draft/room'

data/lib/basketball/entity.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Basketball
+  # Base class for uniquely identifiable classes.  Subclasses are simply based on a string-based ID
+  # and comparison/sorting/equality will be done in a case-insensitive manner.
   class Entity
     extend Forwardable
     include Comparable
@@ -12,20 +14,24 @@ module Basketball
     def initialize(id)
       raise ArgumentError, 'id is required' if id.to_s.empty?
 
-      @id = id.to_s.upcase
+      @id = id
     end
 
     def <=>(other)
-      id <=> other.id
+      comparable_id <=> other.comparable_id
     end
 
     def ==(other)
-      id == other.id
+      comparable_id == other.comparable_id
     end
     alias eql? ==
 
     def hash
-      id.hash
+      comparable_id.hash
+    end
+
+    def comparable_id
+      id.to_s.upcase
     end
   end
 end

data/lib/basketball/org/league.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Describes a collection of teams and players.  Holds the rules which support
+    # adding teams and players to ensure the all the teams are cohesive, such as:
+    #   - preventing duplicate teams
+    #   - preventing double-signing players across teams
+    class League
+      class TeamAlreadyRegisteredError < StandardError; end
+      class UnregisteredTeamError < StandardError; end
+
+      attr_reader :teams
+
+      def initialize(teams: [])
+        @teams = []
+
+        teams.each { |team| register!(team) }
+
+        freeze
+      end
+
+      def to_s
+        teams.map(&:to_s).join("\n")
+      end
+
+      def sign!(player:, team:)
+        raise ArgumentError, 'player is required' unless player
+        raise ArgumentError, 'team is required' unless team
+        raise UnregisteredTeamError, "#{team} is not registered" unless registered?(team)
+        raise PlayerAlreadySignedError, "#{player} is already signed" if signed?(player)
+
+        team.sign!(player)
+
+        self
+      end
+
+      def signed?(player)
+        players.include?(player)
+      end
+
+      def players
+        teams.flat_map(&:players)
+      end
+
+      def not_registered?(team)
+        !registered?(team)
+      end
+
+      def registered?(team)
+        teams.include?(team)
+      end
+
+      def register!(team)
+        raise ArgumentError, 'team is required' unless team
+        raise TeamAlreadyRegisteredError, "#{team} already registered" if registered?(team)
+
+        team.players.each do |player|
+          raise PlayerAlreadySignedError, "#{player} already signed" if signed?(player)
+        end
+
+        teams << team
+
+        self
+      end
+
+      def ==(other)
+        teams == other.teams
+      end
+      alias eql? ==
+    end
+  end
+end