bagel 0.1.0

data/lib/bagel/graphic.rb

@@ -0,0 +1,23 @@
+require 'bagel/graphic/intro'
+require 'bagel/graphic/comment'
+
+require 'bagel/graphic/scoreboard'
+require 'bagel/graphic/scoreboard/context'
+require 'bagel/graphic/scoreboard/server'
+require 'bagel/graphic/scoreboard/name'
+require 'bagel/graphic/scoreboard/score'
+require 'bagel/graphic/scoreboard/sets'
+require 'bagel/graphic/scoreboard/games'
+require 'bagel/graphic/scoreboard/points'
+
+require 'bagel/graphic/stats'
+require 'bagel/graphic/stats/header'
+require 'bagel/graphic/stats/result'
+require 'bagel/graphic/stats/duration'
+require 'bagel/graphic/stats/stat'
+
+module Bagel
+  module Graphic
+    FILENAME_EXTENSION = '.png'
+  end
+end

data/lib/bagel/tennis/checker.rb

@@ -0,0 +1,100 @@
+module Bagel::Tennis
+  class Checker
+    BREAK_POINT = 'BREAK POINT'
+    SET_POINT = 'SET POINT'
+    MATCH_POINT = 'MATCH POINT'
+
+    MINIMUM_POINTS_TO_WIN_GAME = 4
+    MINIMUM_POINTS_TO_WIN_TIEBREAK = 7
+
+    MINIMUM_GAMES_TO_WIN_SET = 6
+    SETS_TO_WIN_MATCH = 2
+
+    TIEBREAK_AT = [ MINIMUM_GAMES_TO_WIN_SET, MINIMUM_GAMES_TO_WIN_SET ]
+
+    private attr_reader :sets, :points, :server, :receiver
+
+    def initialize(sets:, points:, server:)
+      @sets, @points, @server = sets, points, server
+      @receiver = Player.opponent(server)
+    end
+
+    def break_point?
+      next_point_wins_game?(receiver)
+    end
+
+    def set_point?
+      next_point_wins_set?(server) || next_point_wins_set?(receiver)
+    end
+
+    def match_point?
+      next_point_wins_match?(server) || next_point_wins_match?(receiver)
+    end
+
+    def tiebreak?
+      sets.last == Tennis::Checker::TIEBREAK_AT
+    end
+
+    private
+
+    def points_for(player)
+      points[Player.index(player)]
+    end
+
+    def games_for(player, set)
+      set[Player.index(player)]
+    end
+
+    def next_point_wins_game?(player)
+      will_have_required_points?(player) && will_have_point_margin?(player)
+    end
+
+    def next_point_wins_set?(player)
+      next_point_wins_game?(player) && next_game_wins_set?(player)
+    end
+
+    def next_game_wins_set?(player)
+      will_have_required_games?(sets.last, player) && will_have_game_margin?(sets.last, player)
+    end
+
+    def next_point_wins_match?(player)
+      next_point_wins_set?(player) && next_set_wins_match?(player)
+    end
+
+    def next_set_wins_match?(player)
+      sets_won(player) + 1 == SETS_TO_WIN_MATCH
+    end
+
+    def will_have_required_points?(player)
+      points_for(player) + 1 >= (tiebreak? ? MINIMUM_POINTS_TO_WIN_TIEBREAK : MINIMUM_POINTS_TO_WIN_GAME)
+    end
+
+    def will_have_required_games?(set, player)
+      games_for(player, set) + 1 >= MINIMUM_GAMES_TO_WIN_SET
+    end
+
+    def will_have_point_margin?(player)
+      points_for(player) - points_for(Player.opponent(player)) >= 1
+    end
+
+    def will_have_game_margin?(set, player)
+      games_for(player, set) - games_for(Player.opponent(player), set) >= 1
+    end
+
+    def sets_won(player)
+      sets.count { |set| won_set?(set, player) }
+    end
+
+    def won_set?(set, player)
+      enough_games_won?(player, set) && more_games_than_opponent?(player, set)
+    end
+
+    def enough_games_won?(player, set)
+      games_for(player, set) >= MINIMUM_GAMES_TO_WIN_SET
+    end
+
+    def more_games_than_opponent?(player, set)
+      games_for(player, set) > games_for(Player.opponent(player), set)
+    end
+  end
+end

data/lib/bagel/tennis/outcome.rb

@@ -0,0 +1,48 @@
+module Bagel::Tennis
+  class Outcome
+    SERVE = 'S'
+    FOREHAND = 'FH'
+    BACKHAND = 'BH'
+
+    WINNER = 'W'
+    FORCED_ERROR = 'FE'
+    UNFORCED_ERROR = 'UE'
+
+    private attr_reader :winner, :reason, :shot, :net
+
+    def initialize(winner:, reason:, shot:, net: nil)
+      @winner = winner
+      @reason = reason
+      @shot = shot
+      @net = net
+    end
+
+    def ace?
+      winner? && shot == SERVE
+    end
+
+    def winner?
+      reason == WINNER
+    end
+
+    def unforced_error?
+      reason == UNFORCED_ERROR
+    end
+
+    def p1_won?
+      winner == Player.ONE
+    end
+
+    def p2_won?
+      winner == Player.TWO
+    end
+
+    def p1_net_point?
+      net && !net[Player.index(Player.ONE)].nil?
+    end
+
+    def p2_net_point?
+      net && !net[Player.index(Player.TWO)].nil?
+    end
+  end
+end

data/lib/bagel/tennis/player.rb

@@ -0,0 +1,22 @@
+module Bagel::Tennis
+  class Player
+    PLAYER_ONE = 1
+    PLAYER_TWO = 2
+
+    def self.ONE
+      PLAYER_ONE
+    end
+
+    def self.TWO
+      PLAYER_TWO
+    end
+
+    def self.index(id)
+      id - 1
+    end
+
+    def self.opponent(id)
+      id == PLAYER_ONE ? PLAYER_TWO : PLAYER_ONE
+    end
+  end
+end

data/lib/bagel/tennis/point.rb

@@ -0,0 +1,17 @@
+module Bagel::Tennis
+  class Point
+    extend Forwardable
+
+    def_delegators :@timeframe, :start, :finish
+    def_delegators :@score, :break_point?, :set_point?, :match_point?
+    def_delegators :@serve, :server?, :no_faults?, :second_serve?, :double_fault?, :p1_serve?, :p2_serve?
+    def_delegators :@outcome, :ace?, :p1_won?, :p2_won?, :winner?, :unforced_error?, :p1_net_point?, :p2_net_point?
+
+    def initialize(timeframe:, score:, serve:, outcome:)
+      @timeframe = timeframe
+      @score = score
+      @serve = serve
+      @outcome = outcome
+    end
+  end
+end

data/lib/bagel/tennis/score.rb

@@ -0,0 +1,68 @@
+module Bagel::Tennis
+  class Score
+    attr_reader :sets, :points
+    private attr_reader :server, :checker
+
+    def initialize(sets:, points: nil, server: nil)
+      @sets, @points = sets, points
+      @server = server
+      @checker = Tennis::Checker.new(sets: sets, points: points, server: server)
+    end
+
+    def id
+      id_parts.map { |i| i.to_s.rjust(2, '0') }.join('-')
+    end
+
+    def context
+      return nil if server.nil?
+      return Tennis::Checker::MATCH_POINT if match_point?
+      return Tennis::Checker::SET_POINT if set_point?
+      return Tennis::Checker::BREAK_POINT if break_point?
+    end
+
+    def server?(player_id)
+      server == player_id
+    end
+
+    def set_number
+      sets.count
+    end
+
+    def set_score
+      sets.last
+    end
+
+    def break_point?
+      checker.break_point?
+    end
+
+    def set_point?
+      checker.set_point?
+    end
+
+    def match_point?
+      checker.match_point?
+    end
+
+    def tiebreak?
+      checker.tiebreak?
+    end
+
+    private
+
+    def id_parts
+      parts = [ set_number ]
+      parts << game_number if points
+      parts << point_number if points
+      parts
+    end
+
+    def game_number
+      sets.last.sum + 1
+    end
+
+    def point_number
+      points.sum + 1
+    end
+  end
+end

data/lib/bagel/tennis/scoring.rb

@@ -0,0 +1,26 @@
+module Bagel::Tennis
+  module Scoring
+    LOVE = '0'
+    FIFTEEN = '15'
+    THIRTY = '30'
+    FORTY = '40'
+    FORTY_BLANK = ''
+    ADVANTAGE = 'A'
+
+    def self.point_call(player, opponent, tiebreak=false)
+      return player.to_s if tiebreak
+
+      return LOVE if player == 0
+      return FIFTEEN if player == 1
+      return THIRTY if player == 2
+
+      if opponent < 3 || player == opponent
+        FORTY
+      elsif player < opponent
+        FORTY_BLANK
+      else
+        ADVANTAGE
+      end
+    end
+  end
+end

data/lib/bagel/tennis/serve.rb

@@ -0,0 +1,36 @@
+module Bagel::Tennis
+  class Serve
+    NO_FAULT = 0
+    DOUBLE_FAULT = 2
+
+    private attr_reader :server, :faults
+
+    def initialize(server:, faults:)
+      @server, @faults = server, faults
+    end
+
+    def server?(player)
+      server == player
+    end
+
+    def no_faults?
+      faults == NO_FAULT
+    end
+
+    def second_serve?
+      faults > NO_FAULT
+    end
+
+    def double_fault?
+      faults == DOUBLE_FAULT
+    end
+
+    def p1_serve?
+      server?(Player.ONE)
+    end
+
+    def p2_serve?
+      server?(Player.TWO)
+    end
+  end
+end

data/lib/bagel/tennis/stats/aces.rb

@@ -0,0 +1,28 @@
+module Bagel::Tennis::Stats
+  class Aces < Stat
+    private attr_reader :p1, :p2
+
+    def name
+      'ACES'
+    end
+
+    def values
+      [ p1, p2 ]
+    end
+
+    def superior
+      [ p1 > p2, p2 > p1 ]
+    end
+
+    private
+
+    def calculate
+      @p1 = aces(Player.ONE)
+      @p2 = aces(Player.TWO)
+    end
+
+    def aces(player)
+      points.count { |point| point.server?(player) && point.ace? }
+    end
+  end
+end

data/lib/bagel/tennis/stats/break_points_won.rb

@@ -0,0 +1,33 @@
+module Bagel::Tennis::Stats
+  class BreakPointsWon < Stat
+    private attr_reader :p1_label, :p2_label, :p1_percentage, :p2_percentage
+
+    def name
+      'BREAK POINTS WON'
+    end
+
+    def values
+      [ p1_label, p2_label ]
+    end
+
+    def superior
+      [ p1_percentage > p2_percentage, p2_percentage > p1_percentage ]
+    end
+
+    private
+
+    def calculate
+      p1_break_points = points.select(&:break_point?).select(&:p2_serve?)
+      p2_break_points = points.select(&:break_point?).select(&:p1_serve?)
+
+      p1_break_points_won = p1_break_points.select(&:p1_won?)
+      p2_break_points_won = p2_break_points.select(&:p2_won?)
+
+      @p1_percentage = percentage(p1_break_points.count, p1_break_points_won.count)
+      @p2_percentage = percentage(p2_break_points.count, p2_break_points_won.count)
+
+      @p1_label = label(p1_break_points.count, p1_break_points_won.count, p1_percentage)
+      @p2_label = label(p2_break_points.count, p2_break_points_won.count, p2_percentage)
+    end
+  end
+end

data/lib/bagel/tennis/stats/double_faults.rb

@@ -0,0 +1,28 @@
+module Bagel::Tennis::Stats
+  class DoubleFaults < Stat
+    private attr_reader :p1, :p2
+
+    def name
+      'DOUBLE FAULTS'
+    end
+
+    def values
+      [ p1, p2 ]
+    end
+
+    def superior
+      [ p1 < p2, p2 < p1 ]
+    end
+
+    private
+
+    def calculate
+      @p1 = double_faults(Player.ONE)
+      @p2 = double_faults(Player.TWO)
+    end
+
+    def double_faults(player)
+      points.count { |point| point.server?(player) && point.double_fault? }
+    end
+  end
+end