playoffs 1.0.0

data/lib/playoffs/tournament/roundable.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Playoffs
+  class Tournament
+    # Understands how to take a top-level series
+    module Roundable
+      extend T::Helpers
+      extend T::Sig
+
+      abstract!
+
+      sig { abstract.returns(T::Array[Round]) }
+      def rounds; end
+
+      sig { returns(T.nilable(Round)) }
+      def current_round
+        rounds.find(&:not_over?)
+      end
+
+      sig { returns(String) }
+      def print_rounds
+        rounds.map { |round, _number| [round.to_s, ''] }.join("\n")
+      end
+
+      private
+
+      sig { params(series: Series).returns(T::Array[Round]) }
+      def rounds_from_series(series)
+        group_by_round(series).values.reverse.map { |s| Round.new(s) }
+      end
+
+      sig do
+        params(
+          series: Series,
+          depth: Integer,
+          series_by_depth: T::Hash[Integer, T::Array[Series]]
+        ).returns(T::Hash[Integer, T::Array[Series]])
+      end
+      def group_by_round(series, depth = 0, series_by_depth = {})
+        series_by_depth[depth] ||= []
+
+        T.must(series_by_depth[depth]) << series
+
+        series.contestants.each do |contestant|
+          group_by_round(contestant, depth + 1, series_by_depth) if contestant.is_a?(Series)
+        end
+
+        series_by_depth
+      end
+    end
+  end
+end

data/lib/playoffs/tournament.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'tournament/bracketable'
+require_relative 'tournament/roundable'
+
+module Playoffs
+  # Models the construction and lifecycle of a set of series in the configured order
+  # leading to completion.
+  class Tournament
+    extend T::Sig
+    include Bracketable
+    include Roundable
+
+    sig { override.returns(Series) }
+    attr_reader :championship
+
+    sig { override.returns(T::Array[Round]) }
+    attr_reader :rounds
+
+    sig { params(championship: Series).void }
+    def initialize(championship)
+      @championship = T.let(championship, Series)
+      @rounds = T.let(rounds_from_series(championship), T::Array[Round])
+    end
+
+    sig { returns(String) }
+    def to_s
+      [
+        print_bracket,
+        '',
+        print_rounds
+      ].join("\n")
+    end
+
+    sig { returns(T.nilable(Series)) }
+    def up_next
+      current_round&.up_next
+    end
+
+    sig { returns(T::Boolean) }
+    def over?
+      !not_over?
+    end
+
+    sig { returns(T::Boolean) }
+    def not_over?
+      !up_next.nil?
+    end
+
+    sig { returns(T::Array[Round]) }
+    def not_over
+      rounds.select(&:not_over?)
+    end
+
+    sig { returns(T.nilable(Team)) }
+    def winner
+      championship.winner
+    end
+  end
+end

data/lib/playoffs/version.rb

@@ -0,0 +1,6 @@
+# typed: false
+# frozen_string_literal: true
+
+module Playoffs
+  VERSION = '1.0.0'
+end

data/lib/playoffs.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'primitive'
+require 'yaml'
+
+require_relative 'playoffs/basketball'
+require_relative 'playoffs/best_of'
+require_relative 'playoffs/cli'
+require_relative 'playoffs/contestant'
+require_relative 'playoffs/round'
+require_relative 'playoffs/series'
+require_relative 'playoffs/team'
+require_relative 'playoffs/tournament'
+
+module Playoffs
+  class IncorrectTeamCount < StandardError; end
+  class InvalidTeamError < StandardError; end
+  class InvalidTeamsError < StandardError; end
+  class NotEnoughTeamsError < StandardError; end
+  class RoundOverError < StandardError; end
+  class SeriesOverError < StandardError; end
+  class TeamsMustBeUniqueError < StandardError; end
+  class TournamentOverError < StandardError; end
+end

data/playoffs.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require './lib/playoffs/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'playoffs'
+  s.version     = Playoffs::VERSION
+  s.summary     = 'Underlying data structures to power a bracket-style tournament of teams/competitors.'
+
+  s.description = <<~DESC
+    I was looking to create a turn-based sports game which, inevitably, would include a playoffs simulator.
+    This library provides a few, easy-to-use APIs to create, simulate, and complete a team & series-based tournament with one clear winner.
+  DESC
+
+  s.authors     = ['Matthew Ruggio']
+  s.email       = ['mattruggio@icloud.com']
+  s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir      = 'exe'
+  s.executables = %w[playoffs]
+  s.homepage    = 'https://github.com/mattruggio/playoffs'
+  s.license     = 'MIT'
+  s.metadata    = {
+    'bug_tracker_uri' => 'https://github.com/mattruggio/playoffs/issues',
+    'changelog_uri' => 'https://github.com/mattruggio/playoffs/blob/main/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/playoffs',
+    'homepage_uri' => s.homepage,
+    'source_code_uri' => s.homepage,
+    'rubygems_mfa_required' => 'true'
+  }
+
+  s.required_ruby_version = '>= 3.2.1'
+
+  s.add_runtime_dependency('primitive')
+  s.add_runtime_dependency('sorbet-runtime')
+
+  s.add_development_dependency('bundler-audit')
+  s.add_development_dependency('guard-rspec')
+  s.add_development_dependency('pry')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rubocop')
+  s.add_development_dependency('rubocop-rake')
+  s.add_development_dependency('rubocop-rspec')
+  s.add_development_dependency('rubocop-sorbet')
+  s.add_development_dependency('simplecov')
+  s.add_development_dependency('simplecov-console')
+  s.add_development_dependency('sorbet')
+  s.add_development_dependency('tapioca')
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true