basketball 0.0.9 → 0.0.11

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,72 +2,99 @@
 
 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
-      class TeamAlreadyRegisteredError < StandardError; end
-      class UnregisteredTeamError < StandardError; end
+    class League < Entity
+      include HasDivisions
 
-      attr_reader :teams
+      class ConferenceAlreadyRegisteredError < StandardError; end
 
-      def initialize(teams: [])
-        @teams = []
+      alias signed? player?
 
-        teams.each { |team| register!(team) }
+      attr_reader :conferences
 
-        freeze
+      def initialize(conferences: [])
+        super()
+
+        @conferences = []
+
+        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)
+
+        # 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 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)
 
-        team.sign!(player)
+        conferences << conference
 
         self
       end
 
-      def signed?(player)
-        players.include?(player)
+      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
 
-      def ==(other)
-        teams == other.teams
+      private
+
+      def team_for(id)
+        teams.find { |team| team.id == id }
       end
-      alias eql? ==
     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

@@ -4,32 +4,29 @@ module Basketball
   module Season
     # A very, very, very basic starting point for a "semi-randomized" game simulator.
     class Arena
-      RANDOM             = :random
-      TOP_ONE            = :top_one
-      TOP_TWO            = :top_two
-      TOP_THREE          = :top_three
-      TOP_SIX            = :top_six
-      MAX_HOME_ADVANTAGE = 5
-
-      STRATEGY_FREQUENCIES = {
-        RANDOM => 10,
-        TOP_ONE => 5,
-        TOP_TWO => 10,
-        TOP_THREE => 20,
-        TOP_SIX => 30
+      RANDOM    = :random
+      TOP_ONE   = :top_one
+      TOP_TWO   = :top_two
+      TOP_THREE = :top_three
+      TOP_SIX   = :top_six
+      DEFAULT_MAX_HOME_ADVANTAGE = 5
+
+      DEFAULT_STRATEGY_FREQUENCIES = {
+        RANDOM => 3,
+        TOP_ONE => 1,
+        TOP_TWO => 1,
+        TOP_THREE => 1,
+        TOP_SIX => 1
       }.freeze
 
-      private_constant :STRATEGY_FREQUENCIES,
-                       :RANDOM,
-                       :TOP_ONE,
-                       :TOP_TWO,
-                       :TOP_SIX,
-                       :MAX_HOME_ADVANTAGE
+      attr_reader :lotto, :max_home_advantage
 
-      def initialize
-        @lotto = STRATEGY_FREQUENCIES.inject([]) do |memo, (name, frequency)|
-          memo + ([name] * frequency)
-        end.shuffle
+      def initialize(
+        strategy_frquencies: DEFAULT_STRATEGY_FREQUENCIES,
+        max_home_advantage: DEFAULT_MAX_HOME_ADVANTAGE
+      )
+        @max_home_advantage = max_home_advantage
+        @lotto              = make_lotto(strategy_frquencies)
 
         freeze
       end
@@ -57,7 +54,11 @@ module Basketball
 
       private
 
-      attr_reader :lotto
+      def make_lotto(strategy_frquencies)
+        strategy_frquencies.inject([]) do |memo, (name, frequency)|
+          memo + ([name] * frequency)
+        end.shuffle
+      end
 
       def pick_strategy
         lotto.sample
@@ -89,7 +90,7 @@ module Basketball
       end
 
       def random_home_advantage
-        rand(0..MAX_HOME_ADVANTAGE)
+        rand(0..max_home_advantage)
       end
 
       def top_one_strategy(matchup)

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

data/lib/basketball/season/coordinator.rb

@@ -3,7 +3,7 @@
 module Basketball
   module Season
     # Main iterator-based object that knows how to manage a calendar and simulate games per day.
-    class Coordinator
+    class Coordinator < Entity
       extend Forwardable
 
       class AlreadyPlayedGameError < StandardError; end
@@ -18,14 +18,13 @@ module Basketball
                   :current_date,
                   :arena,
                   :results,
-                  :league,
-                  :id
+                  :league
 
       def_delegators :calendar,
-                     :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,
                      :exhibitions_for,
                      :regulars_for,
@@ -70,13 +69,13 @@ module Basketball
       end
 
       def assert_current_date
-        if current_date < preseason_start_date
-          raise OutOfBoundsError, "current date #{current_date} should be on or after #{preseason_start_date}"
+        if current_date < exhibition_start_date
+          raise OutOfBoundsError, "current date #{current_date} should be on or after #{exhibition_start_date}"
         end
 
-        return unless current_date > season_end_date
+        return unless current_date > regular_end_date
 
-        raise OutOfBoundsError, "current date #{current_date} should be on or after #{preseason_start_date}"
+        raise OutOfBoundsError, "current date #{current_date} should be on or after #{exhibition_start_date}"
       end
 
       def sim!
@@ -104,11 +103,11 @@ module Basketball
       end
 
       def total_days
-        (season_end_date - preseason_start_date).to_i
+        (regular_end_date - exhibition_start_date).to_i
       end
 
       def days_left
-        (season_end_date - current_date).to_i
+        (regular_end_date - current_date).to_i
       end
 
       def total_exhibitions
@@ -132,7 +131,7 @@ module Basketball
       end
 
       def done?
-        current_date == season_end_date && games.length == results.length
+        current_date == regular_end_date && games.length == results.length
       end
 
       def not_done?
@@ -154,9 +153,17 @@ module Basketball
         end
       end
 
+      def regular_results
+        results.select { |result| result.game.is_a?(Regular) }
+      end
+
+      def exhibition_results
+        results.select { |result| result.game.is_a?(Exhibition) }
+      end
+
       private
 
-      attr_writer :id, :arena
+      attr_writer :arena
 
       def opponent_team(opponent)
         league.teams.find { |t| t == opponent }
@@ -171,7 +178,7 @@ module Basketball
       end
 
       def increment_current_date!
-        return self if current_date >= season_end_date
+        return self if current_date >= regular_end_date
 
         @current_date = current_date + 1
 
@@ -185,9 +192,9 @@ module Basketball
       end
 
       def assert_known_teams(game)
-        raise UnknownTeamError, "unknown opponent: #{game.home_opponent}" if league.not_registered?(game.home_opponent)
+        raise UnknownTeamError, "unknown opponent: #{game.home_opponent}" unless league.team?(game.home_opponent)
 
-        return unless league.not_registered?(game.away_opponent)
+        return if league.team?(game.away_opponent)
 
         raise UnknownTeamError, "unknown opponent: #{game.away_opponent}"
       end

data/lib/basketball/season/detail.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Describes a result from the perspective of a team.
+    class Detail < ValueObject
+      value_reader :date,
+                   :home,
+                   :opponent_score,
+                   :opponent,
+                   :score
+
+      alias home? home
+
+      def initialize(date:, home:, opponent:, opponent_score:, score:)
+        super()
+
+        raise ArgumentError,  'date is required'           unless date
+        raise ArgumentError,  'opponent is required'       unless opponent
+        raise ArgumentError,  'score is required'          unless score
+        raise ArgumentError,  'opponent_score is required' unless opponent_score
+        raise ArgumentError,  'home is required'           if home.nil?
+        raise CannotTieError, 'scores cannot be equal'     if score == opponent_score
+
+        @date           = date
+        @opponent       = opponent
+        @score          = score
+        @opponent_score = opponent_score
+        @home           = home
+
+        freeze
+      end
+
+      def win?
+        score > opponent_score
+      end
+
+      def loss?
+        score < opponent_score
+      end
+
+      def to_s
+        "[#{date}] #{win? ? 'Win' : 'Loss'} #{home? ? 'vs' : 'at'} #{opponent} (#{score}-#{opponent_score})"
+      end
+    end
+  end
+end

data/lib/basketball/season/exhibition.rb

@@ -5,7 +5,7 @@ module Basketball
     # An exhibition game.
     class Exhibition < Game
       def to_s
-        "#{super} (preseason)"
+        "#{super} (exhibition)"
       end
     end
   end

data/lib/basketball/season/opponent.rb

@@ -5,6 +5,12 @@ module Basketball
     # Represents a team without a roster.  Equal to a team by identity.
     # A team's roster will not be known until the last minute (when it is game time).
     class Opponent < Entity
+      class << self
+        def from(team)
+          new(id: team.id)
+        end
+      end
+
       def initialize(id:)
         super(id)
 

data/lib/basketball/season/record.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Represents a team within a Standings object. Each Record is comprised of Detail instances
+    # which are the game results in the perspective of a single Team.
+    class Record < Entity
+      class DetailAlreadyAddedError < StandardError; end
+      class OpponentNotFoundError < StandardError; end
+
+      def initialize(id:)
+        super(id)
+
+        @details_by_date = {}
+
+        details.each { |detail| add!(detail) }
+
+        freeze
+      end
+
+      def accept!(result)
+        if result.home_opponent == self
+          detail = Detail.new(
+            date: result.date,
+            opponent: result.away_opponent,
+            score: result.home_score,
+            opponent_score: result.away_score,
+            home: true
+          )
+
+          add!(detail)
+        elsif result.away_opponent == self
+          detail = Detail.new(
+            date: result.date,
+            opponent: result.home_opponent,
+            score: result.away_score,
+            opponent_score: result.home_score,
+            home: false
+          )
+
+          add!(detail)
+        else
+          raise OpponentNotFoundError, "#{result} has no opponent for #{self}"
+        end
+      end
+
+      def detail_for(date)
+        details_by_date[date]
+      end
+
+      def details
+        details_by_date.values
+      end
+
+      def win_percentage
+        (win_count.to_f / game_count).round(3)
+      end
+
+      def game_count
+        details.length
+      end
+
+      def win_count
+        details.count(&:win?)
+      end
+
+      def loss_count
+        details.count(&:loss?)
+      end
+
+      def to_s
+        "[#{super}] #{win_count}-#{loss_count} (#{win_percentage})"
+      end
+
+      def <=>(other)
+        [win_count, win_percentage] <=> [other.win_count, other.win_percentage]
+      end
+
+      private
+
+      attr_reader :details_by_date
+
+      def add!(detail)
+        raise DetailAlreadyAddedError, "#{detail} already added for date" if detail_for(detail.date)
+
+        details_by_date[detail.date] = detail
+
+        self
+      end
+    end
+  end
+end