basketball 0.0.9 → 0.0.11

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

@@ -4,7 +4,15 @@ 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
 
@@ -17,6 +25,14 @@ module Basketball
 
         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,99 @@
+# frozen_string_literal: true
+
+module Basketball
+  module App
+    # Provides methods to serialize/deserialize a League object
+    module LeagueSerializable
+      # 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_cli.rb

@@ -3,23 +3,27 @@
 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
+    #   exe/basketball-draft-room -o tmp/draft.json
+    #   exe/basketball-draft-room -i tmp/draft.json -o tmp/draft-wip.json -s 26 -p P-5,P-10 -l 10
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -x 2
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -g -l 10
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -s 30 -l 10
+    #   exe/basketball-draft-room -i tmp/draft-wip.json -ate
     class RoomCLI
       class PlayerNotFound < StandardError; end
 
-      attr_reader :opts, :io, :repository
+      attr_reader :opts,
+                  :io,
+                  :room_repository
 
-      def initialize(args:, io: $stdout)
-        @io         = io
-        @opts       = slop_parse(args)
-        @repository = RoomRepository.new
+      def initialize(
+        args:,
+        io: $stdout,
+        room_repository: RoomRepository.new(FileStore.new)
+      )
+        @io                = io
+        @opts              = slop_parse(args)
+        @room_repository   = room_repository
 
         if opts[:input].to_s.empty? && opts[:output].to_s.empty?
           io.puts('Input and/or output paths are required.')
@@ -37,7 +41,7 @@ module Basketball
         status(room)
         write(room)
         events(room)
-        league(room)
+        teams(room)
         query(room)
 
         self
@@ -63,15 +67,15 @@ module Basketball
 
       def slop_parse(args)
         Slop.parse(args) do |o|
-          o.banner = 'Usage: basketball-room [options] ...'
+          o.banner = 'Usage: basketball-draft-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 '-l', '--list',         'List the top rated available players (default is 0).', default: 0
+          o.bool    '-t', '--teams',        '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
 
@@ -112,11 +116,11 @@ module Basketball
         Draft::Room.new(rounds: 12, players:, front_offices:)
       end
 
-      def league(room)
-        return unless opts[:league]
+      def teams(room)
+        return unless opts[:teams]
 
         io.puts
-        io.puts(room.league)
+        io.puts(room.teams)
       end
 
       def events(room)
@@ -129,19 +133,19 @@ module Basketball
       end
 
       def query(room)
-        top = opts[:top]
+        list = opts[:list]
 
-        return if top <= 0
+        return if list <= 0
 
-        players = room.undrafted_players.sort_by(&:overall).reverse.take(opts[:top])
+        players = room.undrafted_players.sort_by(&:overall).reverse.take(opts[:list])
 
         io.puts
-        io.puts("Top #{top} available players")
+        io.puts("Top #{list} available players")
         io.puts(players)
       end
 
       def read
-        repository.load(opts[:input])
+        room_repository.load(opts[:input])
       end
 
       # rubocop:disable Metrics/AbcSize
@@ -200,7 +204,7 @@ module Basketball
       def write(room)
         output = output_default_to_input
 
-        repository.save(output, room)
+        room_repository.save(output, room)
 
         io.puts
         io.puts("Draft written to: #{output}")

data/lib/basketball/app/room_repository.rb

@@ -3,54 +3,14 @@
 module Basketball
   module App
     # Can load and save Room objects to JSON files.
-    class RoomRepository
+    class RoomRepository < DocumentRepository
       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])

data/lib/basketball/app.rb

@@ -1,10 +1,18 @@
 # frozen_string_literal: true
 
-# Services
+# Stores
 require_relative 'app/file_store'
+require_relative 'app/in_memory_store'
 
-# Repositories
+# Serialization
+require_relative 'app/league_serializable'
+
+# Repositories / Common
+require_relative 'app/document_repository'
+
+# Repositories / Implementations
 require_relative 'app/coordinator_repository'
+require_relative 'app/league_repository'
 require_relative 'app/room_repository'
 
 # Controllers

data/lib/basketball/draft/pick.rb

@@ -20,13 +20,6 @@ module Basketball
       def to_s
         "#{super} #{auto ? 'auto-' : ''}picked #{player}"
       end
-
-      def ==(other)
-        super &&
-          player == other.player &&
-          auto == other.auto
-      end
-      alias eql? ==
     end
   end
 end

data/lib/basketball/draft/room.rb

@@ -3,7 +3,7 @@
 module Basketball
   module Draft
     # Main pick-by-pick iterator object which will round-robin rotate team selections.
-    class Room
+    class Room < Entity
       class AlreadyPickedError < StandardError; end
       class EndOfDraftError < StandardError; end
       class EventOutOfOrderError < StandardError; end
@@ -12,9 +12,11 @@ module Basketball
       class UnknownFrontOfficeError < StandardError; end
       class UnknownPlayerError < StandardError; end
 
-      attr_reader :rounds, :players, :front_offices, :events, :id
+      attr_reader :rounds, :players, :front_offices, :events
 
       def initialize(front_offices:, rounds:, players: [], events: [])
+        super()
+
         raise InvalidRoundsError, "#{rounds} should be a positive number" unless rounds.positive?
 
         @rounds        = rounds
@@ -28,17 +30,15 @@ module Basketball
       end
 
       # This method will return a materialized list of teams and their selections.
-      def league
-        Org::League.new.tap do |league|
-          front_offices.each do |front_office|
-            team = Org::Team.new(id: front_office.id)
-
-            league.register!(team)
+      def teams
+        front_offices.each_with_object([]) do |front_office, memo|
+          team = Org::Team.new(id: front_office.id)
 
-            drafted_players(front_office).each do |player|
-              league.sign!(player:, team:)
-            end
+          drafted_players(front_office).each do |player|
+            team.sign!(player)
           end
+
+          memo << team
         end
       end
 
@@ -157,8 +157,6 @@ module Basketball
 
       private
 
-      attr_writer :id
-
       def player_events
         events.select { |e| e.respond_to?(:player) }
       end

data/lib/basketball/entity.rb

@@ -4,16 +4,11 @@ module Basketball
   # Base class for uniquely identifiable classes.  Subclasses are simply based on a string-based ID
   # and comparison/sorting/equality will be done in a case-insensitive manner.
   class Entity
-    extend Forwardable
     include Comparable
 
     attr_reader :id
 
-    def_delegators :id, :to_s
-
-    def initialize(id)
-      raise ArgumentError, 'id is required' if id.to_s.empty?
-
+    def initialize(id = nil)
       @id = id
     end
 
@@ -30,8 +25,16 @@ module Basketball
       comparable_id.hash
     end
 
+    def to_s
+      id.to_s
+    end
+
     def comparable_id
       id.to_s.upcase
     end
+
+    private
+
+    attr_writer :id
   end
 end

data/lib/basketball/org/conference.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # A collection of divisions, teams, and players.
+    class Conference < Entity
+      include HasDivisions
+
+      attr_reader :divisions
+
+      def initialize(id:, divisions: [])
+        super(id)
+
+        @divisions = []
+
+        divisions.each { |d| register_division!(d) }
+
+        freeze
+      end
+
+      def to_s
+        ([super] + divisions.map(&:to_s)).join("\n")
+      end
+
+      def teams
+        divisions.flat_map(&:teams)
+      end
+
+      def players
+        divisions.flat_map(&:players)
+      end
+
+      private
+
+      def register_division!(division)
+        raise ArgumentError, 'division is required' unless division
+        raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
+
+        assert_teams_are_not_already_registered(division.teams)
+
+        divisions << division
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/org/division.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # A collection of teams and players.
+    class Division < Entity
+      include HasTeams
+
+      attr_reader :teams
+
+      def initialize(id:, teams: [])
+        super(id)
+
+        @teams = []
+
+        teams.each { |t| register_team!(t) }
+
+        freeze
+      end
+
+      def to_s
+        ([super] + teams.map(&:to_s)).join("\n")
+      end
+
+      def players
+        teams.flat_map(&:players)
+      end
+
+      private
+
+      def register_team!(team)
+        raise ArgumentError, 'team is required' unless team
+        raise TeamAlreadyRegisteredError, "#{team} already registered" if team?(team)
+
+        assert_players_are_not_already_signed(team.players)
+
+        teams << team
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/org/has_divisions.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Helper methods for objects that can be composed of divisions which are also composed of teams
+    # and players.
+    module HasDivisions
+      include HasTeams
+
+      def division?(division)
+        divisions.include?(division)
+      end
+
+      private
+
+      def assert_divisions_are_not_already_registered(divisions)
+        divisions.each do |division|
+          raise DivisionAlreadyRegisteredError, "#{division} already registered" if division?(division)
+
+          assert_teams_are_not_already_registered(division.teams)
+        end
+      end
+    end
+  end
+end

data/lib/basketball/org/has_players.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Helper methods for objects that can be composed of players.
+    module HasPlayers
+      def player?(player)
+        players.include?(player)
+      end
+
+      private
+
+      def assert_players_are_not_already_signed(players)
+        players.each do |player|
+          raise PlayerAlreadySignedError, "#{player} already registered" if player?(player)
+        end
+      end
+    end
+  end
+end