sciolyff-duosmium 0.13.0

data/lib/sciolyff/interpreter/model.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Parent class for other nested classes within Interpreter
+  class Interpreter::Model
+    def initialize(rep, index)
+      @rep = rep[pluralize_for_key(self.class)][index]
+    end
+
+    def link_to_other_models(interpreter)
+      @tournament = interpreter.tournament
+    end
+
+    attr_reader :tournament
+
+    # prevents infinite loop due caused by intentional circular references
+    def inspect
+      to_s.delete_suffix('>') + " @rep=#{@rep}>"
+    end
+
+    private
+
+    def pluralize_for_key(klass)
+      name = klass.name.split('::').last
+      name = name.delete_suffix('y') + 'ie' if name.end_with?('y')
+      (name + 's').to_sym
+    end
+  end
+end

data/lib/sciolyff/interpreter/penalty.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'sciolyff/interpreter/model'
+
+module SciolyFF
+  # Models a team penalty for a Science Olympiad team at a tournament
+  class Interpreter::Penalty < Interpreter::Model
+    def link_to_other_models(interpreter)
+      super
+      @team = interpreter.teams.find { |t| t.number == @rep[:team] }
+    end
+
+    attr_reader :team
+
+    def points
+      @rep[:points]
+    end
+  end
+end

data/lib/sciolyff/interpreter/placing.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'sciolyff/interpreter/model'
+
+module SciolyFF
+  # Models the result of a team participating (or not) in an event
+  class Interpreter::Placing < Interpreter::Model
+    require 'sciolyff/interpreter/raw'
+
+    def link_to_other_models(interpreter)
+      super
+      @event = interpreter.events.find { |e| e.name   == @rep[:event] }
+      @team  = interpreter.teams .find { |t| t.number == @rep[:team]  }
+
+      link_to_placing_in_subdivision_interpreter(interpreter)
+    end
+
+    attr_reader :event, :team, :subdivision_placing
+
+    def participated?
+      @rep[:participated] || @rep[:participated].nil?
+    end
+
+    def disqualified?
+      @rep[:disqualified] || false
+    end
+
+    def exempt?
+      @rep[:exempt] || false
+    end
+
+    def unknown?
+      @rep[:unknown] || false
+    end
+
+    def tie?
+      raw? ? @tie ||= event.raws.count(raw) > 1 : @rep[:tie] == true
+    end
+
+    def place
+      raw? ? @place ||= event.raws.find_index(raw) + 1 : @rep[:place]
+    end
+
+    def raw
+      @raw ||= Raw.new(@rep[:raw], event.low_score_wins?) if raw?
+    end
+
+    def raw?
+      @rep.key? :raw
+    end
+
+    def did_not_participate?
+      !participated?
+    end
+
+    def participation_only?
+      participated? && !place && !disqualified? && !unknown?
+    end
+
+    def dropped_as_part_of_worst_placings?
+      team.worst_placings_to_be_dropped.include?(self)
+    end
+
+    def points
+      @points ||= if !considered_for_team_points? then 0
+                  else isolated_points
+                  end
+    end
+
+    def isolated_points
+      max_place = event.maximum_place
+      n = max_place + tournament.n_offset
+
+      if    disqualified? then n + 2
+      elsif did_not_participate? then n + 1
+      elsif participation_only? || unknown? then n
+      else  [calculate_points, max_place].min
+      end
+    end
+
+    def considered_for_team_points?
+      initially_considered_for_team_points? &&
+        !dropped_as_part_of_worst_placings?
+    end
+
+    def initially_considered_for_team_points?
+      !(event.trial? || event.trialed? || exempt?)
+    end
+
+    def points_affected_by_exhibition?
+      considered_for_team_points? && place && !exhibition_placings_behind.zero?
+    end
+
+    def points_limited_by_maximum_place?
+      tournament.custom_maximum_place? &&
+        (unknown? ||
+         (place &&
+          (calculate_points > event.maximum_place ||
+           calculate_points == event.maximum_place && tie?
+          )))
+    end
+
+    private
+
+    def calculate_points
+      return place if event.trial?
+
+      place - exhibition_placings_behind
+    end
+
+    def exhibition_placings_behind
+      @exhibition_placings_behind ||= event.placings.count do |p|
+        (p.exempt? || p.team.exhibition?) &&
+          p.place &&
+          p.place < place
+      end
+    end
+
+    def link_to_placing_in_subdivision_interpreter(interpreter)
+      return @subdivision_placing = nil unless (sub = team.subdivision)
+
+      @subdivision_placing = interpreter.subdivisions[sub].placings.find do |p|
+        p.event.name == event.name && p.team.number == team.number
+      end
+    end
+  end
+end

data/lib/sciolyff/interpreter/raw.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Models the raw score representation for a Placing
+  class Interpreter::Placing::Raw
+    def initialize(rep, low_score_wins)
+      @rep = rep
+      @low_score_wins = low_score_wins
+    end
+
+    def score
+      @rep[:score]
+    end
+
+    def tiered?
+      tier > 1
+    end
+
+    def tier
+      @rep[:tier] || 1
+    end
+
+    def lost_tiebreaker?
+      tiebreaker_rank > 1
+    end
+
+    def tiebreaker_rank
+      @rep[:'tiebreaker rank'] || 1
+    end
+
+    def ==(other)
+      score == other.score &&
+        tier == other.tier &&
+        tiebreaker_rank == other.tiebreaker_rank
+    end
+
+    def <=>(other)
+      [
+        tier,
+        @low_score_wins ? score : -score,
+        tiebreaker_rank
+      ] <=>
+        [
+          other.tier,
+          @low_score_wins ? other.score : -other.score,
+          other.tiebreaker_rank
+        ]
+    end
+  end
+end

data/lib/sciolyff/interpreter/subdivisions.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Subdivision logic, to be used in the Interpreter class
+  module Interpreter::Subdivisions
+    private
+
+    def subdivision_rep(sub)
+      # make a deep copy of rep
+      rep = Marshal.load(Marshal.dump(@rep))
+
+      remove_teams_not_in_subdivision(rep, sub)
+      fix_subdivision_tournament_fields(rep, sub)
+      limit_maximum_place(rep)
+      fix_placings_for_existing_teams(rep) unless raws?
+      rep
+    end
+
+    def remove_teams_not_in_subdivision(rep, sub)
+      rep[:Teams].select! { |t| t.delete(:subdivision) == sub }
+
+      team_numbers = rep[:Teams].map { |t| t[:number] }
+      rep[:Placings].select! { |p| team_numbers.include? p[:team] }
+    end
+
+    def fix_subdivision_tournament_fields(rep, sub)
+      tournament_rep = rep[:Tournament]
+      sub_rep = rep[:Subdivisions].find { |s| s[:name] == sub }
+
+      replace_tournament_fields(tournament_rep, sub_rep)
+
+      tournament_rep.delete(:bids)
+      tournament_rep.delete(:'bids per school')
+      rep.delete(:Subdivisions)
+    end
+
+    def replace_tournament_fields(tournament_rep, sub_rep)
+      [:medals, :trophies, :'maximum place'].each do |key|
+        tournament_rep[key] = sub_rep[key] if sub_rep.key?(key)
+      end
+    end
+
+    def limit_maximum_place(rep)
+      max_place = rep[:Tournament][:'maximum place']
+      team_count = rep[:Teams].count { |t| !t[:exhibition] }
+
+      rep[:Tournament].delete(:'maximum place') if
+        !max_place.nil? && max_place > team_count
+    end
+
+    def fix_placings_for_existing_teams(rep)
+      rep[:Placings]
+        .group_by { |p| p[:event] }
+        .each { |_, ep| fix_event_placings(ep) }
+    end
+
+    def fix_event_placings(event_placings)
+      event_placings
+        .select { |p| p[:place] }
+        .sort_by { |p| p[:place] }
+        .each_with_index { |p, i| p[:temp_place] = i + 1 }
+        .each { |p| fix_placing_ties(p, event_placings) }
+        .each { |p| p.delete(:temp_place) }
+    end
+
+    def fix_placing_ties(placing, event_placings)
+      ties = event_placings.select { |o| o[:place] == placing[:place] }
+      placing[:place] = ties.map { |t| t[:temp_place] }.max - ties.count + 1
+      ties.count > 1 ? placing[:tie] = true : placing.delete(:tie)
+    end
+  end
+end

data/lib/sciolyff/interpreter/team.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'sciolyff/interpreter/model'
+
+module SciolyFF
+  # Models an instance of a Science Olympiad team at a specific tournament
+  class Interpreter::Team < Interpreter::Model
+    def link_to_other_models(interpreter)
+      super
+      @placings  = interpreter.placings .select { |p| p.team == self }
+      @penalties = interpreter.penalties.select { |p| p.team == self }
+      @placings_by_event =
+        @placings.group_by(&:event).transform_values!(&:first)
+
+      link_to_team_in_subdivision_interpreter(interpreter)
+    end
+
+    attr_reader :placings, :penalties, :subdivision_team
+
+    def school
+      @rep[:school]
+    end
+
+    def school_abbreviation
+      @rep[:'school abbreviation']
+    end
+
+    def suffix
+      @rep[:suffix]
+    end
+
+    def subdivision
+      @rep[:subdivision]
+    end
+
+    def exhibition?
+      @rep[:exhibition] || false
+    end
+
+    def disqualified?
+      @rep[:disqualified] || false
+    end
+
+    def number
+      @rep[:number]
+    end
+
+    def city
+      @rep[:city]
+    end
+
+    def state
+      @rep[:state]
+    end
+
+    def placing_for(event)
+      @placings_by_event[event]
+    end
+
+    def rank
+      @tournament.teams.find_index(self) + 1
+    end
+
+    def points
+      @points ||= placings.sum(&:points) + penalties.sum(&:points)
+    end
+
+    def earned_bid?
+      school_rank = @tournament.teams_eligible_for_bids.find_index(self)
+      !school_rank.nil? && school_rank < @tournament.bids
+    end
+
+    def worst_placings_to_be_dropped
+      return [] if @tournament.worst_placings_dropped.zero?
+
+      placings
+        .select(&:initially_considered_for_team_points?)
+        .sort_by(&:isolated_points)
+        .reverse
+        .take(@tournament.worst_placings_dropped)
+    end
+
+    def trial_event_points
+      placings.select { |p| p.event.trial? }.sum(&:isolated_points)
+    end
+
+    def medal_counts
+      (1..(@tournament.teams.count + 2)).map do |medal_points|
+        placings.select(&:considered_for_team_points?)
+                .count { |p| p.points == medal_points }
+      end
+    end
+
+    def trial_event_medal_counts
+      (1..(@tournament.teams.count + 2)).map do |medal_points|
+        placings.select { |p| p.event.trial? }
+                .count { |p| p.isolated_points == medal_points }
+      end
+    end
+
+    private
+
+    def link_to_team_in_subdivision_interpreter(interpreter)
+      return @subdivision_team = nil unless (sub = subdivision)
+
+      @subdivision_team = interpreter.subdivisions[sub].teams.find do |t|
+        t.number == number
+      end
+    end
+  end
+end

data/lib/sciolyff/interpreter/tiebreaks.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Tie-breaking logic for teams, to be used in the Interpreter class
+  module Interpreter::Tiebreaks
+    private
+
+    def sort_teams_by_points(teams)
+      teams.sort do |team_a, team_b|
+        cmp = team_a.points <=> team_b.points
+        cmp.zero? ? break_tie(team_a, team_b) : cmp
+      end
+    end
+
+    def break_tie(team_a, team_b)
+      team_a.medal_counts
+            .zip(team_b.medal_counts)
+            .map { |counts| counts.last - counts.first }
+            .find(proc { break_second_tie(team_a, team_b) }, &:nonzero?)
+    end
+
+    def break_second_tie(team_a, team_b)
+      cmp = team_a.trial_event_points <=> team_b.trial_event_points
+      cmp.zero? ? break_third_tie(team_a, team_b) : cmp
+    end
+
+    def break_third_tie(team_a, team_b)
+      team_a.trial_event_medal_counts
+            .zip(team_b.trial_event_medal_counts)
+            .map { |counts| counts.last - counts.first }
+            .find(proc { team_a.number <=> team_b.number }, &:nonzero?)
+    end
+  end
+end