basketball 0.0.8 → 0.0.10

data/lib/basketball/app/coordinator_repository.rb

@@ -0,0 +1,114 @@
+# 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
+      include LeagueSerializable
+
+      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]),
+          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_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_results(results)
+        results.map do |result|
+          serialize_result(result)
+        end
+      end
+
+      # Deserialization
+
+      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/document_repository.rb

@@ -0,0 +1,67 @@
+# 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
+
+      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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Basketball
+  module App
+    # Knows how to flatten a League instance and rehydrate one from JSON and/or a Ruby hash.
+    class LeagueRepository < DocumentRepository
+      include LeagueSerializable
+
+      private
+
+      def from_h(hash)
+        deserialize_league(hash)
+      end
+
+      def to_h(league)
+        serialize_league(league)
+      end
+    end
+  end
+end

data/lib/basketball/app/league_serializable.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Basketball
+  module App
+    # Provides methods to serialize/deserialize a League object
+    module LeagueSerializable
+      # Serialization
+
+      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_player(player)
+        {
+          id: player.id,
+          overall: player.overall,
+          position: player.position&.code
+        }
+      end
+
+      # Deserialization
+
+      def deserialize_league(league_hash)
+        team_hashes = league_hash[:teams] || []
+        teams       = team_hashes.map { |team_hash| deserialize_team(team_hash) }
+
+        Org::League.new(teams:)
+      end
+
+      def deserialize_team(team_hash)
+        players = (team_hash[:players] || []).map { |player_hash| deserialize_player(player_hash) }
+
+        Org::Team.new(id: team_hash[:id], players:)
+      end
+
+      def deserialize_player(player_hash)
+        Org::Player.new(
+          id: player_hash[:id],
+          overall: player_hash[:overall],
+          position: Org::Position.new(player_hash[:position])
+        )
+      end
+    end
+  end
+end

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

@@ -1,30 +1,34 @@
 # 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 -r tmp/draft-league.json
+    class RoomCLI
       class PlayerNotFound < StandardError; end
 
-      attr_reader :opts, :serializer, :io
-
-      def initialize(args:, io: $stdout)
-        @io         = io
-        @serializer = RoomSerializer.new
-        @opts       = slop_parse(args)
+      attr_reader :opts,
+                  :io,
+                  :room_repository,
+                  :league_repository
+
+      def initialize(
+        args:,
+        io: $stdout,
+        room_repository: RoomRepository.new(FileStore.new),
+        league_repository: LeagueRepository.new(FileStore.new)
+      )
+        @io                = io
+        @opts              = slop_parse(args)
+        @room_repository   = room_repository
+        @league_repository = league_repository
 
         if opts[:input].to_s.empty? && opts[:output].to_s.empty?
           io.puts('Input and/or output paths are required.')
@@ -39,49 +43,54 @@ module Basketball
         room = load_room
 
         execute(room)
+        status(room)
+        write(room)
+        events(room)
+        league(room)
+        query(room)
+        rosters(room)
+
+        self
+      end
+
+      private
+
+      def rosters(room)
+        return if opts[:rosters].to_s.empty?
 
+        league_repository.save(opts[:rosters], room.league)
+      end
+
+      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.string  '-r', '--rosters',      'Path to write the resulting rosters (league) to.'
 
           o.on '-h', '--help', 'Print out help, like this is doing right now.' do
             io.puts(o)
@@ -104,33 +113,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 +145,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)
+        room_repository.load(opts[:input])
       end
 
       # rubocop:disable Metrics/AbcSize
@@ -195,14 +190,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 +210,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)
+        room_repository.save(output, room)
 
         io.puts
         io.puts("Draft written to: #{output}")