sciolyff 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f19b6f05fc3a19ae643aa8c783561f094ddd93959021b77eda3ad437ec9f6d
-  data.tar.gz: e0359c5b02d570f75d068ae5d4b0dd2965d0bece8acfa7451b6cc29acfe19cb7
+  metadata.gz: 32773284dba3d9f67b630bd64bc1e42c60ca301a49da032c51a055101a8a96c5
+  data.tar.gz: dee4202db369a0d6968ffdd32b98be3a6e42edb49558a8a05855a1ea77c3d653
 SHA512:
-  metadata.gz: dfacd78064019cebf1be0d4cf7351965eb6dd134d2457a1f00d8ed26babb535c94d292d90b9cb6f21f04350faa8b9d96745bdb61d05b8c00806e8a4fbde57df6
-  data.tar.gz: 51e0a6fd2deaa74b1f0692e7a39a4d2712bef21f3a4f92b322d205219ac58d2dd0102ba438c2a6b085850d2d23885ee1d95386f67c81c5c66d355b4c7bef2db0
+  metadata.gz: acab98c9051a82ed655f14551e185f4e69cc3f22c08af64ab2361d00759216b812a96f0eb247aa5add92ad3367d705c339dfbb2be67e44b6d4df588901611d69
+  data.tar.gz: ddcb26d4a7ab3a9f668ab1a95923183697857bb44e64942a63314b3336d57fd01c6275a2081e765ae0de66953527a15d5b6bc1637d62db5bfa06898da2a835eb

data/bin/sciolyff

@@ -6,7 +6,7 @@ require 'yaml'
 require 'sciolyff'
 
 opts = Optimist.options do
-  version 'sciolyff 0.6.0'
+  version 'sciolyff 0.7.0'
   banner <<~STRING
     Checks if a given file is in the Scioly File Format
 

data/lib/sciolyff/interpreter/placing.rb

@@ -46,6 +46,12 @@ module SciolyFF
     end
 
     def points
+      return 0 unless considered_for_team_points?
+
+      isolated_points
+    end
+
+    def isolated_points
       return @cache[:points] if @cache[:points]
 
       n = event.competing_teams.count
@@ -60,6 +66,11 @@ module SciolyFF
     end
 
     def considered_for_team_points?
+      initially_considered_for_team_points? &&
+        !team.worst_placings_to_be_dropped.include?(self)
+    end
+
+    def initially_considered_for_team_points?
       !(event.trial? || event.trialed? || exempt?)
     end
 

data/lib/sciolyff/interpreter/team.rb

@@ -61,21 +61,21 @@ module SciolyFF
     def points
       return @cache[:points] if @cache[:points]
 
-      counted_placings = placings.select(&:considered_for_team_points?)
+      @cache[:points] = placings.sum(&:points) + penalties.sum(&:points)
+    end
 
-      if @tournament.worst_placings_dropped?
-        counted_placings
-          .sort!(&:points)
-          .reverse!
-          .drop!(@tournament.worst_placings_dropped)
-      end
+    def worst_placings_to_be_dropped
+      return [] if @tournament.worst_placings_dropped.zero?
 
-      @cache[:points] =
-        counted_placings.sum(&:points) + penalties.sum(&:points)
+      placings
+        .select(&:initially_considered_for_team_points?)
+        .sort(&:points)
+        .reverse
+        .take(@tournament.worst_placings_dropped)
     end
 
     def trial_event_points
-      placings.select { |p| p.event.trial? }.sum(&:points)
+      placings.select { |p| p.event.trial? }.sum(&:isolated_points)
     end
 
     def medal_counts

data/lib/sciolyff/interpreter/tournament.rb

@@ -53,13 +53,19 @@ module SciolyFF
     end
 
     def worst_placings_dropped?
-      @rep[:'worst placings dropped'].instance_of? Integer
+      @rep.key? :'worst placings dropped'
     end
 
     def worst_placings_dropped
-      return 0 unless @rep[:'worst placings dropped']
+      worst_placings_dropped? ? @rep[:'worst placings dropped'] : 0
+    end
+
+    def exempt_placings?
+      @rep.key? :'exempt placings'
+    end
 
-      @rep[:'worst placings dropped']
+    def exempt_placings
+      exempt_placings? ? @rep[:'exempt placings'] : 0
     end
 
     def max_points_per_event(trial: false)

data/lib/sciolyff/placings.rb

@@ -69,6 +69,23 @@ module SciolyFF
       end
     end
 
+    def test_each_team_has_correct_number_of_exempt_placings
+      skip unless SciolyFF.rep.instance_of? Hash
+      skip unless SciolyFF.rep[:Tournament].instance_of? Hash
+
+      exempt_placings = SciolyFF.rep[:Tournament][:'exempt placings']
+      exempt_placings = 0 if exempt_placings.nil?
+      skip unless exempt_placings.instance_of? Integer
+
+      @placings.select { |p| p.instance_of?(Hash) && p[:'exempt'] }
+               .group_by { |p| p[:team] }
+               .each do |team_number, placings|
+        assert placings.count == exempt_placings,
+               "Team number #{team_number} has the incorrect number of exempt "\
+               "placings (#{placings.count} instead of #{exempt_placings})"
+      end
+    end
+
     def test_each_placing_has_valid_tie
       @placings.select { |p| p.instance_of? Hash }.each do |placing|
         next unless placing.key? :tie

data/lib/sciolyff/tournament.rb

@@ -23,7 +23,7 @@ module SciolyFF
 
     def test_does_not_have_extra_info
       info = Set.new %i[name location level division state year date]
-      info << :'short name'
+      info << :'short name' << :'worst placings dropped' << :'exempt placings'
       assert Set.new(@tournament.keys).subset? info
     end
 
@@ -74,5 +74,15 @@ module SciolyFF
       skip unless @tournament.key? :date
       assert_instance_of Date, @tournament[:date]
     end
+
+    def test_has_valid_worst_placings_dropped
+      skip unless @tournament.key? :'worst placings dropped'
+      assert_instance_of Integer, @tournament[:'worst placings dropped']
+    end
+
+    def test_has_valid_exempt_placings
+      skip unless @tournament.key? :'exempt placings'
+      assert_instance_of Integer, @tournament[:'exempt placings']
+    end
   end
 end

data/lib/sciolyff.rb

@@ -47,166 +47,4 @@ module SciolyFF
     Doesn't give line numbers from original file? Yeah.
 
   STRING
-
-  # Deprecated: Please use `SciolyFF::Interpreter` instead
-  #
-  # Wrapper class around a SciolyFF Ruby object representation with utility
-  # methods to help in displaying results
-  class Helper
-    attr_reader :rep, :tournament, :events_by_name, :teams_by_number
-    attr_reader :placings_by_event, :placings_by_team, :penalties_by_team
-
-    def initialize(rep)
-      warn 'Class `SciolyFF::Helper` is deprecated. '\
-           'Please use `SciolyFF::Interpreter` instead.'
-
-      @rep = rep
-      @exhibition_teams_count = rep[:Teams].count { |t| t[:exhibition] }
-      @exempt_placings_count = rep[:Placings].count { |p| p[:exempt] }
-      @team_points_cache = {}
-
-      @tournament = rep[:Tournament]
-      @events_by_name = index_array(rep[:Events], [:name])
-      @teams_by_number = index_array(rep[:Teams], [:number])
-      @placings_by_event = index_array(rep[:Placings], %i[event team])
-      @placings_by_team = index_array(rep[:Placings], %i[team event])
-      return unless rep[:Penalties]
-
-      @penalties_by_team = index_array(rep[:Penalties], [:team])
-    end
-
-    def nonexhibition_teams
-      @teams_by_number.reject { |_, t| t[:exhibition] }
-    end
-
-    def event_points(team_number, event_name)
-      placing = @placings_by_event[event_name][team_number]
-      number_of_teams = number_of_competing_teams(event_name)
-
-      if placing[:disqualified] then number_of_teams + 2
-      elsif placing[:participated] == false then number_of_teams + 1
-      elsif placing[:unknown] then number_of_teams - 1
-      elsif placing[:place].nil? then number_of_teams
-      else calculate_event_points(placing)
-      end
-    end
-
-    def team_points(team_number)
-      return @team_points_cache[team_number] if @team_points_cache[team_number]
-
-      @team_points_cache[team_number] = calculate_team_points(team_number)
-    end
-
-    def team_points_from_penalties(team_number)
-      if @penalties_by_team.nil? || @penalties_by_team[team_number].nil? then 0
-      else @penalties_by_team[team_number][:points]
-      end
-    end
-
-    def sort_teams_by_rank
-      @teams_by_number
-        .values
-        .sort do |a, b|
-        next  1 if  a[:exhibition] && !b[:exhibition]
-        next -1 if !a[:exhibition] &&  b[:exhibition]
-
-        cmp = team_points(a[:number]) - team_points(b[:number])
-        cmp.zero? ? break_tie(a[:number], b[:number]) : cmp
-      end
-    end
-
-    def medal_counts(team_number)
-      (1..(nonexhibition_teams.count + 2)).map do |m|
-        @events_by_name
-          .values
-          .reject { |e| e[:trial] || e[:trialed] }
-          .count { |e| event_points(team_number, e[:name]) == m }
-      end
-    end
-
-    private
-
-    def index_array(arr, index_keys)
-      return arr.first if index_keys.empty?
-
-      indexed_hash = arr.group_by { |x| x[index_keys.first] }
-
-      indexed_hash.transform_values do |a|
-        index_array(a, index_keys.drop(1))
-      end
-    end
-
-    def number_of_competing_teams(event_name)
-      return @teams_by_number.count if @events_by_name[event_name][:trial]
-
-      nonexhibition_teams.count
-    end
-
-    def calculate_event_points(placing)
-      return placing[:place] if simple_placing?(placing)
-
-      # Points is place minus number of exhibition and exempt teams with a
-      # better place
-      placing[:place] -
-        @placings_by_event[placing[:event]]
-        .values
-        .select { |p| p[:place] && exhibition_or_exempt_placing?(p) }
-        .count { |p| p[:place] < placing[:place] }
-    end
-
-    def calculate_team_points(team_number)
-      @placings_by_team[team_number]
-        .values
-        .reject { |p| @events_by_name[p[:event]][:trial] }
-        .reject { |p| @events_by_name[p[:event]][:trialed] }
-        .reject { |p| p[:exempt] }
-        .sum { |p| event_points(team_number, p[:event]) } \
-      + team_points_from_penalties(team_number)
-    end
-
-    def simple_placing?(placing)
-      @events_by_name[placing[:event]][:trial] ||
-        (@exhibition_teams_count.zero? && @exempt_placings_count.zero?)
-    end
-
-    def exhibition_or_exempt_placing?(placing)
-      @teams_by_number[placing[:team]][:exhibition] || placing[:exempt]
-    end
-
-    def break_tie(team_number_a, team_number_b)
-      medal_counts(team_number_a)
-        .zip(medal_counts(team_number_b))
-        .map { |count| count.last - count.first }
-        .find(proc { break_second_tie(team_number_a, team_number_b) },
-              &:nonzero?)
-    end
-
-    def break_second_tie(team_number_a, team_number_b)
-      cmp = points_from_trial(team_number_a) - points_from_trial(team_number_b)
-      cmp.zero? ? break_third_tie(team_number_a, team_number_b) : cmp
-    end
-
-    def break_third_tie(team_number_a, team_number_b)
-      medal_counts_from_trial(team_number_a)
-        .zip(medal_counts_from_trial(team_number_b))
-        .map { |count| count.last - count.first }
-        .find(proc { team_number_a <=> team_number_b }, &:nonzero?)
-    end
-
-    def points_from_trial(team_number)
-      @placings_by_team[team_number]
-        .values
-        .select { |p| @events_by_name[p[:event]][:trial] }
-        .sum { |p| event_points(team_number, p[:event]) }
-    end
-
-    def medal_counts_from_trial(team_number)
-      (1..(@teams_by_number.count + 2)).map do |m|
-        @events_by_name
-          .values
-          .select { |e| e[:trial] }
-          .count { |e| event_points(team_number, e[:name]) == m }
-      end
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sciolyff
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Em Zhan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-26 00:00:00.000000000 Z
+date: 2019-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest