basketball 0.0.7 → 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/app/room_cli.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+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
+    class RoomCLI
+      class PlayerNotFound < StandardError; end
+
+      attr_reader :opts, :io, :repository
+
+      def initialize(args:, io: $stdout)
+        @io         = io
+        @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.')
+
+          exit
+        end
+
+        freeze
+      end
+
+      def invoke!
+        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
+          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 #{round} pick #{round_pick} for #{front_office}")
+        end
+      end
+
+      def slop_parse(args)
+        Slop.parse(args) do |o|
+          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  '-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 '-x', '--skip',         'Number of picks to skip (default is 0).', default: 0
+          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)
+            exit
+          end
+        end.to_h
+      end
+
+      def load_room
+        if opts[:input].to_s.empty?
+          io.puts('Input path was not provided, generating fresh front_offices and players')
+
+          generate_draft
+        else
+          io.puts("Draft loaded from: #{opts[:input]}")
+
+          read
+        end
+      end
+
+      def generate_draft
+        front_offices = 30.times.map do |i|
+          Draft::FrontOffice.new(
+            id: "T-#{i + 1}"
+          )
+        end
+
+        players = 450.times.map do |i|
+          Org::Player.new(
+            id: "P-#{i + 1}",
+            overall: (20..100).to_a.sample,
+            position: Org::Position.random
+          )
+        end
+
+        Draft::Room.new(rounds: 12, players:, front_offices:)
+      end
+
+      def league(room)
+        return unless opts[:league]
+
+        io.puts
+        io.puts(room.league)
+      end
+
+      def events(room)
+        return unless opts[:events]
+
+        io.puts
+        io.puts('Event Log')
+
+        puts room.events
+      end
+
+      def query(room)
+        top = opts[:top]
+
+        return if top <= 0
+
+        players = room.undrafted_players.sort_by(&:overall).reverse.take(opts[:top])
+
+        io.puts
+        io.puts("Top #{top} available players")
+        io.puts(players)
+      end
+
+      def read
+        repository.load(opts[:input])
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def execute(room)
+        event_count = 0
+
+        io.puts
+        io.puts('New Events')
+
+        (opts[:picks] || []).each do |id|
+          break if room.done?
+
+          player = room.players.find { |p| p.id == id.to_s.upcase }
+
+          raise PlayerNotFound, "player not found by id: #{id}" unless player
+
+          event = room.pick!(player)
+
+          io.puts(event)
+
+          event_count += 1
+        end
+
+        opts[:skip].times do
+          event = room.skip!
+
+          io.puts(event)
+
+          event_count += 1
+        end
+
+        opts[:simulate].times do
+          room.sim!
+
+          event_count += 1
+        end
+
+        if opts[:simulate_all]
+          room.sim_rest! do |event|
+            io.puts(event)
+
+            event_count += 1
+          end
+        end
+
+        io.puts("Generated #{event_count} new event(s)")
+
+        nil
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def output_default_to_input
+        opts[:output].to_s.empty? ? opts[:input] : opts[:output]
+      end
+
+      def write(room)
+        output = output_default_to_input
+
+        repository.save(output, room)
+
+        io.puts
+        io.puts("Draft written to: #{output}")
+
+        nil
+      end
+    end
+  end
+end

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/{drafting → draft}/event.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 module Basketball
-  module Drafting
+  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