basketball 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f2c7326c8bfa26bcedb1ccbedec191db4681bed0831d5f37bb7691782a12ae4
-  data.tar.gz: c22558bd6733383f7926ee33506b86eb9bb8f4fa0807d8eb246d8a8b2912041b
+  metadata.gz: afad5b6023e9b0baf1dc11fe6874d4cc46430c1698aa4e97bf5dc2df8cbb314e
+  data.tar.gz: f98bb161b770d7148c4fb271ab1b58b2347cfe7b85f94acf1fb6332a4517e61b
 SHA512:
-  metadata.gz: f04c5f0691974ae8750d3e66eaf2be925b792b771201ee727313e3f678ca7712f2f5e22878486a682cf17c0a31cac3f38428e5a1eae7337a5b0b7929596cbc22
-  data.tar.gz: 1b6a61df353c5c4ec77935cd4a406839be050eed15ccd5f3f6c79aca701b2ed5ad09cb66efb4fda4f098e2e3fd75c76596170ed8359c2f5b6abbdc4b7ac8c194
+  metadata.gz: 439ca00c393c39e8535ffc21b504b66aaf2a987f09e424ba55b8d4d33d740c6ece187e8e2821239b1d2fa7512aa3743e8a8750be9c41d71259a6093eb2bff57a
+  data.tar.gz: 433fbfeaf16e28312b165ff2b293b9a529ea57e95f0e03e4637b730f1dc36c22c095717825da54da6e0549eeccbeedbb999caf7db5afed80e8e439b25a15d2cd

data/README.md

@@ -14,18 +14,13 @@ Element      | Description
 **Assessment** | When the Room needs to know who a Front Office wants to select, the Room will send the Front Office an Assessment. The Assessment is a report of where the team currently stands: players picked, players available, and round information.
 **Calendar** | Stores important boundary dates (exhibition start, exhibition end, season start, and season end).
 **Conference** | A collection of Divisions.
-**Coordinator Repository** | Understands how to save and load Coordinator objects.
 **Coordinator** | Object which can take a League, Calendar, Games, and an Arena and provide an iterable interface to enumerate through days and simulate games as results.
 **Detail** | Re-representation of a Result object but from a specific team's perspective.
 **Division** | A collection of teams.
 **Draft** | Bounded context (sub-module) dealing with running a round-robin player draft for teams.
 **Exhibition** | Pre-season game which has no impact to team record.
-**External Dependency** | Some outside system which this library or portions of this library are dependent on.
-**File Store** | Implements a store that can interact with the underlying File System.
-**File System** | Local operating system that repositories can use as their underlying persistence layer.
 **Front Office** | Identifiable as a team, contains logic for how to auto-pick draft selections.  Meant to be subclassed and extended to include more intricate player selection logic as the base will simply randomly select a player.
 **Game** | Matches up a date with two teams (home and away) to represent a coordinatord match-up.
-**League Repository** | Understands how to save and load League objects from JSON files on disk.
 **League** | Describes a league in terms of structure composed of conferences, divisions, teams, and players.
 **Match** | When the Coordinator needs an Arena instance to select a game winner, it will send the Arena a Match. A match is Game but also includes the active roster (players) for both teams that will participate in the game.
 **Org** | Bounded context (sub-module) dealing with overall organizational structure of a sports assocation.
@@ -34,14 +29,12 @@ Element      | Description
 **Record** | Represents a team's overall record.
 **Regular** | Game that counts towards regular season record.
 **Result** | The outcome of a game (typically with a home and away score).
-**Room Repository** | Understands how to save and load Room objects.
 **Room** | Main object responsible for providing an iterable interface capable of executing a draft, pick by pick.
 **Scheduler** | Knows how to take a League and a year and generate a game-populated calendar.
 **Scout** | Knows how to stack rank lists of players.
 **Season** | Bounded context (sub-module) dealing with calendar and matchup generation.
 **Skip** | Result event emitted when a front office decides to skip a round.
 **Standings** | Synthesizes teams and results into team standings with win/loss records and more.
-**Standings Repository** | Understands how to save and load Standings objects.
 **Store** | Interface for the underlying Repository persistence layer.  While a Document Repository is mainly responsible for serialization/de-serialization, the store actually knows how to read/write the data.
 **Team Group** | Set of rosters that together form a cohesive league.
 **Team** | Member of a league and signs players.  Has games assigned and played.

data/lib/basketball/org/conference.rb

@@ -6,12 +6,13 @@ module Basketball
     class Conference < Entity
       include HasDivisions
 
-      attr_reader :divisions
+      attr_reader :divisions, :name
 
-      def initialize(id:, divisions: [])
+      def initialize(id:, name: '', divisions: [])
         super(id)
 
         @divisions = []
+        @name      = name.to_s
 
         divisions.each { |d| register_division!(d) }
 
@@ -19,7 +20,7 @@ module Basketball
       end
 
       def to_s
-        ([super] + divisions.map(&:to_s)).join("\n")
+        (["[#{super}] #{name}"] + divisions.map(&:to_s)).join("\n")
       end
 
       def teams

data/lib/basketball/org/division.rb

@@ -6,12 +6,13 @@ module Basketball
     class Division < Entity
       include HasTeams
 
-      attr_reader :teams
+      attr_reader :teams, :name
 
-      def initialize(id:, teams: [])
+      def initialize(id:, name: '', teams: [])
         super(id)
 
         @teams = []
+        @name  = name.to_s
 
         teams.each { |t| register_team!(t) }
 
@@ -19,7 +20,7 @@ module Basketball
       end
 
       def to_s
-        ([super] + teams.map(&:to_s)).join("\n")
+        (["[#{super}] #{name}"] + teams.map(&:to_s)).join("\n")
       end
 
       def players

data/lib/basketball/org/player.rb

@@ -5,21 +5,27 @@ module Basketball
     # Base class describing a player.
     # A consumer application should extend these specific to their specific sports traits.
     class Player < Entity
-      attr_reader :overall, :position
+      attr_reader :overall, :position, :first_name, :last_name
 
-      def initialize(id:, overall: 0, position: nil)
+      def initialize(id:, overall: 0, position: nil, first_name: '', last_name: '')
         super(id)
 
         raise ArgumentError, 'position is required' unless position
 
-        @overall  = overall
-        @position = position
+        @overall    = overall
+        @position   = position
+        @first_name = first_name
+        @last_name  = last_name
 
         freeze
       end
 
+      def full_name
+        "#{first_name} #{last_name}".strip
+      end
+
       def to_s
-        "[#{super}] (#{position}) #{overall}".strip
+        "[#{super}] #{full_name} (#{position}) #{overall}".strip
       end
     end
   end

data/lib/basketball/org/team.rb

@@ -5,12 +5,13 @@ module Basketball
     # 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
+      attr_reader :players, :name
 
-      def initialize(id:, players: [])
+      def initialize(id:, name: '', players: [])
         super(id)
 
         @players = []
+        @name    = name.to_s
 
         players.each { |p| sign!(p) }
 
@@ -18,7 +19,7 @@ module Basketball
       end
 
       def to_s
-        ([super.to_s] + players.map(&:to_s)).join("\n")
+        (["[#{super}] #{name}"] + players.map(&:to_s)).join("\n")
       end
 
       def signed?(player)

data/lib/basketball/season/coordinator.rb

@@ -16,7 +16,8 @@ module Basketball
       attr_reader :calendar,
                   :current_date,
                   :arena,
-                  :results
+                  :results,
+                  :league
 
       def_delegators :calendar,
                      :exhibition_start_date,
@@ -28,29 +29,32 @@ module Basketball
                      :regulars_for,
                      :games_for
 
-      def initialize(calendar:, current_date:, results: [])
+      def initialize(calendar:, league:, current_date:, results: [])
         super()
 
-        raise ArgumentError, 'calendar is required' unless calendar
+        raise ArgumentError, 'calendar is required'     unless calendar
         raise ArgumentError, 'current_date is required' if current_date.to_s.empty?
+        raise ArgumentError, 'league is required'       unless league
 
         @calendar     = calendar
         @current_date = current_date
         @arena        = Arena.new
         @results      = []
+        @league       = league
 
         results.each { |result| replay!(result) }
 
         assert_current_date
         assert_all_past_dates_are_played
         assert_all_future_dates_arent_played
+        assert_all_known_teams
       end
 
-      def sim_rest!(league, &)
+      def sim_rest!(&)
         events = []
 
         while not_done?
-          new_events = sim!(league, &)
+          new_events = sim!(&)
 
           events += new_events
         end
@@ -68,7 +72,7 @@ module Basketball
         raise OutOfBoundsError, "current date #{current_date} should be on or after #{exhibition_start_date}"
       end
 
-      def sim!(league)
+      def sim!
         raise ArgumentError, 'league is required' unless league
 
         return [] if done?
@@ -77,8 +81,8 @@ module Basketball
         games  = games_for(date: current_date)
 
         games.each do |game|
-          home_players = opponent_team(league, game.home_opponent).players
-          away_players = opponent_team(league, game.away_opponent).players
+          home_players = opponent_team(game.home_opponent).players
+          away_players = opponent_team(game.away_opponent).players
           matchup      = Matchup.new(game:, home_players:, away_players:)
           event        = arena.play(matchup)
 
@@ -156,7 +160,7 @@ module Basketball
 
       attr_writer :arena
 
-      def opponent_team(league, opponent)
+      def opponent_team(opponent)
         league.teams.find { |t| t == opponent }
       end
 
@@ -220,6 +224,18 @@ module Basketball
 
         result
       end
+
+      def assert_known_teams(game)
+        raise UnknownTeamError, "unknown opponent: #{game.home_opponent}" unless league.team?(game.home_opponent)
+
+        return if league.team?(game.away_opponent)
+
+        raise UnknownTeamError, "unknown opponent: #{game.away_opponent}"
+      end
+
+      def assert_all_known_teams
+        calendar.games.each { |game| assert_known_teams(game) }
+      end
     end
   end
 end

data/lib/basketball/version.rb

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

data/lib/basketball.rb

@@ -15,6 +15,3 @@ require_relative 'basketball/org'
 # Dependent on Org
 require_relative 'basketball/draft'
 require_relative 'basketball/season'
-
-# Dependent on All
-require_relative 'basketball/app'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: basketball
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.18
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-12 00:00:00.000000000 Z
+date: 2023-06-14 00:00:00.000000000 Z
 dependencies: []
 description: "    This library is meant to serve as the domain for a basketball league/season
   simulator/turn-based game. It models core ideas such as: players, general managers,
@@ -33,14 +33,6 @@ files:
 - Rakefile
 - basketball.gemspec
 - lib/basketball.rb
-- lib/basketball/app.rb
-- lib/basketball/app/coordinator_repository.rb
-- lib/basketball/app/document_repository.rb
-- lib/basketball/app/file_store.rb
-- lib/basketball/app/in_memory_store.rb
-- lib/basketball/app/league_repository.rb
-- lib/basketball/app/room_repository.rb
-- lib/basketball/app/standings_repository.rb
 - lib/basketball/draft.rb
 - lib/basketball/draft/assessment.rb
 - lib/basketball/draft/event.rb

data/lib/basketball/app/coordinator_repository.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module App
-    # Knows how to flatten a Coordinator instance and rehydrate one from JSON and/or a Ruby hash.
-    class CoordinatorRepository < DocumentRepository
-      GAME_CLASSES = {
-        'Exhibition' => Season::Exhibition,
-        'Regular' => Season::Regular
-      }.freeze
-
-      private_constant :GAME_CLASSES
-
-      private
-
-      def from_h(hash)
-        Season::Coordinator.new(
-          calendar: deserialize_calendar(hash[:calendar]),
-          current_date: Date.parse(hash[:current_date]),
-          results: deserialize_results(hash[:results])
-        )
-      end
-
-      def to_h(coordinator)
-        {
-          id: coordinator.id,
-          calendar: serialize_calendar(coordinator.calendar),
-          current_date: coordinator.current_date.to_s,
-          results: serialize_results(coordinator.results)
-        }
-      end
-
-      # Serialization
-
-      def serialize_games(games)
-        games.map { |game| serialize_game(game) }
-      end
-
-      def serialize_calendar(calendar)
-        {
-          exhibition_start_date: calendar.exhibition_start_date.to_s,
-          exhibition_end_date: calendar.exhibition_end_date.to_s,
-          regular_start_date: calendar.regular_start_date.to_s,
-          regular_end_date: calendar.regular_end_date.to_s,
-          games: serialize_games(calendar.games)
-        }
-      end
-
-      def serialize_game(game)
-        {
-          type: game.class.name.split('::').last,
-          date: game.date.to_s,
-          home_opponent: game.home_opponent.id,
-          away_opponent: game.away_opponent.id
-        }
-      end
-
-      def serialize_result(result)
-        {
-          game: serialize_game(result.game),
-          home_score: result.home_score,
-          away_score: result.away_score
-        }
-      end
-
-      def serialize_results(results)
-        results.map do |result|
-          serialize_result(result)
-        end
-      end
-
-      # Deserialization
-
-      def deserialize_calendar(calendar_hash)
-        Season::Calendar.new(
-          exhibition_start_date: Date.parse(calendar_hash[:exhibition_start_date]),
-          exhibition_end_date: Date.parse(calendar_hash[:exhibition_end_date]),
-          regular_start_date: Date.parse(calendar_hash[:regular_start_date]),
-          regular_end_date: Date.parse(calendar_hash[:regular_end_date]),
-          games: deserialize_games(calendar_hash[:games])
-        )
-      end
-
-      def deserialize_games(game_hashes)
-        (game_hashes || []).map { |game_hash| deserialize_game(game_hash) }
-      end
-
-      def deserialize_game(game_hash)
-        GAME_CLASSES.fetch(game_hash[:type]).new(
-          date: Date.parse(game_hash[:date]),
-          home_opponent: Season::Opponent.new(id: game_hash[:home_opponent]),
-          away_opponent: Season::Opponent.new(id: game_hash[:away_opponent])
-        )
-      end
-
-      def deserialize_results(result_hashes)
-        (result_hashes || []).map do |result_hash|
-          deserialize_result(result_hash)
-        end
-      end
-
-      def deserialize_result(result_hash)
-        Season::Result.new(
-          game: deserialize_game(result_hash[:game]),
-          home_score: result_hash[:home_score],
-          away_score: result_hash[:away_score]
-        )
-      end
-    end
-  end
-end

data/lib/basketball/app/document_repository.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module App
-    # Base class for all repositories which are based on a flat document.
-    # At the very minimum sub-classes should implement #to_h(object) and #from_h(hash).
-    class DocumentRepository
-      attr_reader :store
-
-      def initialize(store = InMemoryStore.new)
-        super()
-
-        @store = store
-      end
-
-      def load(id)
-        contents = store.read(id)
-
-        deserialize(contents).tap do |object|
-          object.send('id=', id)
-        end
-      end
-
-      def save(id, object)
-        object.send('id=', id)
-
-        contents = serialize(object)
-
-        store.write(id, contents)
-
-        object
-      end
-
-      def delete(object)
-        return false unless object.id
-
-        store.delete(object.id)
-
-        object.send('id=', nil)
-
-        true
-      end
-
-      def exist?(id)
-        store.exist?(id)
-      end
-
-      protected
-
-      def from_h(hash)
-        Entity.new(hash[:id])
-      end
-
-      def to_h(entity)
-        { id: entity.id }
-      end
-
-      private
-
-      def deserialize(string)
-        hash = JSON.parse(string, symbolize_names: true)
-
-        from_h(hash)
-      end
-
-      def serialize(object)
-        to_h(object).to_json
-      end
-    end
-  end
-end

data/lib/basketball/app/file_store.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module App
-    # Knows how to read and write documents to disk.
-    class FileStore
-      class PathNotFoundError < StandardError; end
-
-      def exist?(path)
-        File.exist?(path)
-      end
-
-      def read(path)
-        raise PathNotFoundError, "'#{path}' not found" unless exist?(path)
-
-        File.read(path)
-      end
-
-      def write(path, contents)
-        dir = File.dirname(path)
-
-        FileUtils.mkdir_p(dir)
-
-        File.write(path, contents)
-
-        nil
-      end
-
-      def delete(path)
-        raise PathNotFoundError, "'#{path}' not found" unless exist?(path)
-
-        File.delete(path)
-
-        nil
-      end
-    end
-  end
-end

data/lib/basketball/app/in_memory_store.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module App
-    # Knows how to read and write documents to a Ruby Hash.
-    class InMemoryStore
-      class KeyNotFoundError < StandardError; end
-
-      attr_reader :data
-
-      def initialize(data = {})
-        @data = data
-
-        freeze
-      end
-
-      def exist?(key)
-        data.key?(key.to_s)
-      end
-
-      def read(key)
-        raise KeyNotFoundError, "'#{key}' not found" unless exist?(key)
-
-        data[key.to_s]
-      end
-
-      def write(key, contents)
-        data[key.to_s] = contents
-
-        nil
-      end
-
-      def delete(key)
-        raise KeyNotFoundError, "'#{key}' not found" unless exist?(key)
-
-        data.delete(key)
-
-        nil
-      end
-    end
-  end
-end

data/lib/basketball/app/league_repository.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module App
-    # Knows how to flatten a League instances and rehydrate one from JSON and/or a Ruby hash.
-    class LeagueRepository < DocumentRepository
-      private
-
-      def from_h(hash)
-        deserialize_league(hash)
-      end
-
-      def to_h(league)
-        serialize_league(league)
-      end
-
-      # Serialization
-
-      def serialize_league(league)
-        {
-          id: league.id,
-          conferences: serialize_conferences(league.conferences)
-        }
-      end
-
-      def serialize_conferences(conferences)
-        conferences.map do |conference|
-          {
-            id: conference.id,
-            divisions: serialize_divisions(conference.divisions)
-          }
-        end
-      end
-
-      def serialize_divisions(divisions)
-        divisions.map do |division|
-          {
-            id: division.id,
-            teams: serialize_teams(division.teams)
-          }
-        end
-      end
-
-      def serialize_teams(teams)
-        teams.map do |team|
-          {
-            id: team.id,
-            players: serialize_players(team.players)
-          }
-        end
-      end
-
-      def serialize_players(players)
-        players.map do |player|
-          {
-            id: player.id,
-            overall: player.overall,
-            position: player.position&.code
-          }
-        end
-      end
-
-      # Deserialization
-
-      def deserialize_league(league_hash)
-        Org::League.new(
-          conferences: deserialize_conferences(league_hash[:conferences])
-        )
-      end
-
-      def deserialize_conferences(conference_hashes)
-        (conference_hashes || []).map do |conference_hash|
-          Org::Conference.new(
-            id: conference_hash[:id],
-            divisions: deserialize_divisions(conference_hash[:divisions])
-          )
-        end
-      end
-
-      def deserialize_divisions(division_hashes)
-        (division_hashes || []).map do |division_hash|
-          Org::Division.new(
-            id: division_hash[:id],
-            teams: deserialize_teams(division_hash[:teams])
-          )
-        end
-      end
-
-      def deserialize_teams(team_hashes)
-        (team_hashes || []).map do |team_hash|
-          Org::Team.new(
-            id: team_hash[:id],
-            players: deserialize_players(team_hash[:players])
-          )
-        end
-      end
-
-      def deserialize_players(player_hashes)
-        (player_hashes || []).map do |player_hash|
-          Org::Player.new(
-            id: player_hash[:id],
-            overall: player_hash[:overall],
-            position: Org::Position.new(player_hash[:position])
-          )
-        end
-      end
-    end
-  end
-end

data/lib/basketball/app/room_repository.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module App
-    # Can load and save Room objects as JSON Documents.
-    class RoomRepository < DocumentRepository
-      PICK_EVENT = 'Pick'
-      SKIP_EVENT = 'Skip'
-
-      private_constant :PICK_EVENT, :SKIP_EVENT
-
-      private
-
-      def from_h(hash)
-        front_offices = deserialize_front_offices(hash[:front_offices])
-        players       = deserialize_players(hash[:players])
-        events        = deserialize_events(hash[:events], players:, front_offices:)
-
-        Draft::Room.new(
-          rounds: hash[:rounds],
-          front_offices:,
-          players:,
-          events:
-        )
-      end
-
-      def to_h(room)
-        {
-          id: room.id,
-          rounds: room.rounds,
-          front_offices: room.front_offices.map { |fo| serialize_front_office(fo) },
-          players: room.players.map { |p| serialize_player(p) },
-          events: serialize_events(room.events)
-        }
-      end
-
-      # Serialization
-
-      def serialize_player(player)
-        {
-          id: player.id,
-          overall: player.overall,
-          position: player.position&.code
-        }
-      end
-
-      def serialize_front_office(front_office)
-        {
-          id: front_office.id,
-          risk_level: front_office.risk_level,
-          prioritized_positions: front_office.prioritized_positions.map(&:code),
-          star_level: front_office.star_level
-        }
-      end
-
-      def serialize_events(events)
-        events.map do |event|
-          case event
-          when Draft::Pick
-            serialize_pick(event)
-          when Draft::Skip
-            serialize_skip(event)
-          end
-        end
-      end
-
-      def serialize_pick(event)
-        {
-          id: event.id || event.pick,
-          type: PICK_EVENT,
-          front_office: event.front_office.id,
-          pick: event.pick,
-          round: event.round,
-          round_pick: event.round_pick,
-          auto: event.auto,
-          player: event.player.id
-        }
-      end
-
-      def serialize_skip(event)
-        {
-          id: event.id || event.pick,
-          type: SKIP_EVENT,
-          front_office: event.front_office.id,
-          pick: event.pick,
-          round: event.round,
-          round_pick: event.round_pick
-        }
-      end
-
-      # Deserialization
-
-      def deserialize_player(player_hash)
-        Org::Player.new(
-          id: player_hash[:id],
-          overall: player_hash[:overall],
-          position: Org::Position.new(player_hash[:position])
-        )
-      end
-
-      def deserialize_front_office(hash)
-        Draft::FrontOffice.new(
-          id: hash[:id],
-          risk_level: hash[:risk_level].to_i,
-          prioritized_positions: (hash[:prioritized_positions] || []).map { |c| Org::Position.new(c) },
-          star_level: hash[:star_level].to_i
-        )
-      end
-
-      def deserialize_front_offices(hashes)
-        (hashes || []).map { |fo| deserialize_front_office(fo) }
-      end
-
-      def deserialize_players(hashes)
-        (hashes || []).map { |hash| deserialize_player(hash) }
-      end
-
-      def deserialize_pick(hash, players:, front_office:)
-        player_id = hash[:player]
-        player    = players.find { |p| p.id == player_id }
-
-        Draft::Pick.new(
-          front_office:,
-          pick: hash[:pick],
-          round: hash[:round],
-          round_pick: hash[:round_pick],
-          player:,
-          auto: hash[:auto]
-        )
-      end
-
-      def deserialize_skip(hash, front_office:)
-        Draft::Skip.new(
-          front_office:,
-          pick: hash[:pick],
-          round: hash[:round],
-          round_pick: hash[:round_pick]
-        )
-      end
-
-      def deserialize_events(hashes, players:, front_offices:)
-        (hashes || []).map do |hash|
-          front_office_id = hash[:front_office]
-          front_office    = front_offices.find { |fo| fo.id == front_office_id }
-
-          event =
-            case hash[:type]
-            when PICK_EVENT
-              deserialize_pick(hash, players:, front_office:)
-            when SKIP_EVENT
-              deserialize_skip(hash, front_office:)
-            end
-
-          event.tap do |e|
-            e.send('id=', hash[:id])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/basketball/app/standings_repository.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Basketball
-  module App
-    # Can load and save Standings objects as JSON Documents.
-    class StandingsRepository < DocumentRepository
-      private
-
-      def from_h(hash)
-        Season::Standings.new(
-          records: deserialize_records(hash[:records])
-        )
-      end
-
-      def to_h(standings)
-        {
-          id: standings.id,
-          records: serialize_records(standings.records)
-        }
-      end
-
-      # Serialization
-
-      def serialize_records(records)
-        (records || []).map do |record|
-          {
-            id: record.id,
-            details: serialize_details(record.details)
-          }
-        end
-      end
-
-      def serialize_details(details)
-        (details || []).map do |detail|
-          {
-            date: detail.date.to_s,
-            home: detail.home,
-            opponent: detail.opponent.id,
-            opponent_score: detail.opponent_score,
-            score: detail.score
-          }
-        end
-      end
-
-      # Deserialization
-
-      def deserialize_records(record_hashes)
-        (record_hashes || []).map do |record_hash|
-          Season::Record.new(
-            id: record_hash[:id],
-            details: deserialize_details(record_hash[:details])
-          )
-        end
-      end
-
-      def deserialize_details(detail_hashes)
-        (detail_hashes || []).map do |detail_hash|
-          Season::Detail.new(
-            date: Date.parse(detail_hash[:date]),
-            home: detail_hash[:home],
-            opponent: Season::Opponent.new(id: detail_hash[:opponent]),
-            opponent_score: detail_hash[:opponent_score].to_i,
-            score: detail_hash[:score].to_i
-          )
-        end
-      end
-    end
-  end
-end

data/lib/basketball/app.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-# Stores
-require_relative 'app/file_store'
-require_relative 'app/in_memory_store'
-
-# Repositories / Common
-require_relative 'app/document_repository'
-
-# Repositories / Implementations
-require_relative 'app/coordinator_repository'
-require_relative 'app/league_repository'
-require_relative 'app/room_repository'
-require_relative 'app/standings_repository'