basketball 0.0.7 → 0.0.9

data/lib/basketball/draft/front_office.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Draft
+    # A team will send their front office to a draft room to make draft selections.
+    class FrontOffice < Entity
+      # 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 :DEFAULT_MAX_STAR_LEVEL, :DEFAULT_MAX_RISK_LEVEL, :MAX_POSITIONS
+
+      attr_reader :prioritized_positions, :risk_level, :star_level, :scout
+
+      def initialize(
+        id:,
+        prioritized_positions: [],
+        risk_level: rand(0..DEFAULT_MAX_RISK_LEVEL),
+        star_level: rand(0..DEFAULT_MAX_STAR_LEVEL)
+      )
+        super(id)
+
+        @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
+
+        @prioritized_positions += random_positions_queue[0...need_count]
+
+        freeze
+      end
+
+      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[0..risk_level].sample
+      end
+
+      private
+
+      def adaptive_search(assessment)
+        drafted_positions = assessment.drafted_players.map(&:position)
+
+        scout.top_for(players: assessment.undrafted_players, exclude_positions: drafted_positions)
+      end
+
+      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(assessment.drafted_players).each do |position|
+          players = scout.top_for(players: assessment.undrafted_players, position:)
+
+          break if players.any?
+        end
+
+        players = players.any? ? players : scout.top_for
+      end
+
+      def all_random_positions
+        Org::Position::ALL_VALUES.to_a.shuffle.map { |v| Org::Position.new(v) }
+      end
+
+      def random_positions_queue
+        all_random_positions + all_random_positions + [Org::Position.random] + [Org::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/draft/pick.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Draft
+    # Room event where a player is selected.
+    class Pick < Event
+      value_reader :player, :auto
+
+      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
+        "#{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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Draft
+    # Main pick-by-pick iterator object which will round-robin rotate team selections.
+    class Room
+      class AlreadyPickedError < StandardError; end
+      class EndOfDraftError < StandardError; end
+      class EventOutOfOrderError < StandardError; end
+      class FrontOfficeAlreadyRegisteredError < StandardError; end
+      class PlayerAlreadyAddedError < StandardError; end
+      class UnknownFrontOfficeError < StandardError; end
+      class UnknownPlayerError < StandardError; end
+
+      attr_reader :rounds, :players, :front_offices, :events, :id
+
+      def initialize(front_offices:, rounds:, players: [], events: [])
+        raise InvalidRoundsError, "#{rounds} should be a positive number" unless rounds.positive?
+
+        @rounds        = rounds
+        @players       = []
+        @front_offices = []
+        @events        = []
+
+        front_offices.each { |front_office| register!(front_office) }
+        players.each       { |player| add_player!(player) }
+        events.each        { |event| add_event!(event) }
+      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)
+
+            drafted_players(front_office).each do |player|
+              league.sign!(player:, team:)
+            end
+          end
+        end
+      end
+
+      ### Peek Methods
+
+      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 round
+        return if done?
+
+        (pick / front_offices.length.to_f).ceil
+      end
+
+      def round_pick
+        return if done?
+
+        mod = pick % front_offices.length
+
+        mod.positive? ? mod : front_offices.length
+      end
+
+      def front_office
+        return if done?
+
+        front_offices[round_pick - 1]
+      end
+
+      def pick
+        return if done?
+
+        internal_pick
+      end
+
+      def remaining_picks
+        total_picks - internal_pick + 1
+      end
+
+      def done?
+        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 = Skip.new(front_office:, pick:, round:, round_pick:)
+
+        add_event!(event)
+
+        event
+      end
+
+      def sim!
+        return if done?
+
+        player = front_office.pick(assessment)
+        event  = Pick.new(front_office:, pick:, round:, round_pick:, player:, auto: true)
+
+        add_event!(event)
+
+        event
+      end
+
+      def sim_rest!
+        events = []
+
+        while not_done?
+          event = sim!
+
+          yield event if block_given?
+
+          events << event
+        end
+
+        events
+      end
+
+      def pick!(player)
+        return nil if done?
+
+        event = Pick.new(front_office:, pick:, round:, round_pick:, player:)
+
+        add_event!(event)
+      end
+
+      private
+
+      attr_writer :id
+
+      def player_events
+        events.select { |e| e.respond_to?(:player) }
+      end
+
+      # 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 assert_player(event)
+        return unless event.respond_to?(:player)
+
+        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
+
+      def internal_pick
+        events.length + 1
+      end
+
+      def registered?(front_office)
+        front_offices.include?(front_office)
+      end
+
+      def register!(front_office)
+        raise ArgumentError, 'front_office required' unless front_office
+        raise FrontOfficeAlreadyRegisteredError, "#{front_office} already registered" if registered?(front_office)
+
+        front_offices << front_office
+
+        self
+      end
+
+      def player?(player)
+        players.include?(player)
+      end
+
+      def add_player!(player)
+        raise ArgumentError, 'player required' unless player
+        raise PlayerAlreadyAddedError, "#{player} already added" if player?(player)
+
+        players << player
+
+        self
+      end
+    end
+  end
+end

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

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
 module Basketball
-  module Drafting
-    class PlayerSearch
-      attr_reader :players
-
-      def initialize(players = [])
-        @players = players
-      end
-
-      def query(position: nil, exclude_positions: [])
+  module Draft
+    # 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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Services
+require_relative 'draft/scout'
+
+# 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

data/lib/basketball/org/player.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Base class describing a player.
+    # A consumer application should extend these specific to their specific sports traits.
+    class Player < Entity
+      attr_reader :overall, :position
+
+      def initialize(id:, overall: 0, position: nil)
+        super(id)
+
+        raise ArgumentError, 'position is required' unless position
+
+        @overall  = overall
+        @position = position
+
+        freeze
+      end
+
+      def to_s
+        "[#{super}] (#{position}) #{overall}".strip
+      end
+    end
+  end
+end

data/lib/basketball/{drafting → org}/position.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Basketball
-  module Drafting
+  module Org
+    # Describes a player position.
     class Position < ValueObject
       extend Forwardable
 
@@ -17,7 +18,7 @@ module Basketball
       FRONT_COURT_VALUES = %w[PF C].to_set.freeze
       ALL_VALUES         = (BACK_COURT_VALUES.to_a + FRONT_COURT_VALUES.to_a).to_set.freeze
 
-      attr_reader_value :code
+      value_reader :code
 
       def_delegators :code, :to_s
 

data/lib/basketball/org/team.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Base class describing a team.  A team here is bare metal and is just described by an ID
+    # and a collection of Player objects.
+    class Team < Entity
+      attr_reader :players
+
+      def initialize(id:, players: [])
+        super(id)
+
+        @players = []
+
+        players.each { |p| sign!(p) }
+
+        freeze
+      end
+
+      def to_s
+        ([super.to_s] + players.map(&:to_s)).join("\n")
+      end
+
+      def signed?(player)
+        players.include?(player)
+      end
+
+      def sign!(player)
+        raise ArgumentError, 'player is required' unless player
+        raise PlayerAlreadySignedError, "#{player} already signed by #{self}" if signed?(player)
+
+        players << player
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/org.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'org/player'
+require_relative 'org/position'
+require_relative 'org/team'
+require_relative 'org/league'
+
+module Basketball
+  module Org
+    class PlayerAlreadySignedError < StandardError; end
+  end
+end