basketball 0.0.8 → 0.0.10

data/lib/basketball/draft/room.rb

@@ -1,142 +1,148 @@
 # frozen_string_literal: true
 
-require_relative 'league'
-
 module Basketball
   module Draft
-    class Room
+    # Main pick-by-pick iterator object which will round-robin rotate team selections.
+    class Room < Entity
       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
+      class UnknownPlayerError < StandardError; end
 
-      private_constant :DEFAULT_ROUNDS
+      attr_reader :rounds, :players, :front_offices, :events
 
-      attr_reader :events, :rounds
+      def initialize(front_offices:, rounds:, players: [], events: [])
+        super()
 
-      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
+        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)
 
-          undrafted_players.each do |player|
-            league.register!(player:)
+            league.register!(team)
+
+            drafted_players(front_office).each do |player|
+              league.sign!(player:, team:)
+            end
           end
         end
       end
 
-      def to_s
-        events.join("\n")
-      end
+      ### Peek Methods
 
-      def front_offices
-        front_offices_by_id.values
-      end
-
-      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 +152,70 @@ 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
-        )
+        event = Pick.new(front_office:, pick:, round:, round_pick:, player:)
 
-        play!(event)
+        add_event!(event)
       end
 
-      def undrafted_players
-        players - drafted_players
-      end
+      private
 
-      def undrafted_player_search
-        PlayerSearch.new(undrafted_players)
+      def player_events
+        events.select { |e| e.respond_to?(:player) }
       end
 
-      private
+      # 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
 
-      attr_reader :players_by_id, :front_offices_by_id
+        assert_player(event)
 
-      def player_events
-        events.select { |e| e.respond_to?(:player) }
+        events << event
+
+        event
       end
+      # rubocop:enable Metrics/AbcSize
 
-      def internal_current_pick
-        events.length + 1
+      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 drafted_players(front_office = nil)
-        player_events.each_with_object([]) do |e, memo|
-          next unless front_office.nil? || e.front_office == front_office
+      def internal_pick
+        events.length + 1
+      end
 
-          memo << e.player
-        end
+      def registered?(front_office)
+        front_offices.include?(front_office)
       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 register!(front_office)
+        raise ArgumentError, 'front_office required' unless front_office
+        raise FrontOfficeAlreadyRegisteredError, "#{front_office} already registered" if registered?(front_office)
 
-        if event.respond_to?(:player) && !players.include?(event.player)
-          raise UnknownPlayerError, "#{event.player} doesnt exist"
-        end
+        front_offices << front_office
 
-        if event.front_office != current_front_office
-          raise EventOutOfOrder, "#{event} #{event.front_office} cant pick right now"
-        end
+        self
+      end
 
-        raise UnknownFrontOfficeError, "#{front_office} doesnt exist" unless front_offices.include?(event.front_office)
+      def player?(player)
+        players.include?(player)
+      end
 
-        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
+      def add_player!(player)
+        raise ArgumentError, 'player required' unless player
+        raise PlayerAlreadyAddedError, "#{player} already added" if player?(player)
 
-        events << event
+        players << player
 
-        event
+        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,31 +1,40 @@
 # 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
 
     attr_reader :id
 
-    def_delegators :id, :to_s
-
-    def initialize(id)
-      raise ArgumentError, 'id is required' if id.to_s.empty?
-
-      @id = id.to_s.upcase
+    def initialize(id = nil)
+      @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 to_s
+      id.to_s
     end
+
+    def comparable_id
+      id.to_s.upcase
+    end
+
+    private
+
+    attr_writer :id
   end
 end

data/lib/basketball/org/league.rb

@@ -0,0 +1,68 @@
+# 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 < Entity
+      class TeamAlreadyRegisteredError < StandardError; end
+      class UnregisteredTeamError < StandardError; end
+
+      attr_reader :teams
+
+      def initialize(teams: [])
+        super()
+
+        @teams = []
+
+        teams.each { |team| register!(team) }
+      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
+    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/{draft → org}/position.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Basketball
-  module Draft
+  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