basketball 0.0.8 → 0.0.10

data/lib/basketball/draft/room_serializer.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'front_office'
-require_relative 'player'
-require_relative 'pick_event'
-require_relative 'sim_event'
-require_relative 'skip_event'
-
-module Basketball
-  module Draft
-    class RoomSerializer
-      EVENT_CLASSES = {
-        'PickEvent' => PickEvent,
-        'SimEvent' => SimEvent,
-        'SkipEvent' => SkipEvent
-      }.freeze
-
-      private_constant :EVENT_CLASSES
-
-      def to_hash(room)
-        {
-          'info' => serialize_info(room),
-          'room' => serialize_room(room),
-          'league' => serialize_league(room)
-        }
-      end
-
-      def from_hash(json)
-        front_offices = deserialize_front_offices(json)
-        players       = deserialize_players(json)
-        events        = deserialize_events(json, players, front_offices)
-
-        room_opts = {
-          players:,
-          front_offices:,
-          events:
-        }
-
-        room_opts[:rounds] = json.dig('room', 'rounds') if json.dig('room', 'rounds')
-
-        Room.new(**room_opts)
-      end
-
-      def deserialize(string)
-        json = JSON.parse(string)
-
-        from_hash(json)
-      end
-
-      def serialize(room)
-        to_hash(room).to_json
-      end
-
-      private
-
-      def serialize_room(room)
-        {
-          'rounds' => room.rounds,
-          'front_offices' => serialize_front_offices(room),
-          'players' => serialize_players(room),
-          'events' => serialize_events(room.events)
-        }
-      end
-
-      def serialize_info(room)
-        {
-          'total_picks' => room.total_picks,
-          'current_round' => room.current_round,
-          'current_round_pick' => room.current_round_pick,
-          'current_front_office' => room.current_front_office&.id,
-          'current_pick' => room.current_pick,
-          'remaining_picks' => room.remaining_picks,
-          'done' => room.done?
-        }
-      end
-
-      def serialize_league(room)
-        league = room.to_league
-
-        rosters = league.rosters.to_h do |roster|
-          [
-            roster.id,
-            {
-              'players' => roster.players.map(&:id)
-            }
-          ]
-        end
-
-        {
-          'free_agents' => league.free_agents.map(&:id),
-          'rosters' => rosters
-        }
-      end
-
-      def serialize_front_offices(room)
-        room.front_offices.to_h do |front_office|
-          [
-            front_office.id,
-            {
-              'name' => front_office.name,
-              'fuzz' => front_office.fuzz,
-              'depth' => front_office.depth,
-              'prioritized_positions' => front_office.prioritized_positions.map(&:code)
-            }
-          ]
-        end
-      end
-
-      def serialize_players(room)
-        room.players.to_h do |player|
-          [
-            player.id,
-            {
-              'first_name' => player.first_name,
-              'last_name' => player.last_name,
-              'overall' => player.overall,
-              'position' => player.position.code
-            }
-          ]
-        end
-      end
-
-      def serialize_events(events)
-        events.map do |event|
-          {
-            'type' => event.class.name.split('::').last,
-            '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_front_offices(json)
-        (json.dig('room', '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: front_office_hash['name'],
-            prioritized_positions:,
-            fuzz: front_office_hash['fuzz'],
-            depth: front_office_hash['depth']
-          }
-
-          FrontOffice.new(**front_office_opts)
-        end
-      end
-
-      def deserialize_players(json)
-        (json.dig('room', 'players') || []).map do |id, player_hash|
-          player_opts = {
-            id:,
-            first_name: player_hash['first_name'],
-            last_name: player_hash['last_name'],
-            overall: player_hash['overall'],
-            position: Position.new(player_hash['position'])
-          }
-
-          Player.new(**player_opts)
-        end
-      end
-
-      def deserialize_events(json, players, front_offices)
-        (json.dig('room', 'events') || []).map do |event_hash|
-          event_opts = event_hash.slice('pick', 'round', 'round_pick').merge(
-            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
-    end
-  end
-end

data/lib/basketball/draft/roster.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Draft
-    class Roster < Entity
-      class PlayerRequiredError < StandardError; end
-
-      attr_reader :name, :players
-
-      def initialize(id:, name: '', players: [])
-        super(id)
-
-        @name    = name.to_s
-        @players = players.each { |p| register!(p) }
-
-        freeze
-      end
-
-      def registered?(player)
-        players.include?(player)
-      end
-
-      def sign!(player)
-        raise PlayerRequiredError, 'player is required' unless player
-        raise PlayerAlreadyRegisteredError, "#{player} already registered for #{id}" if registered?(player)
-
-        players << player
-
-        self
-      end
-
-      def to_s
-        (["[#{super}] #{name} Roster"] + players.map(&:to_s)).join("\n")
-      end
-    end
-  end
-end

data/lib/basketball/draft/sim_event.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Draft
-    class SimEvent < Event
-      attr_reader_value :player
-
-      def initialize(front_office:, player:, pick:, round:, round_pick:)
-        super(front_office:, pick:, round:, round_pick:)
-
-        raise ArgumentError, 'player required' unless player
-
-        @player = player
-
-        freeze
-      end
-
-      def to_s
-        "#{player} auto-picked #{super}"
-      end
-    end
-  end
-end

data/lib/basketball/draft/skip_event.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'event'
-
-module Basketball
-  module Draft
-    class SkipEvent < Event
-      def to_s
-        "skipped #{super}"
-      end
-    end
-  end
-end

data/lib/basketball/season/calendar_serializer.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'game'
-require_relative 'preseason_game'
-require_relative 'season_game'
-
-module Basketball
-  module Season
-    class CalendarSerializer
-      GAME_CLASSES = {
-        'PreseasonGame' => PreseasonGame,
-        'SeasonGame' => SeasonGame
-      }.freeze
-
-      def to_hash(calendar)
-        teams = calendar.games.flat_map(&:teams).uniq
-
-        {
-          'year' => calendar.preseason_start_date.year,
-          'teams' => serialize_teams(teams),
-          'games' => serialize_games(calendar.games)
-        }
-      end
-
-      def from_hash(json)
-        Calendar.new(
-          year: json['year'].to_i,
-          games: deserialize_games(json)
-        )
-      end
-
-      def deserialize(string)
-        json = JSON.parse(string)
-
-        from_hash(json)
-      end
-
-      def serialize(calendar)
-        to_hash(calendar).to_json
-      end
-
-      private
-
-      ## Deserialization
-
-      def deserialize_games(json)
-        teams = deserialize_teams(json['teams'])
-
-        (json['games'] || []).map do |game_hash|
-          GAME_CLASSES.fetch(game_hash['type']).new(
-            date: Date.parse(game_hash['date']),
-            home_team: teams.fetch(game_hash['home_team']),
-            away_team: teams.fetch(game_hash['away_team'])
-          )
-        end
-      end
-
-      def deserialize_teams(teams)
-        (teams || []).to_h do |id, team_hash|
-          team = Team.new(id:, name: team_hash['name'])
-
-          [
-            team.id,
-            team
-          ]
-        end
-      end
-
-      ## Serialization
-
-      def serialize_teams(teams)
-        teams.to_h do |team|
-          [
-            team.id,
-            {
-              'name' => team.name
-            }
-          ]
-        end
-      end
-
-      def serialize_games(games)
-        games.sort_by(&:date).map do |game|
-          {
-            'type' => game.class.name.split('::').last,
-            'date' => game.date.to_s,
-            'home_team' => game.home_team.id,
-            'away_team' => game.away_team.id
-          }
-        end
-      end
-    end
-  end
-end

data/lib/basketball/season/conference.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Season
-    class Conference < Entity
-      DIVISIONS_SIZE = 3
-
-      attr_reader :name, :divisions
-
-      def initialize(id:, name: '', divisions: [])
-        super(id)
-
-        @name      = name.to_s
-        @divisions = []
-
-        divisions.each { |d| register_division!(d) }
-
-        if divisions.length != DIVISIONS_SIZE
-          raise BadDivisionsSizeError, "#{id} should have exactly #{DIVISIONS_SIZE} divisions"
-        end
-
-        freeze
-      end
-
-      def to_s
-        (["[#{super}] #{name}"] + divisions.map(&:to_s)).join("\n")
-      end
-
-      def division?(division)
-        divisions.include?(division)
-      end
-
-      def teams
-        divisions.flat_map(&:teams)
-      end
-
-      def team?(team)
-        teams.include?(team)
-      end
-
-      private
-
-      def register_division!(division)
-        raise ArgumentError, 'division is required' unless division
-        raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
-
-        division.teams.each do |team|
-          raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
-        end
-
-        divisions << division
-
-        self
-      end
-    end
-  end
-end

data/lib/basketball/season/division.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Season
-    class Division < Entity
-      TEAMS_SIZE = 5
-
-      attr_reader :name, :teams
-
-      def initialize(id:, name: '', teams: [])
-        super(id)
-
-        @name  = name.to_s
-        @teams = []
-
-        teams.each { |t| register_team!(t) }
-
-        raise BadTeamsSizeError, "#{id} should have exactly #{TEAMS_SIZE} teams" if teams.length != TEAMS_SIZE
-
-        freeze
-      end
-
-      def to_s
-        (["[#{super}] #{name}"] + teams.map(&:to_s)).join("\n")
-      end
-
-      def team?(team)
-        teams.include?(team)
-      end
-
-      private
-
-      def register_team!(team)
-        raise ArgumentError, 'team is required' unless team
-        raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
-
-        teams << team
-
-        self
-      end
-    end
-  end
-end

data/lib/basketball/season/league.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Season
-    class League
-      class UnknownTeamError < StandardError; end
-
-      class << self
-        def generate_random; end
-      end
-
-      CONFERENCES_SIZE = 2
-
-      attr_reader :conferences
-
-      def initialize(conferences: [])
-        @conferences = []
-
-        conferences.each { |c| register_conference!(c) }
-
-        if conferences.length != CONFERENCES_SIZE
-          raise BadConferencesSizeError, "there has to be #{CONFERENCES_SIZE} conferences"
-        end
-
-        freeze
-      end
-
-      def to_s
-        (['League'] + conferences.map(&:to_s)).join("\n")
-      end
-
-      def divisions
-        conferences.flat_map(&:divisions)
-      end
-
-      def conference?(conference)
-        conferences.include?(conference)
-      end
-
-      def division?(division)
-        divisions.include?(division)
-      end
-
-      def team?(team)
-        teams.include?(team)
-      end
-
-      def teams
-        conferences.flat_map do |conference|
-          conference.divisions.flat_map(&:teams)
-        end
-      end
-
-      def conference_for(team)
-        conferences.find { |c| c.divisions.find { |d| d.teams.include?(team) } }
-      end
-
-      def division_for(team)
-        conference_for(team)&.divisions&.find { |d| d.teams.include?(team) }
-      end
-
-      # Same conference, same division
-      def division_opponents_for(team)
-        division = division_for(team)
-
-        return nil unless division
-
-        division.teams - [team]
-      end
-
-      # Same conference, different division
-      def cross_division_opponents_for(team)
-        conference = conference_for(team)
-        division   = division_for(team)
-
-        return nil unless conference && division
-
-        other_divisions = conference.divisions - [division]
-
-        other_divisions.flat_map(&:teams)
-      end
-
-      # Different conference
-      def cross_conference_opponents_for(team)
-        conference = conference_for(team)
-
-        return nil unless conference
-
-        other_conferences = conferences - [conference]
-
-        other_conferences.flat_map { |c| c.divisions.flat_map(&:teams) }
-      end
-
-      private
-
-      def register_conference!(conference)
-        raise ArgumentError, 'conference is required' unless conference
-        raise ConferenceAlreadyRegisteredError, "#{conference} already registered" if conference?(conference)
-
-        conference.divisions.each do |division|
-          raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
-
-          division.teams.each do |team|
-            raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
-          end
-        end
-
-        conferences << conference
-
-        self
-      end
-    end
-  end
-end

data/lib/basketball/season/league_serializer.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module Season
-    class LeagueSerializer
-      def to_hash(league)
-        {
-          'conferences' => serialize_conferences(league.conferences)
-        }
-      end
-
-      def from_hash(json)
-        conferences = deserialize_conferences(json['conferences'])
-
-        League.new(conferences:)
-      end
-
-      def deserialize(string)
-        json = JSON.parse(string)
-
-        from_hash(json)
-      end
-
-      def serialize(league)
-        to_hash(league).to_json
-      end
-
-      private
-
-      ## Deserialization
-
-      def deserialize_conferences(conferences)
-        (conferences || []).map do |conference_id, conference_hash|
-          Conference.new(
-            id: conference_id,
-            name: conference_hash['name'],
-            divisions: deserialize_divisions(conference_hash['divisions'])
-          )
-        end
-      end
-
-      def deserialize_divisions(divisions)
-        (divisions || []).map do |division_id, division_hash|
-          Division.new(
-            id: division_id,
-            name: division_hash['name'],
-            teams: deserialize_teams(division_hash['teams'])
-          )
-        end
-      end
-
-      def deserialize_teams(teams)
-        (teams || []).map do |team_id, team_hash|
-          Team.new(
-            id: team_id,
-            name: team_hash['name']
-          )
-        end
-      end
-
-      ## Serialization
-
-      def serialize_conferences(conferences)
-        conferences.to_h do |conference|
-          [
-            conference.id,
-            {
-              'name' => conference.name,
-              'divisions' => serialize_divisions(conference.divisions)
-            }
-          ]
-        end
-      end
-
-      def serialize_divisions(divisions)
-        divisions.to_h do |division|
-          [
-            division.id,
-            {
-              'name' => division.name,
-              'teams' => serialize_teams(division.teams)
-            }
-          ]
-        end
-      end
-
-      def serialize_teams(teams)
-        teams.to_h do |team|
-          [
-            team.id,
-            {
-              'name' => team.name
-            }
-          ]
-        end
-      end
-    end
-  end
-end