basketball 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29805ef216312c25dee77d7f7c2a82bf220287404e9e241d24e16dddfb895fcc
-  data.tar.gz: 3d8a0038acf62e4e1aa230299cc1b2d7d777596bc133b159b1e661639c75c76d
+  metadata.gz: 793bfe7afef52aa72d3f89c94541fc7d8f24b350d63cb7c75d7215c285695b74
+  data.tar.gz: 46a3ac7199fb534ff4827c8fe48bbe371c7f87bc623e579ffdce2310132a1263
 SHA512:
-  metadata.gz: ae3baac2215dbfee6b9cf70a44b2bdf9257d7dade811c6a30bf37b22f840bd85621f6441d137e07f38b615210092d0cede011a2e9f4655aa1e05c6281411a856
-  data.tar.gz: 4bcb67de94178f2945376faa2cb57c5f5884d60b24479d73e12d1145c7c20c1b9f3dd547f321c578f39d43868fb2f8d158859020b14d7e436fbface8a89b2809
+  metadata.gz: cf8c46719f3669a31c932d7dc2742c287666fcb305c90c596c87b79c37d4fb95aafa446c70575ed4d8d3750a3f3672646e9ee49c6a0cf95e4dd7eb092831670e
+  data.tar.gz: db01d3bfc4a8c1448875c5a099d0a33fd60ad60471ae5cda5f9eeeaf8a1fb2daa3e52d5ca2d8138867e42aaf6f54d259cdad7d3628cfbaa2d7bcf134fe5dc4b9

data/CHANGELOG.md

@@ -1,7 +1,16 @@
+#### 0.0.5 - May 5th, 2023
+
+* Remove the notion of Team in favor of a flat front office.
+#### 0.0.4 - May 5th, 2023
+
+* Add ability to skip draft picks using `Basketball::Drafting::Engine#skip!`
+* Add ability to output event full drafting event log using CLI: `basketball-draft -i tmp/draft-wip.json -l`
+* Add ability to skip draft picks using CLI: `basketball-draft -i tmp/draft-wip.json -x 1`
+
 #### 0.0.3 - May 5th, 2023
 
-* Drafting::Engine#sim! should return events
-* Added Drafting::Engine#undrafted_player_search
+* `Drafting::Engine#sim!` should return events
+* Added `Drafting::Engine#undrafted_player_search`
 
 #### 0.0.2 - May 4th, 2023
 

data/CODE_OF_CONDUCT.md

@@ -56,7 +56,7 @@ further defined and clarified by project maintainers.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported. All complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
+is deemed necessary and appropriate to the circumstances. The project front_office is
 obligated to maintain confidentiality with regard to the reporter of an incident.
 Further details of specific enforcement policies may be posted separately.
 

data/README.md

@@ -26,7 +26,7 @@ Install executable scripts:
 bundle binstubs basketball
 ````
 
-## Main Modules
+## Sub-Modules
 
 This library is broken down into several bounded contexts that can be consumed either via its Ruby API's or CLI through provided executable scripts:
 
@@ -38,6 +38,21 @@ The drafting module is responsible for providing a turn-based iterator allowing
 
 ![Basketball Architecture - Drafting.png](/docs/architecture/drafting.png)
 
+Element      | Description
+:------------ | :-----------
+**Drafting** | Bounded context (sub-module) dealing with executing an asynchronous draft.
+**Engine** | Aggregate root responsible for providing an iterable interface capable of executing a draft, pick by pick.
+**Event** | Represents one cycle execution result from the Engine.
+**External Ruby App** | An example consumer for the Drafting context.
+**Front Office** | Identifiable as a team, contains configuration for how to auto-pick draft selections.
+**League** | Set of rosters that together form a cohesive league.
+**Pick Event** | Result event emitted when a player is manually selected.
+**Playe ** | Identitiable as a person able to be drafted.
+**Position** | Value object based on position code: PG, SG, SF, PF, and C.
+**Roster** | Identifiable as a team, set of players that make up a single team.
+**Sim Event** | Result event emitted when a player is automatically selected by a front office.
+**Skip Event** | Result event emitted when a front office decides to skip a round.
+
 ### The Drafting CLI
 
 The drafting module is meant to be interfaces using its Ruby API by consuming applications.  It also ships with a CLI which a user can interact with to emulate "the draft process".  Technically speaking, the CLI provides an example application built on top of the Drafting module.  Each time a CLI command is executed, its results will be resaved, so the output file can then be used as the next command's input file to string together commands.  The following sections are example CLI interactions:
@@ -45,43 +60,55 @@ The drafting module is meant to be interfaces using its Ruby API by consuming ap
 #### Generate a Fresh Draft
 
 ```zsh
-exe/basketball-draft -o tmp/draft.json
+basketball-draft -o tmp/draft.json
 ```
 
 #### N Top Available Players
 
 ```zsh
-exe/basketball-draft -i tmp/draft.json -t 10
+basketball-draft -i tmp/draft.json -t 10
 ```
 
 #### N Top Available Players for a Position
 
 ```zsh
-exe/basketball-draft -i tmp/draft.json -t 10 -q PG
+basketball-draft -i tmp/draft.json -t 10 -q PG
 ```
 
 #### Output Current Rosters
 
 ```zsh
-exe/basketball-draft -i tmp/draft.json -r
+basketball-draft -i tmp/draft.json -r
+```
+
+#### Output Event Log
+
+```zsh
+basketball-draft -i tmp/draft.json -l
 ```
 
 #### Simulate N picks
 
 ```zsh
-exe/basketball-draft -i tmp/draft.json -s 10
+basketball-draft -i tmp/draft.json -s 10
+```
+
+#### Skip N picks
+
+```zsh
+basketball-draft -i tmp/draft.json -x 10
 ```
 
 #### Pick Players
 
 ```zsh
-exe/basketball-draft -i tmp/draft.json -p P-100,P-200,P-300
+basketball-draft -i tmp/draft.json -p P-100,P-200,P-300
 ```
 
 #### Simulate the Rest of the Draft
 
 ```zsh
-exe/basketball-draft -i tmp/draft.json -a
+basketball-draft -i tmp/draft.json -a
 ```
 
 ## Contributing

data/lib/basketball/drafting/cli.rb

@@ -9,12 +9,16 @@ module Basketball
   module Drafting
     # Example:
     #   exe/basketball-draft -o tmp/draft.json
-    #   exe/basketball-draft -i tmp/draft.json -o tmp/draft-wip.json -s 28 -p ONEALSH01,ONEALJE01 -t 10 -q PG
+    #   exe/basketball-draft -i tmp/draft.json -o tmp/draft-wip.json -s 26 -p P-5,P-10 -t 10 -q PG
+    #   exe/basketball-draft -i tmp/draft-wip.json -x 2
     #   exe/basketball-draft -i tmp/draft-wip.json -r -t 10
     #   exe/basketball-draft -i tmp/draft-wip.json -t 10 -q SG
     #   exe/basketball-draft -i tmp/draft-wip.json -s 30 -t 10
     #   exe/basketball-draft -i tmp/draft-wip.json -a -r
+    #   exe/basketball-draft -i tmp/draft-wip.json -l
     class CLI
+      class PlayerNotFound < StandardError; end
+
       attr_reader :opts, :serializer, :io
 
       def initialize(args:, io: $stdout)
@@ -42,13 +46,19 @@ module Basketball
         if engine.done?
           io.puts('Draft is complete!')
         else
+          current_round        = engine.current_round
+          current_round_pick   = engine.current_round_pick
+          current_front_office = engine.current_front_office
+
           io.puts("#{engine.remaining_picks} Remaining pick(s)")
-          io.puts("Round #{engine.current_round} pick #{engine.current_round_pick} for #{engine.current_team}")
+          io.puts("Up Next: Round #{current_round} pick #{current_round_pick} for #{current_front_office}")
         end
 
         write(engine)
 
-        rosters(engine)
+        log(engine)
+
+        league(engine)
 
         query(engine)
 
@@ -69,7 +79,9 @@ module Basketball
           o.array   '-p', '--picks',        'Comma-separated list of ordered player IDs to pick.', delimiter: ','
           o.integer '-t', '--top',          'Output the top rated available players (default is 0).', default: 0
           o.string  '-q', '--query',        "Filter TOP by position: #{Position::ALL_VALUES.join(', ')}."
-          o.bool    '-r', '--rosters',      'Output all team rosters.', default: false
+          o.bool    '-r', '--rosters',      'Output all front_office rosters.', default: false
+          o.integer '-x', '--skip',         'Number of picks to skip (default is 0).', default: 0
+          o.bool    '-l', '--log',          'Output event log.', default: false
 
           o.on '-h', '--help', 'Print out help, like this is doing right now.' do
             io.puts(o)
@@ -80,7 +92,7 @@ module Basketball
 
       def load_engine
         if opts[:input].to_s.empty?
-          io.puts('Input path was not provided, generating fresh teams and players')
+          io.puts('Input path was not provided, generating fresh front_offices and players')
 
           generate_draft
         else
@@ -91,8 +103,8 @@ module Basketball
       end
 
       def generate_draft
-        teams = 30.times.map do |i|
-          Team.new(
+        front_offices = 30.times.map do |i|
+          FrontOffice.new(
             id: "T-#{i + 1}", name: Faker::Team.name
           )
         end
@@ -107,18 +119,23 @@ module Basketball
           )
         end
 
-        Engine.new(players:, teams:)
+        Engine.new(players:, front_offices:)
       end
 
-      def rosters(engine)
+      def league(engine)
         return unless opts[:rosters]
 
         io.puts
-        io.puts('Rosters')
+        io.puts(engine.to_league)
+      end
+
+      def log(engine)
+        return unless opts[:log]
+
+        io.puts
+        io.puts('Event Log')
 
-        engine.rosters.each do |roster|
-          io.puts(roster)
-        end
+        puts engine.events
       end
 
       # rubocop:disable Metrics/AbcSize
@@ -161,6 +178,8 @@ module Basketball
 
           player = engine.players.find { |p| p.id == id.to_s.upcase }
 
+          raise PlayerNotFound, "player not found by id: #{id}" unless player
+
           event = engine.pick!(player)
 
           io.puts(event)
@@ -168,6 +187,14 @@ module Basketball
           event_count += 1
         end
 
+        opts[:skip].times do
+          event = engine.skip!
+
+          io.puts(event)
+
+          event_count += 1
+        end
+
         engine.sim!(opts[:simulate]) do |event|
           io.puts(event)
 

data/lib/basketball/drafting/engine.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'roster'
+require_relative 'league'
 
 module Basketball
   module Drafting
@@ -9,7 +9,7 @@ module Basketball
       class DupeEventError < StandardError; end
       class EventOutOfOrderError < StandardError; end
       class UnknownPlayerError < StandardError; end
-      class UnknownTeamError < StandardError; end
+      class UnknownFrontOfficeError < StandardError; end
       class EndOfDraftError < StandardError; end
 
       DEFAULT_ROUNDS = 12
@@ -18,11 +18,11 @@ module Basketball
 
       attr_reader :events, :rounds
 
-      def initialize(players: [], teams: [], events: [], rounds: DEFAULT_ROUNDS)
-        @players_by_id = players.to_h { |p| [p.id, p] }
-        @teams_by_id   = teams.to_h { |t| [t.id, t] }
-        @events        = []
-        @rounds        = rounds.to_i
+      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
 
         # Each one will be validated for correctness.
         events.each { |e| play!(e) }
@@ -30,15 +30,15 @@ module Basketball
         freeze
       end
 
-      def rosters
-        events_by_team = teams.to_h { |t| [t, []] }
+      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
 
-        events.each do |event|
-          events_by_team.fetch(event.team) << event
-        end
-
-        events_by_team.map do |team, events|
-          Roster.new(team:, events:)
+          undrafted_players.each do |player|
+            league.register!(player:)
+          end
         end
       end
 
@@ -46,8 +46,8 @@ module Basketball
         events.join("\n")
       end
 
-      def teams
-        teams_by_id.values
+      def front_offices
+        front_offices_by_id.values
       end
 
       def players
@@ -55,27 +55,27 @@ module Basketball
       end
 
       def total_picks
-        rounds * teams.length
+        rounds * front_offices.length
       end
 
       def current_round
         return if done?
 
-        (current_pick / teams.length.to_f).ceil
+        (current_pick / front_offices.length.to_f).ceil
       end
 
       def current_round_pick
         return if done?
 
-        mod = current_pick % teams.length
+        mod = current_pick % front_offices.length
 
-        mod.positive? ? mod : teams.length
+        mod.positive? ? mod : front_offices.length
       end
 
-      def current_team
+      def current_front_office
         return if done?
 
-        teams[current_round_pick - 1]
+        front_offices[current_round_pick - 1]
       end
 
       def current_pick
@@ -96,22 +96,38 @@ module Basketball
         !done?
       end
 
+      def skip!
+        return if done?
+
+        event = SkipEvent.new(
+          id: SecureRandom.uuid,
+          front_office: current_front_office,
+          pick: current_pick,
+          round: current_round,
+          round_pick: current_round_pick
+        )
+
+        play!(event)
+
+        event
+      end
+
       def sim!(times = nil)
         counter = 0
         events  = []
 
         until done? || (times && counter >= times)
-          team = current_team
+          front_office = current_front_office
 
-          player = team.pick(
+          player = front_office.pick(
             undrafted_player_search:,
-            drafted_players: drafted_players(team),
+            drafted_players: drafted_players(front_office),
             round: current_round
           )
 
           event = SimEvent.new(
             id: SecureRandom.uuid,
-            team:,
+            front_office:,
             player:,
             pick: current_pick,
             round: current_round,
@@ -134,7 +150,7 @@ module Basketball
 
         event = PickEvent.new(
           id: SecureRandom.uuid,
-          team: current_team,
+          front_office: current_front_office,
           player:,
           pick: current_pick,
           round: current_round,
@@ -154,15 +170,19 @@ module Basketball
 
       private
 
-      attr_reader :players_by_id, :teams_by_id
+      attr_reader :players_by_id, :front_offices_by_id
+
+      def player_events
+        events.select { |e| e.respond_to?(:player) }
+      end
 
       def internal_current_pick
         events.length + 1
       end
 
-      def drafted_players(team = nil)
-        events.each_with_object([]) do |e, memo|
-          next unless team.nil? || e.team == team
+      def drafted_players(front_office = nil)
+        player_events.each_with_object([]) do |e, memo|
+          next unless front_office.nil? || e.front_office == front_office
 
           memo << e.player
         end
@@ -172,15 +192,25 @@ module Basketball
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity
       def play!(event)
-        raise AlreadyPickedError, "#{player} was already picked" if drafted_players.include?(event.player)
-        raise DupeEventError,     "#{event} is a dupe"                if events.include?(event)
-        raise EventOutOfOrder,    "#{event} team cant pick right now" if event.team != current_team
-        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 UnknownTeamError,   "#{team} doesnt exist"                   unless teams.include?(event.team)
-        raise UnknownPlayerError, "#{player} doesnt exist"                 unless players.include?(event.player)
-        raise EndOfDraftError,    "#{total_picks} pick limit reached"      if events.length > total_picks + 1
+        if event.respond_to?(:player) && drafted_players.include?(event.player)
+          raise AlreadyPickedError, "#{player} was already picked"
+        end
+
+        if event.respond_to?(:player) && !players.include?(event.player)
+          raise UnknownPlayerError, "#{event.player} doesnt exist"
+        end
+
+        if event.front_office != current_front_office
+          raise EventOutOfOrder, "#{event} #{event.front_office} cant pick right now"
+        end
+
+        raise UnknownFrontOfficeError, "#{front_office} doesnt exist" unless front_offices.include?(event.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
 
         events << event
 

data/lib/basketball/drafting/engine_serializer.rb

@@ -2,29 +2,30 @@
 
 require_relative 'front_office'
 require_relative 'player'
-require_relative 'team'
 require_relative 'pick_event'
 require_relative 'sim_event'
+require_relative 'skip_event'
 
 module Basketball
   module Drafting
     class EngineSerializer
       EVENT_CLASSES = {
         'PickEvent' => PickEvent,
-        'SimEvent' => SimEvent
+        'SimEvent' => SimEvent,
+        'SkipEvent' => SkipEvent
       }.freeze
 
       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:
         }
 
@@ -37,7 +38,7 @@ module Basketball
         {
           info: serialize_info(engine),
           engine: serialize_engine(engine),
-          rosters: serialize_rosters(engine)
+          league: serialize_league(engine)
         }.to_json
       end
 
@@ -46,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)
         }
@@ -57,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.events.map { |event| event.player.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
@@ -112,39 +116,31 @@ module Basketball
           {
             type: event.class.name.split('::').last,
             id: event.id,
-            player: event.player.id,
-            team: event.team.id,
+            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_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
 
@@ -159,15 +155,18 @@ 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(
-            player: players.find { |p| p.id == event_hash[:player] },
-            team: teams.find { |t| t.id == event_hash[:team] }
+            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

data/lib/basketball/drafting/event.rb

@@ -3,21 +3,21 @@
 module Basketball
   module Drafting
     class Event < Entity
-      attr_reader :pick, :round, :round_pick, :team
+      attr_reader :pick, :round, :round_pick, :front_office
 
-      def initialize(id:, team:, pick:, round:, round_pick:)
+      def initialize(id:, front_office:, pick:, round:, round_pick:)
         super(id)
 
-        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,71 @@
+# frozen_string_literal: true
+
+require_relative 'roster'
+
+module Basketball
+  module Drafting
+    class League
+      class PlayerAlreadyRegisteredError < StandardError; end
+      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

@@ -7,8 +7,8 @@ module Basketball
     class PickEvent < Event
       attr_reader :player
 
-      def initialize(id:, team:, player:, pick:, round:, round_pick:)
-        super(id:, team:, pick:, round:, round_pick:)
+      def initialize(id:, front_office:, player:, pick:, round:, round_pick:)
+        super(id:, front_office:, pick:, round:, round_pick:)
 
         raise ArgumentError, 'player required' unless player
 

data/lib/basketball/drafting/roster.rb

@@ -2,37 +2,36 @@
 
 module Basketball
   module Drafting
-    class Roster < ValueObject
-      extend Forwardable
+    class Roster < Entity
+      class PlayerAlreadyRegisteredError < StandardError; end
+      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
+        freeze
+      end
 
-        other_teams_pick_event_ids = events.reject { |e| e.team == team }.map(&:id)
+      def registered?(player)
+        players.include?(player)
+      end
 
-        if other_teams_pick_event_ids.any?
-          raise WrongTeamEventError,
-                "Event(s): #{other_teams_pick_event_ids.join(',')} has wrong team"
-        end
+      def sign!(player)
+        raise PlayerRequiredError, 'player is required' unless player
+        raise PlayerAlreadyRegisteredError, "#{player} already registered for #{id}" if registered?(player)
 
-        @team   = team
-        @events = events
-      end
+        players << player
 
-      def players
-        events.map(&: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

@@ -5,8 +5,8 @@ module Basketball
     class SimEvent < Event
       attr_reader :player
 
-      def initialize(id:, team:, player:, pick:, round:, round_pick:)
-        super(id:, team:, pick:, round:, round_pick:)
+      def initialize(id:, front_office:, player:, pick:, round:, round_pick:)
+        super(id:, front_office:, pick:, round:, round_pick:)
 
         raise ArgumentError, 'player required' unless player
 

data/lib/basketball/drafting/skip_event.rb

@@ -0,0 +1,13 @@
+# 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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Basketball
-  VERSION = '0.0.3'
+  VERSION = '0.0.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: basketball
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-05 00:00:00.000000000 Z
+date: 2023-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faker
@@ -209,13 +209,14 @@ files:
 - lib/basketball/drafting/engine_serializer.rb
 - lib/basketball/drafting/event.rb
 - lib/basketball/drafting/front_office.rb
+- lib/basketball/drafting/league.rb
 - lib/basketball/drafting/pick_event.rb
 - lib/basketball/drafting/player.rb
 - lib/basketball/drafting/player_search.rb
 - lib/basketball/drafting/position.rb
 - lib/basketball/drafting/roster.rb
 - lib/basketball/drafting/sim_event.rb
-- lib/basketball/drafting/team.rb
+- lib/basketball/drafting/skip_event.rb
 - lib/basketball/entity.rb
 - lib/basketball/value_object.rb
 - lib/basketball/version.rb

data/lib/basketball/drafting/team.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Drafting
-    class Team < Entity
-      extend Forwardable
-
-      attr_reader :name, :front_office
-
-      def_delegators :front_office, :pick
-
-      def initialize(id:, name: '', front_office: FrontOffice.new)
-        super(id)
-
-        raise ArgumentError, 'front_office is required' unless front_office
-
-        @name         = name.to_s
-        @front_office = front_office
-
-        freeze
-      end
-
-      def to_s
-        "[#{super}] #{name}"
-      end
-    end
-  end
-end