basketball 0.0.8 → 0.0.9

data/lib/basketball/app/coordinator_repository.rb

@@ -0,0 +1,191 @@
+# 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
+      GAME_CLASSES = {
+        'Exhibition' => Season::Exhibition,
+        'Regular' => Season::Regular
+      }.freeze
+
+      private_constant :GAME_CLASSES
+
+      attr_reader :store
+
+      def initialize(store: FileStore.new)
+        super()
+
+        @store = store
+
+        freeze
+      end
+
+      def load(path)
+        contents = store.read(path)
+
+        deserialize(contents).tap do |coordinator|
+          coordinator.send('id=', path)
+        end
+      end
+
+      def save(path, coordinator)
+        contents = serialize(coordinator)
+
+        store.write(path, contents)
+
+        coordinator.send('id=', path)
+
+        coordinator
+      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
+
+      def from_h(hash)
+        Season::Coordinator.new(
+          calendar: deserialize_calendar(hash[:calendar]),
+          current_date: Date.parse(hash[:current_date]),
+          results: deserialize_results(hash[:results]),
+          league: deserialize_league(hash[:league])
+        )
+      end
+
+      def to_h(coordinator)
+        {
+          calendar: serialize_calendar(coordinator.calendar),
+          current_date: coordinator.current_date.to_s,
+          results: serialize_results(coordinator.results),
+          league: serialize_league(coordinator.league)
+        }
+      end
+
+      # Serialization
+
+      def serialize_player(player)
+        {
+          id: player.id,
+          overall: player.overall,
+          position: player.position&.code
+        }
+      end
+
+      def serialize_games(games)
+        games.map { |game| serialize_game(game) }
+      end
+
+      def serialize_calendar(calendar)
+        {
+          preseason_start_date: calendar.preseason_start_date.to_s,
+          preseason_end_date: calendar.preseason_end_date.to_s,
+          season_start_date: calendar.season_start_date.to_s,
+          season_end_date: calendar.season_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_league(league)
+        {
+          teams: league.teams.map { |team| serialize_team(team) }
+        }
+      end
+
+      def serialize_team(team)
+        {
+          id: team.id,
+          players: team.players.map { |player| serialize_player(player) }
+        }
+      end
+
+      def serialize_results(results)
+        results.map do |result|
+          serialize_result(result)
+        end
+      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_league(league_hash)
+        team_hashes = league_hash[:teams] || []
+
+        teams = team_hashes.map do |team_hash|
+          players = (team_hash[:players] || []).map { |player_hash| deserialize_player(player_hash) }
+
+          Org::Team.new(id: team_hash[:id], players:)
+        end
+
+        Org::League.new(teams:)
+      end
+
+      def deserialize_calendar(calendar_hash)
+        Season::Calendar.new(
+          preseason_start_date: Date.parse(calendar_hash[:preseason_start_date]),
+          preseason_end_date: Date.parse(calendar_hash[:preseason_end_date]),
+          season_start_date: Date.parse(calendar_hash[:season_start_date]),
+          season_end_date: Date.parse(calendar_hash[:season_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/file_store.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Basketball
+  module App
+    # Knows how to read and write documents to disk.
+    class FileStore
+      def read(path)
+        File.read(path)
+      end
+
+      def write(path, contents)
+        dir = File.dirname(path)
+
+        FileUtils.mkdir_p(dir)
+
+        File.write(path, contents)
+
+        nil
+      end
+    end
+  end
+end

data/lib/basketball/{draft/cli.rb → app/room_cli.rb}

@@ -1,30 +1,25 @@
 # frozen_string_literal: true
 
-require_relative 'room'
-require_relative 'room_serializer'
-require_relative 'player_search'
-require_relative 'position'
-
 module Basketball
-  module Draft
+  module App
     # Examples:
-    #   exe/basketball-draft -o tmp/draft.json
-    #   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
+    #   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
+    class RoomCLI
       class PlayerNotFound < StandardError; end
 
-      attr_reader :opts, :serializer, :io
+      attr_reader :opts, :io, :repository
 
       def initialize(args:, io: $stdout)
         @io         = io
-        @serializer = RoomSerializer.new
         @opts       = slop_parse(args)
+        @repository = RoomRepository.new
 
         if opts[:input].to_s.empty? && opts[:output].to_s.empty?
           io.puts('Input and/or output paths are required.')
@@ -39,49 +34,46 @@ module Basketball
         room = load_room
 
         execute(room)
+        status(room)
+        write(room)
+        events(room)
+        league(room)
+        query(room)
+
+        self
+      end
+
+      private
 
+      def status(room)
         io.puts
         io.puts('Status')
 
         if room.done?
           io.puts('Draft is complete!')
         else
-          current_round        = room.current_round
-          current_round_pick   = room.current_round_pick
-          current_front_office = room.current_front_office
+          round        = room.round
+          round_pick   = room.round_pick
+          front_office = room.front_office
 
           io.puts("#{room.remaining_picks} Remaining pick(s)")
-          io.puts("Up Next: Round #{current_round} pick #{current_round_pick} for #{current_front_office}")
+          io.puts("Up Next: Round #{round} pick #{round_pick} for #{front_office}")
         end
-
-        write(room)
-
-        log(room)
-
-        league(room)
-
-        query(room)
-
-        self
       end
 
-      private
-
       def slop_parse(args)
         Slop.parse(args) do |o|
-          o.banner = 'Usage: basketball-draft [options] ...'
+          o.banner = 'Usage: basketball-room [options] ...'
 
-          o.string  '-i', '--input',
-                    'Path to load the room from. If omitted then a new draft will be generated.'
+          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.string  '-q', '--query',        "Filter TOP by position: #{Position::ALL_VALUES.join(', ')}."
-          o.bool    '-r', '--rosters',      'Output all front_office rosters.', default: false
+          o.bool    '-l', '--league',       'Output all teams and their picks', 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.bool    '-e', '--events',       'Output event log.', default: false
 
           o.on '-h', '--help', 'Print out help, like this is doing right now.' do
             io.puts(o)
@@ -104,33 +96,31 @@ module Basketball
 
       def generate_draft
         front_offices = 30.times.map do |i|
-          FrontOffice.new(
-            id: "T-#{i + 1}", name: Faker::Team.name
+          Draft::FrontOffice.new(
+            id: "T-#{i + 1}"
           )
         end
 
         players = 450.times.map do |i|
-          Player.new(
+          Org::Player.new(
             id: "P-#{i + 1}",
-            first_name: Faker::Name.first_name,
-            last_name: Faker::Name.last_name,
-            position: Position.random,
-            overall: (0..100).to_a.sample
+            overall: (20..100).to_a.sample,
+            position: Org::Position.random
           )
         end
 
-        Room.new(players:, front_offices:)
+        Draft::Room.new(rounds: 12, players:, front_offices:)
       end
 
       def league(room)
-        return unless opts[:rosters]
+        return unless opts[:league]
 
         io.puts
-        io.puts(room.to_league)
+        io.puts(room.league)
       end
 
-      def log(room)
-        return unless opts[:log]
+      def events(room)
+        return unless opts[:events]
 
         io.puts
         io.puts('Event Log')
@@ -138,32 +128,20 @@ module Basketball
         puts room.events
       end
 
-      # rubocop:disable Metrics/AbcSize
       def query(room)
         top = opts[:top]
 
         return if top <= 0
 
-        search   = PlayerSearch.new(room.undrafted_players)
-        position = opts[:query].to_s.empty? ? nil : Position.new(opts[:query])
-        players  = search.query(position:).take(opts[:top])
+        players = room.undrafted_players.sort_by(&:overall).reverse.take(opts[:top])
 
         io.puts
-        io.print("Top #{top} available players")
-
-        if position
-          io.puts(" for #{position} position:")
-        else
-          io.puts(' for all positions:')
-        end
-
+        io.puts("Top #{top} available players")
         io.puts(players)
       end
-      # rubocop:enable Metrics/AbcSize
 
       def read
-        contents = File.read(opts[:input])
-        serializer.deserialize(contents)
+        repository.load(opts[:input])
       end
 
       # rubocop:disable Metrics/AbcSize
@@ -195,14 +173,14 @@ module Basketball
           event_count += 1
         end
 
-        room.sim!(opts[:simulate]) do |event|
-          io.puts(event)
+        opts[:simulate].times do
+          room.sim!
 
           event_count += 1
         end
 
         if opts[:simulate_all]
-          room.sim! do |event|
+          room.sim_rest! do |event|
             io.puts(event)
 
             event_count += 1
@@ -215,15 +193,14 @@ module Basketball
       end
       # rubocop:enable Metrics/AbcSize
 
-      def write(room)
-        output = opts[:output].to_s.empty? ? opts[:input] : opts[:output]
-
-        contents = serializer.serialize(room)
-        out_dir  = File.dirname(output)
+      def output_default_to_input
+        opts[:output].to_s.empty? ? opts[:input] : opts[:output]
+      end
 
-        FileUtils.mkdir_p(out_dir)
+      def write(room)
+        output = output_default_to_input
 
-        File.write(output, contents)
+        repository.save(output, room)
 
         io.puts
         io.puts("Draft written to: #{output}")

data/lib/basketball/app/room_repository.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Basketball
+  module App
+    # Can load and save Room objects to JSON files.
+    class RoomRepository
+      PICK_EVENT = 'Pick'
+      SKIP_EVENT = 'Skip'
+
+      private_constant :PICK_EVENT, :SKIP_EVENT
+
+      attr_reader :store
+
+      def initialize(store: FileStore.new)
+        super()
+
+        @store = store
+
+        freeze
+      end
+
+      def load(path)
+        contents = store.read(path)
+
+        room = deserialize(contents)
+
+        room.send('id=', path)
+
+        room
+      end
+
+      def save(path, room)
+        contents = serialize(room)
+
+        store.write(path, contents)
+
+        room.send('id=', path)
+
+        room
+      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
+
+      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)
+        {
+          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
+        }
+      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)
+        {
+          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)
+        {
+          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]
+        )
+      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 }
+
+          case hash[:type]
+          when PICK_EVENT
+            deserialize_pick(hash, players:, front_office:)
+          when SKIP_EVENT
+            deserialize_skip(hash, front_office:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/basketball/app.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Services
+require_relative 'app/file_store'
+
+# Repositories
+require_relative 'app/coordinator_repository'
+require_relative 'app/room_repository'
+
+# Controllers
+require_relative 'app/coordinator_cli'
+require_relative 'app/room_cli'

data/lib/basketball/draft/assessment.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Draft
+    # An assessment is given to a front office when it needs the front office to make a pick.
+    # This is essentially just a data-transfer object to get information to a front office to make a pick.
+    class Assessment
+      attr_reader :drafted_players,
+                  :pick,
+                  :round_pick,
+                  :round,
+                  :undrafted_players
+
+      def initialize(
+        drafted_players:,
+        pick:,
+        round_pick:,
+        round:,
+        undrafted_players:
+      )
+        @drafted_players   = drafted_players
+        @pick              = pick
+        @round             = round
+        @round_pick        = round_pick
+        @undrafted_players = undrafted_players
+
+        freeze
+      end
+    end
+  end
+end

data/lib/basketball/draft/event.rb

@@ -2,8 +2,9 @@
 
 module Basketball
   module Draft
+    # Describes what all Room events have to have to be considered an "event".
     class Event < ValueObject
-      attr_reader_value :pick, :round, :round_pick, :front_office
+      value_reader :pick, :round, :round_pick, :front_office
 
       def initialize(front_office:, pick:, round:, round_pick:)
         super()
@@ -17,7 +18,7 @@ module Basketball
       end
 
       def to_s
-        "##{pick} overall (R#{round}:P#{round_pick}) by #{front_office}"
+        "[##{pick} R:#{round} P:#{round_pick}] #{front_office}"
       end
     end
   end