basketball 0.0.10 → 0.0.11

data/lib/basketball/app/room_cli.rb

@@ -3,32 +3,27 @@
 module Basketball
   module App
     # Examples:
-    #   exe/basketball-room -o tmp/draft.json
-    #   exe/basketball-room -i tmp/draft.json -o tmp/draft-wip.json -s 26 -p P-5,P-10 -t 10
-    #   exe/basketball-room -i tmp/draft-wip.json -x 2
-    #   exe/basketball-room -i tmp/draft-wip.json -g -t 10
-    #   exe/basketball-room -i tmp/draft-wip.json -s 30 -t 10
-    #   exe/basketball-room -i tmp/draft-wip.json -ale
-    #
-    #   exe/basketball-room -o tmp/draft-wip.json -ale -r tmp/draft-league.json
+    #   exe/basketball-draft-room -o tmp/draft.json
+    #   exe/basketball-draft-room -i tmp/draft.json -o tmp/draft-wip.json -s 26 -p P-5,P-10 -l 10
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -x 2
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -g -l 10
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -s 30 -l 10
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -ate
     class RoomCLI
       class PlayerNotFound < StandardError; end
 
       attr_reader :opts,
                   :io,
-                  :room_repository,
-                  :league_repository
+                  :room_repository
 
       def initialize(
         args:,
         io: $stdout,
-        room_repository: RoomRepository.new(FileStore.new),
-        league_repository: LeagueRepository.new(FileStore.new)
+        room_repository: RoomRepository.new(FileStore.new)
       )
         @io                = io
         @opts              = slop_parse(args)
         @room_repository   = room_repository
-        @league_repository = league_repository
 
         if opts[:input].to_s.empty? && opts[:output].to_s.empty?
           io.puts('Input and/or output paths are required.')
@@ -46,21 +41,14 @@ module Basketball
         status(room)
         write(room)
         events(room)
-        league(room)
+        teams(room)
         query(room)
-        rosters(room)
 
         self
       end
 
       private
 
-      def rosters(room)
-        return if opts[:rosters].to_s.empty?
-
-        league_repository.save(opts[:rosters], room.league)
-      end
-
       def status(room)
         io.puts
         io.puts('Status')
@@ -79,18 +67,17 @@ module Basketball
 
       def slop_parse(args)
         Slop.parse(args) do |o|
-          o.banner = 'Usage: basketball-room [options] ...'
+          o.banner = 'Usage: basketball-draft-room [options] ...'
 
           o.string  '-i', '--input',        'Path to load the Room from. If omitted then a new draft will be generated.'
           o.string  '-o', '--output',       'Path to write the room to (if omitted then input path will be used)'
           o.integer '-s', '--simulate',     'Number of picks to simulate (default is 0).', default: 0
           o.bool    '-a', '--simulate-all', 'Simulate the rest of the draft', default: false
           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.bool    '-l', '--league',       'Output all teams and their picks', default: false
+          o.integer '-l', '--list',         'List the top rated available players (default is 0).', default: 0
+          o.bool    '-t', '--teams',        'Output all teams and their picks', default: false
           o.integer '-x', '--skip',         'Number of picks to skip (default is 0).', default: 0
           o.bool    '-e', '--events',       'Output event log.', default: false
-          o.string  '-r', '--rosters',      'Path to write the resulting rosters (league) to.'
 
           o.on '-h', '--help', 'Print out help, like this is doing right now.' do
             io.puts(o)
@@ -129,11 +116,11 @@ module Basketball
         Draft::Room.new(rounds: 12, players:, front_offices:)
       end
 
-      def league(room)
-        return unless opts[:league]
+      def teams(room)
+        return unless opts[:teams]
 
         io.puts
-        io.puts(room.league)
+        io.puts(room.teams)
       end
 
       def events(room)
@@ -146,14 +133,14 @@ module Basketball
       end
 
       def query(room)
-        top = opts[:top]
+        list = opts[:list]
 
-        return if top <= 0
+        return if list <= 0
 
-        players = room.undrafted_players.sort_by(&:overall).reverse.take(opts[:top])
+        players = room.undrafted_players.sort_by(&:overall).reverse.take(opts[:list])
 
         io.puts
-        io.puts("Top #{top} available players")
+        io.puts("Top #{list} available players")
         io.puts(players)
       end
 

data/lib/basketball/draft/pick.rb

@@ -20,13 +20,6 @@ module Basketball
       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

@@ -30,17 +30,15 @@ module Basketball
       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)
+      def teams
+        front_offices.each_with_object([]) do |front_office, memo|
+          team = Org::Team.new(id: front_office.id)
 
-            league.register!(team)
-
-            drafted_players(front_office).each do |player|
-              league.sign!(player:, team:)
-            end
+          drafted_players(front_office).each do |player|
+            team.sign!(player)
           end
+
+          memo << team
         end
       end
 

data/lib/basketball/org/conference.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # A collection of divisions, teams, and players.
+    class Conference < Entity
+      include HasDivisions
+
+      attr_reader :divisions
+
+      def initialize(id:, divisions: [])
+        super(id)
+
+        @divisions = []
+
+        divisions.each { |d| register_division!(d) }
+
+        freeze
+      end
+
+      def to_s
+        ([super] + divisions.map(&:to_s)).join("\n")
+      end
+
+      def teams
+        divisions.flat_map(&:teams)
+      end
+
+      def players
+        divisions.flat_map(&:players)
+      end
+
+      private
+
+      def register_division!(division)
+        raise ArgumentError, 'division is required' unless division
+        raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
+
+        assert_teams_are_not_already_registered(division.teams)
+
+        divisions << division
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/org/division.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # A collection of teams and players.
+    class Division < Entity
+      include HasTeams
+
+      attr_reader :teams
+
+      def initialize(id:, teams: [])
+        super(id)
+
+        @teams = []
+
+        teams.each { |t| register_team!(t) }
+
+        freeze
+      end
+
+      def to_s
+        ([super] + teams.map(&:to_s)).join("\n")
+      end
+
+      def players
+        teams.flat_map(&:players)
+      end
+
+      private
+
+      def register_team!(team)
+        raise ArgumentError, 'team is required' unless team
+        raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
+
+        assert_players_are_not_already_signed(team.players)
+
+        teams << team
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/org/has_divisions.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Helper methods for objects that can be composed of divisions which are also composed of teams
+    # and players.
+    module HasDivisions
+      include HasTeams
+
+      def division?(division)
+        divisions.include?(division)
+      end
+
+      private
+
+      def assert_divisions_are_not_already_registered(divisions)
+        divisions.each do |division|
+          raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
+
+          assert_teams_are_not_already_registered(division.teams)
+        end
+      end
+    end
+  end
+end

data/lib/basketball/org/has_players.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Helper methods for objects that can be composed of players.
+    module HasPlayers
+      def player?(player)
+        players.include?(player)
+      end
+
+      private
+
+      def assert_players_are_not_already_signed(players)
+        players.each do |player|
+          raise PlayerAlreadySignedError, "#{player} already registered" if player?(player)
+        end
+      end
+    end
+  end
+end

data/lib/basketball/org/has_teams.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Helper methods for objects that can be composed of teams which are also made up of players.
+    module HasTeams
+      include HasPlayers
+
+      def team?(team)
+        teams.include?(team)
+      end
+
+      private
+
+      def assert_teams_are_not_already_registered(teams)
+        teams.each do |team|
+          raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
+
+          assert_players_are_not_already_signed(team.players)
+        end
+      end
+    end
+  end
+end

data/lib/basketball/org/league.rb

@@ -2,66 +2,98 @@
 
 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:
+    # Describes a collection of conferences, divisions, teams, and players.
+    # Holds the rules which support adding teams and players to ensure the all the
+    # teams are cohesive, such as:
+    #   - preventing duplicate conferences
+    #   - preventing duplicate divisions
     #   - preventing duplicate teams
     #   - preventing double-signing players across teams
     class League < Entity
-      class TeamAlreadyRegisteredError < StandardError; end
-      class UnregisteredTeamError < StandardError; end
+      include HasDivisions
 
-      attr_reader :teams
+      class ConferenceAlreadyRegisteredError < StandardError; end
 
-      def initialize(teams: [])
+      alias signed? player?
+
+      attr_reader :conferences
+
+      def initialize(conferences: [])
         super()
 
-        @teams = []
+        @conferences = []
 
-        teams.each { |team| register!(team) }
+        conferences.each { |c| register!(c) }
       end
 
       def to_s
-        teams.map(&:to_s).join("\n")
+        conferences.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)
+        raise UnregisteredTeamError, "#{team} not registered" unless team?(team)
+        raise PlayerAlreadySignedError, "#{player} already registered" if player?(player)
 
-        team.sign!(player)
+        # It is OK to pass in a detached team as long as its equivalent resides in this
+        # League's object graph.
+        team_for(team.id).sign!(player)
 
         self
       end
 
-      def signed?(player)
-        players.include?(player)
+      def register!(conference)
+        raise ArgumentError, 'conference is required' unless conference
+        raise ConferenceAlreadyRegisteredError, "#{conference} already registered" if conference?(conference)
+
+        assert_divisions_are_not_already_registered(conference.divisions)
+
+        conferences << conference
+
+        self
+      end
+
+      def conference?(conference)
+        conferences.include?(conference)
+      end
+
+      def divisions
+        conferences.flat_map(&:divisions)
+      end
+
+      def teams
+        conferences.flat_map(&:teams)
       end
 
       def players
-        teams.flat_map(&:players)
+        conferences.flat_map(&:players)
       end
 
-      def not_registered?(team)
-        !registered?(team)
+      def conference_for(team)
+        conferences.find { |c| c.divisions.find { |d| d.teams.include?(team) } }
       end
 
-      def registered?(team)
-        teams.include?(team)
+      def division_for(team)
+        conference_for(team)&.divisions&.find { |d| d.teams.include?(team) }
       end
 
-      def register!(team)
-        raise ArgumentError, 'team is required' unless team
-        raise TeamAlreadyRegisteredError, "#{team} already registered" if registered?(team)
+      # Same conference, different division
+      def cross_division_opponents_for(team)
+        conference = conference_for(team)
+        division   = division_for(team)
 
-        team.players.each do |player|
-          raise PlayerAlreadySignedError, "#{player} already signed" if signed?(player)
-        end
+        return nil unless conference && division
 
-        teams << team
+        other_divisions = conference.divisions - [division]
 
-        self
+        other_divisions.flat_map(&:teams)
+      end
+
+      private
+
+      def team_for(id)
+        teams.find { |team| team.id == id }
       end
     end
   end

data/lib/basketball/org.rb

@@ -1,12 +1,23 @@
 # frozen_string_literal: true
 
+# Cross-cutting Concerns
+require_relative 'org/has_players'
+require_relative 'org/has_teams'
+require_relative 'org/has_divisions'
+
+# Domain Models
+require_relative 'org/conference'
+require_relative 'org/division'
+require_relative 'org/league'
 require_relative 'org/player'
 require_relative 'org/position'
 require_relative 'org/team'
-require_relative 'org/league'
 
 module Basketball
   module Org
+    class DivisionAlreadyRegisteredError < StandardError; end
     class PlayerAlreadySignedError < StandardError; end
+    class TeamAlreadyRegisteredError < StandardError; end
+    class UnregisteredTeamError < StandardError; end
   end
 end

data/lib/basketball/season/arena.rb

@@ -12,11 +12,11 @@ module Basketball
       DEFAULT_MAX_HOME_ADVANTAGE = 5
 
       DEFAULT_STRATEGY_FREQUENCIES = {
-        RANDOM => 10,
-        TOP_ONE => 5,
-        TOP_TWO => 10,
-        TOP_THREE => 20,
-        TOP_SIX => 30
+        RANDOM => 3,
+        TOP_ONE => 1,
+        TOP_TWO => 1,
+        TOP_THREE => 1,
+        TOP_SIX => 1
       }.freeze
 
       attr_reader :lotto, :max_home_advantage

data/lib/basketball/season/calendar.rb

@@ -2,35 +2,35 @@
 
 module Basketball
   module Season
-    # Sets boundaries for preseason and regular season play.  Add games as long as they are
+    # Sets boundaries for exhibition and regular season play.  Add games as long as they are
     # within the correct dated boundaries
     class Calendar
       class OutOfBoundsError < StandardError; end
       class TeamAlreadyBookedError < StandardError; end
 
-      attr_reader :preseason_start_date,
-                  :preseason_end_date,
-                  :season_start_date,
-                  :season_end_date,
+      attr_reader :exhibition_start_date,
+                  :exhibition_end_date,
+                  :regular_start_date,
+                  :regular_end_date,
                   :games
 
       def initialize(
-        preseason_start_date:,
-        preseason_end_date:,
-        season_start_date:,
-        season_end_date:,
+        exhibition_start_date:,
+        exhibition_end_date:,
+        regular_start_date:,
+        regular_end_date:,
         games: []
       )
-        raise ArgumentError, 'preseason_start_date is required' if preseason_start_date.to_s.empty?
-        raise ArgumentError, 'preseason_end_date is required'   if preseason_end_date.to_s.empty?
-        raise ArgumentError, 'season_start_date is required'    if season_start_date.to_s.empty?
-        raise ArgumentError, 'season_end_date is required'      if season_end_date.to_s.empty?
+        raise ArgumentError, 'exhibition_start_date is required' if exhibition_start_date.to_s.empty?
+        raise ArgumentError, 'exhibition_end_date is required'   if exhibition_end_date.to_s.empty?
+        raise ArgumentError, 'regular_start_date is required'    if regular_start_date.to_s.empty?
+        raise ArgumentError, 'regular_end_date is required'      if regular_end_date.to_s.empty?
 
-        @preseason_start_date = preseason_start_date
-        @preseason_end_date   = preseason_end_date
-        @season_start_date    = season_start_date
-        @season_end_date      = season_end_date
-        @games                = []
+        @exhibition_start_date = exhibition_start_date
+        @exhibition_end_date   = exhibition_end_date
+        @regular_start_date    = regular_start_date
+        @regular_end_date      = regular_end_date
+        @games                 = []
 
         games.each { |game| add!(game) }
 
@@ -60,8 +60,38 @@ module Basketball
         end
       end
 
+      def available_exhibition_dates_for(opponent)
+        all_exhibition_dates - exhibitions_for(opponent:).map(&:date)
+      end
+
+      def available_regular_dates_for(opponent)
+        all_season_dates - regulars_for(opponent:).map(&:date)
+      end
+
+      def available_exhibition_matchup_dates(opponent1, opponent2)
+        available_opponent_dates       = available_exhibition_dates_for(opponent1)
+        available_other_opponent_dates = available_exhibition_dates_for(opponent2)
+
+        available_opponent_dates & available_other_opponent_dates
+      end
+
+      def available_regular_matchup_dates(opponent1, opponent2)
+        available_opponent_dates       = available_regular_dates_for(opponent1)
+        available_other_opponent_dates = available_regular_dates_for(opponent2)
+
+        available_opponent_dates & available_other_opponent_dates
+      end
+
       private
 
+      def all_exhibition_dates
+        (exhibition_start_date..exhibition_end_date).to_a
+      end
+
+      def all_season_dates
+        (regular_start_date..regular_end_date).to_a
+      end
+
       def assert_free_date(game)
         if games_for(date: game.date, opponent: game.home_opponent).any?
           raise TeamAlreadyBookedError, "#{game.home_opponent} already playing on #{game.date}"
@@ -76,11 +106,11 @@ module Basketball
         date = game.date
 
         if game.is_a?(Exhibition)
-          raise OutOfBoundsError, "#{date} is before preseason begins" if date < preseason_start_date
-          raise OutOfBoundsError, "#{date} is after preseason ends"    if date > preseason_end_date
+          raise OutOfBoundsError, "#{date} is before exhibition begins" if date < exhibition_start_date
+          raise OutOfBoundsError, "#{date} is after exhibition ends"    if date > exhibition_end_date
         elsif game.is_a?(Regular)
-          raise OutOfBoundsError, "#{date} is before season begins" if date < season_start_date
-          raise OutOfBoundsError, "#{date} is after season ends"    if date > season_end_date
+          raise OutOfBoundsError, "#{date} is before season begins" if date < regular_start_date
+          raise OutOfBoundsError, "#{date} is after season ends"    if date > regular_end_date
         else
           raise ArgumentError, "Dont know what this game type is: #{game.class.name}"
         end