tennis 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 071d8da8d7b39b88163c917635cff96a913bafcd
-  data.tar.gz: 63252be0e608ee1d0f597d36c0333d24b8256606
+  metadata.gz: ce621f74414d103564e2bcc239a788d487c912ee
+  data.tar.gz: 7fb8ec8e853cf6b05f775aed1ad42a95fe982d34
 SHA512:
-  metadata.gz: e9a0401551a28c70dd2cd3106196c3ec3d8723ff603ed5ef7250c077e3d76c41f74747a698594fb58929c41c154cdfdb92c880b08814b639569732b4457e2d67
-  data.tar.gz: 66c54ec51b6a0f6520d4caa602c3eacdd950eb43736c749da85a4f294cbca106b820cf8c35a4f9d0faa209be8cd24d2d5337f369b5ac61cc59186b4198986399
+  metadata.gz: e693fb0265a8e3934b631971f86a57320003ac1fe82863ad840478cc3ab57cf5107f98e9d314483ee8b6a5fe59338ea45e2723b7d7a06f2752e94d35f1974ec4
+  data.tar.gz: f69de2817fda3554545f98af969f1dbf6d2dbceafff7f43c3b6109d0adbb3fde5889bc4ad870ad8a893ca8b7966dd8698ff76e9fe8f1277d63ad77717796ee7d

data/Makefile

@@ -1,5 +1,5 @@
 
-VERSION=0.1.6
+VERSION=0.2.0
 
 all:
 	rake spec

data/lib/tennis/version.rb

@@ -1,3 +1,3 @@
 class Tennis
-	VERSION = "0.1.7"
+	VERSION = "0.2.0"
 end

data/lib/tennis.rb

@@ -4,180 +4,78 @@ class Tennis
   # player 1 is the home player(0) , player 2 is the away player(1)
   # winner is either 0 or 1
   # points is an array: [points for 0 , points for 1]
-  # sets_lost is an array: [sets lost by 0, sets lost by 1]
-  # games_lost is an array: [games won by 0, games won by 1]
+  # sets_won/lost is an array: [sets won/lost by 0, sets won/lost by 1]
+  # games_won/lost is an array: [games won/lost by 0, games won/lost by 1]
 
-  attr_reader :winner, :points, :sets_lost, :games_lost
+  attr_reader :winner, :sets_won, :sets_lost, :games_won, :games_lost
 
-  def initialize(scores)
+  def initialize(score)
     # dfh -> default win for home player(0)
     # dfa -> default win for away player(1)
-    @winner = :default
-    @scores = validate_score(scores)
-    @winner = match_winner if @winner == :default
-    @points = match_points
-    unless @scores.is_a? String
-      @sets_lost = count_sets_lost
-      @games_lost = count_games_lost
-    end
+    process_score(score)
   end
 
   # to_s
   # return the score in string format
   def to_s
-    (0...@scores.length).step(2).map{ |i| [@scores[i], @scores[i+1]].join('-') }.join(', ')
+    @score.map{|set| set.join('-') }.join(', ')
   end
 
   # flip score ( P1-P2 to P2-P1)
   # returns the flipped score as a string
   def flipped
-    (0...@scores.length).step(2).map{ |i| [@scores[i+1], @scores[i]].join('-') }.join(', ')
+    @score.map{|set| set.reverse.join('-') }.join(', ')
   end
 
   private
 
-  # helper method: to check score validation
-  def validate_score(scores_string)
-    set_scores = scores_string.split(/[-,,]/).map(&:to_i)
-    if set_scores == [0]
-      # checks bad default string value reported
-      @winner = (0 if scores == 'dfh') || (1 if scores == 'dfa') || :error
-      scores_string
-    else
-      # check blank input ''
-      validation_1 = set_scores.any? { |score| score.nil? }
-      # to check if score for only 1 set has been input
-      validation_2 = set_scores.length == 2
-      # to check if any input > 7
-      validation_3 = set_scores.any? { |score| score > 7 }
-      # to check if one of the input is 7 and the other is not 6
-      # bad tie break input
-      validation_4 = false
-      set_scores.each_slice(2).each { |r| validation_4 = true if r.any? { |score| score == 7 } && !r.any? { |score| score == 6 || score == 5 } }
-      @winner = :error if validation_1 || validation_2 || validation_3 || validation_4
-      # if set score is not complete eg: 4-6,7-6,4-1
-      set_scores.each_slice(2).each {|r| @winner = :incomplete_match if r[0] < 6 && r[1] < 6 } unless @winner == :error
-      set_scores
-    end
-  end
-
-  # returns who won the match
-  # :incomplete_match (bad input/incomplete match)
-  # :error (bad input for sure)
-  # 0 (player-1 won)
-  # 1 (player-2 won)
-  def match_winner
-    @scores.length == 4 ? two_sets : three_sets
-  end
-
-  # returns an array of points
-  # returns (points_player_1 , points_player_2)
-  # returns (0,0) for bad input
-  def match_points
-    return [0, 0] if @winner == :error
-    return [@scores == 'dfh' ? 12 : 0, @scores == 'dfa' ? 12 : 0] if @scores.is_a? String
-    @winner == 0 || @winner == 1 ? complete_match_points : incomplete_match_points
-  end
-
-  # returns the number of sets lost by each player
-  def count_sets_lost
-    sets = [0, 0]
-    (0...@scores.length).step(2).each do |i|
-      @scores[i] > @scores[i + 1] ? sets[1] += 1 : sets[0] += 1
-    end
-    sets
-  end
-
-  # returns the number of won by each player
-  def count_games_lost
-    games = [0, 0]
-    (0...@scores.length).step(2).each do |i|
-      games[0] += @scores[i + 1]
-      games[1] += @scores[i]
+  def process_score(score, best_of=3)
+    begin
+      sets = score.split(/,/)
+      # only take 2 to 5 sets
+      raise "invalid number of sets" unless (2..best_of).cover? sets.length
+      score_plus_winner = map_scores_winners(sets)
+      @set_winners = score_plus_winner.map{ |sw| sw[1] }
+      home = @set_winners.count(0)
+      away = @set_winners.count(1)
+      raise "nobody won" if home + away == 0
+      @winner = home > away ? 0 : away > home ? 1 : raise("no winner")
+      # sets won and lost
+      @sets_won, @sets_lost = [[home, away], [away, home]]
+      # score array
+      @score = score_plus_winner.map{ |sw| sw[0] }
+      @games_won = @score.transpose.map{ |games| games.inject{ |sum,x| sum + x } }
+      @games_lost = @games_won.reverse
+      # FIXME this is the only thing that assumes 3 sets
+      raise "too many sets" if @set_winners[0] == @set_winners[1] and sets.size > 2
+    rescue => e
+      raise ArgumentError, "Invalid score '#{score}': #{e}"
     end
-    games
   end
 
-  # returns the number of sets won by each player
-  def sets_won
-    sets = [0, 0]
-    (0...@scores.length).step(2).each do |i|
-      @scores[0 + i] > @scores[1 + i] ? sets[0] += 1 : sets[1] += 1
+  # return an array of scores and winners for each set
+  def map_scores_winners(sets)
+    sets.map do |set|
+      set.strip!
+      games = set.split(/-/).map(&:to_i)
+      raise "uneven games in set '#{set}'" unless games.length == 2
+      h, a = games
+      sw = set_winner(h, a)
+      raise "no valid winner in set '#{set}'" unless sw
+      [games, sw]
     end
-    sets
   end
 
-  # returns the number of won by each player
-  def games_won
-    games = [0, 0]
-    (0...@scores.length).step(2).each do |i|
-      games[0] += @scores[0 + i]
-      games[1] += @scores[1 + i]
-    end
-    games
+  # determine the set winner for home and away, or else return nil
+  def set_winner(h, a)
+    # basic range check
+    return nil if h > 7 or a > 7 or h < 0 or a < 0
+    # game went to 7
+    return 0 if h == 7 and [5,6].include?(a)
+    return 1 if a == 7 and [5,6].include?(h)
+    # there has to be one winner, to 6
+    return nil unless (h == 6 and h > a + 1) or (a == 6 and a > h + 1)
+    h > a ? 0 : 1
   end
 
-  # helper method: called by RESULT method for valid matches with 2 sets
-  def two_sets
-    set_results = []
-    (0...@scores.length).step(2).each do |i|
-      # tie breaker (assuming a 7 point tie breaker) or a 7-5 scores
-      if @scores[i] == 7 || @scores[i + 1] == 7
-        set_results << (@scores[i] == 7 ? 0 : 1)
-        # regular set victory - 6 games with a margin of 2
-      else
-        return :incomplete_match if ( @scores[i] - @scores[i + 1] ).abs < 2
-        set_results << (@scores[i] == 6 ? 0 : 1)
-      end
-    end
-    # incomplete match e.g: 6-4,5-3
-    (set_results[0] if set_results[0] == set_results[1]) || :incomplete_match
-  end
-
-  # helper method: called by RESULT method for valid matches with 3 sets
-  def three_sets
-    set_results = []
-    (0...@scores.length).step(2).each do |i|
-      # tie breaker (assuming a 7 point tie breaker) or a 7-5 score
-      if @scores[i] == 7 || @scores[i + 1] == 7
-        set_results << (@scores[i] == 7 ? 0 : 1)
-        # regular set victory - 6 games with a margin of 2
-      else
-        return :incomplete_match if (@scores[i] - @scores[i + 1]).abs < 2
-        set_results << (@scores[i] == 6 ? 0 : 1)
-      end
-    end
-    # checks if the result has been decided in the first 2 sets
-    # but the 3rd set is also present in the input
-    return :error if set_results[0] == set_results[1]
-    set_results.count(0) == 2 ? 0 : 1
-  end
-
-  # helper method: called by POINTS for complete matches
-  def complete_match_points
-    points = [0, 0]
-    points[@winner] = (@scores.length == 6) ? 12 : 14
-    runner_up = 1 - @winner
-    runner_up_points = player_points(runner_up)
-    points[runner_up] = runner_up_points < 8 ? runner_up_points : 8
-    points
-  end
-
-  # helper method: called by POINTS for incomplete matches
-  def incomplete_match_points
-    points = [0, 0]
-    player_1_points = player_points(0)
-    player_2_points = player_points(1)
-    points[0] = player_1_points < 10 ? player_1_points : 10
-    points[1] = player_2_points < 10 ? player_2_points : 10
-    points
-  end
-
-  # helper method: returns the POINTS of a player given the player number
-  def player_points(player)
-    player_scores = []
-    @scores.each_with_index { |score, index| (player_scores << score; player += 2) if index == (player) }
-    player_scores = player_scores.sort! { |x, y| y <=> x }
-    player_scores[0] + player_scores[1]
-  end
 end

data/spec/tennis_spec.rb

@@ -28,90 +28,44 @@ describe Tennis, "#scores" do
 	end
 
 	it "reports incomplete match score (set 1-1)" do
-		score = Tennis.new("6-4,4-6")
-		expect(score.winner).to eq :incomplete_match
+		expect { Tennis.new("6-4,4-6") }.to raise_error
 	end
 
 	it "reports incomplete match score (set incomplete)" do
-		score = Tennis.new("6-4,4-5")
-		expect(score.winner).to eq :incomplete_match
+		expect { Tennis.new("6-4,4-5") }.to raise_error
 	end
 
 	it "checks invalid score: difference in games won < 2" do
-		score = Tennis.new("6-5,4-6,7-6")
-		expect(score.winner).to eq :incomplete_match
+		expect { Tennis.new("6-5,4-6,7-6") }.to raise_error
 	end
 
 	it "checks invalid score: only 1 set input" do
-		score = Tennis.new("6-4")
-		expect(score.winner).to eq :error
+		expect {  Tennis.new("6-4") }.to raise_error
 	end
 
 	it "checks invalid score: winner decided in first 2 sets but 3rd set input" do
-		score = Tennis.new("6-4,6-4,4-6")
-		expect(score.winner).to eq :error
+		expect {  Tennis.new("6-4,6-4,4-6") }.to raise_error
 	end
 
 	it "checks invalid score: bad input for tie break" do
-		score = Tennis.new("7-0,4-6,6-2")
-		expect(score.winner).to eq :error
+		expect {  Tennis.new("7-0,4-6,6-2") }.to raise_error
 	end
 
 	it "checks invalid score: no score > 7" do
-		score = Tennis.new("8-4,2-6,6-1")
-		expect(score.winner).to eq :error
+		expect {  Tennis.new("8-4,2-6,6-1") }.to raise_error
 	end
 
-	it "checks invalid score: blank score '' " do
-		score = Tennis.new("")
-		expect(score.winner).to eq :error
+	it "checks invalid score: blank score ''" do
+		expect { Tennis.new("") }.to raise_error
 	end
 
 	it "finds the winner properly in scores with 7-5" do
 		score = Tennis.new("3-6,5-7")
 		expect(score.winner).to eq 1
 	end
-end
-
-describe Tennis, "#points" do
-	it "returns 12 points in a three set win in a complete match" do
-		score = Tennis.new("6-4, 4-6, 6-4")
-		expect(score.points).to eq [12,8]
-	end
-
-	it "returns 14 points in two set win in a complete match" do
-		score = Tennis.new("4-6, 4-6")
-		expect(score.points).to eq [8,14]
-	end
 
-	it "returns a max of 8 points for the runners up in a complete match" do
-		score = Tennis.new("4-6, 6-2, 3-6")
-		expect(score.points).to eq [8,12]
-	end
-
-	it "return a max of 10 points for each player in an incomplete match" do
-		score = Tennis.new("7-6,6-7")
-		expect(score.points).to eq [10,10]
-	end
-
-	it "return a max of 10 points for each player in an incomplete match" do
-		score = Tennis.new("7-6,4-6,4-1")
-		expect(score.points).to eq [10,10]
-	end
-
-	it "return [0,0] for bad input" do
-		score = Tennis.new("8-1")
-		expect(score.points).to eq [0,0]
-	end
-
-	it "checks invalid score: blank score '' " do
-		score = Tennis.new("")
-		expect(score.points).to eq [0,0]
-	end
-
-	it "finds the points properly in scores with 7-5" do
-		score = Tennis.new("3-6,5-7")
-		expect(score.points).to eq [8,14]
+	it "raises exception for bad input" do
+		expect { Tennis.new("8-1") }.to raise_error
 	end
 end
 
@@ -138,7 +92,7 @@ end
 
 describe Tennis, "#sets_lost" do
 	it "returns the sets lost by each player" do
-		scores = [["6-4, 4-6, 6-4", [1,2]],["6-2,6-1", [0, 2]], ["7-6,4-6,6-4", [1, 2]], ["6-4", [0,1]]]
+		scores = [["6-4, 4-6, 6-4", [1,2]],["6-2,6-1", [0, 2]], ["7-6,4-6,6-4", [1, 2]], ["6-4, 6-1", [0, 2]]]
 		scores.each do |s|
 			ts = Tennis.new(s[0])
 			expect(ts.sets_lost).to eq s[1]
@@ -148,7 +102,7 @@ end
 
 describe Tennis, "#games_lost" do
 	it "returns the games won by each player" do
-		scores = [["6-4, 4-6, 6-4", [14,16]],["6-2,6-1", [3, 12]], ["7-6,4-6,6-4", [16, 17]], ["6-4", [4,6]]]
+		scores = [["6-4, 4-6, 6-4", [14,16]],["6-2,6-1", [3, 12]], ["7-6,4-6,6-4", [16, 17]], ["6-4, 7-5", [9, 13]]]
 		scores.each do |s|
 			ts = Tennis.new(s[0])
 			expect(ts.games_lost).to eq s[1]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tennis
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Rohan Katyal
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-13 00:00:00.000000000 Z
+date: 2015-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler