sciolyff 0.10.0 → 0.11.0

data/lib/sciolyff/interpreter/placing.rb

@@ -18,19 +18,19 @@ module SciolyFF
     attr_reader :event, :team, :subdivision_placing
 
     def participated?
-      @rep[:participated] == true || @rep[:participated].nil?
+      @rep[:participated] || @rep[:participated].nil?
     end
 
     def disqualified?
-      @rep[:disqualified] == true
+      @rep[:disqualified] || false
     end
 
     def exempt?
-      @rep[:exempt] == true
+      @rep[:exempt] || false
     end
 
     def unknown?
-      @rep[:unknown] == true
+      @rep[:unknown] || false
     end
 
     def tie?

data/lib/sciolyff/interpreter/raw.rb

@@ -25,7 +25,7 @@ module SciolyFF
     end
 
     def tiebreaker_rank
-      @rep[:'tiebreaker rank'] || Float::INFINITY
+      @rep[:'tiebreaker rank'] || 1
     end
 
     def ==(other)

data/lib/sciolyff/interpreter/subdivisions.rb

@@ -6,15 +6,45 @@ module SciolyFF
     private
 
     def subdivision_rep(sub)
-      # make a deep copy of rep and remove teams not in the subdivision
+      # 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)
+      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
 
-      fix_placings_for_existing_teams(rep)
-      rep
+    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)
+      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)

data/lib/sciolyff/interpreter/team.rb

@@ -34,11 +34,11 @@ module SciolyFF
     end
 
     def exhibition?
-      @rep[:exhibition] == true
+      @rep[:exhibition] || false
     end
 
     def disqualified?
-      @rep[:disqualified] == true
+      @rep[:disqualified] || false
     end
 
     def number
@@ -65,6 +65,11 @@ module SciolyFF
       @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?
 

data/lib/sciolyff/interpreter/tournament.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'sciolyff/interpreter/model'
+require 'sciolyff/interpreter/bids'
 
 module SciolyFF
   # Models a Science Olympiad tournament
@@ -21,40 +22,43 @@ module SciolyFF
 
     undef tournament
 
-    def name
-      @rep[:name]
+    %i[
+      name
+      location
+      level
+      state
+      division
+      year
+    ].each do |sym|
+      define_method(sym) { @rep[sym] }
     end
 
     def short_name
       @rep[:'short name']
     end
 
-    def location
-      @rep[:location]
-    end
-
-    def level
-      @rep[:level]
+    def date
+      @date ||= if @rep[:date].instance_of?(Date)
+                  @rep[:date]
+                else
+                  Date.parse(@rep[:date])
+                end
     end
 
-    def state
-      @rep[:state]
+    def medals
+      @rep[:medals] || [calc_medals, maximum_place].min
     end
 
-    def division
-      @rep[:division]
+    def trophies
+      @rep[:trophies] || [calc_trophies, nonexhibition_teams_count].min
     end
 
-    def year
-      @rep[:year]
+    def bids
+      @rep[:bids] || 0
     end
 
-    def date
-      @date ||= if @rep[:date].instance_of?(Date)
-                  @rep[:date]
-                else
-                  Date.parse(@rep[:date])
-                end
+    def bids_per_school
+      @rep[:'bids per school'] || 1
     end
 
     def worst_placings_dropped?
@@ -74,17 +78,17 @@ module SciolyFF
     end
 
     def custom_maximum_place?
-      maximum_place != @teams.count { |t| !t.exhibition? }
+      maximum_place != nonexhibition_teams_count
     end
 
     def maximum_place
       return @rep[:'maximum place'] if @rep[:'maximum place']
 
-      @teams.count { |t| !t.exhibition? }
+      nonexhibition_teams_count
     end
 
     def per_event_n?
-      @rep[:'per-event n']
+      @rep[:'per-event n'] || false
     end
 
     def n_offset
@@ -104,5 +108,21 @@ module SciolyFF
     def subdivisions?
       !@subdivisions.empty?
     end
+
+    def nonexhibition_teams_count
+      @nonexhibition_teams_count ||= @teams.count { |t| !t.exhibition? }
+    end
+
+    include Interpreter::Bids
+
+    private
+
+    def calc_medals
+      [(nonexhibition_teams_count / 10r).ceil, 3].max
+    end
+
+    def calc_trophies
+      [(nonexhibition_teams_count / 6r).ceil, 3].max
+    end
   end
 end

data/lib/sciolyff/validator.rb

@@ -10,14 +10,15 @@ module SciolyFF
 
     require 'sciolyff/validator/top_level'
     require 'sciolyff/validator/tournament'
+    require 'sciolyff/validator/subdivisions'
     require 'sciolyff/validator/events'
     require 'sciolyff/validator/teams'
     require 'sciolyff/validator/placings'
     require 'sciolyff/validator/penalties'
     require 'sciolyff/validator/raws'
 
-    def initialize(loglevel = Logger::WARN)
-      @logger = Logger.new loglevel
+    def initialize(loglevel: Logger::WARN, canonical: true)
+      @logger = Logger.new loglevel, canonical_checks: canonical
       @checkers = {}
     end
 
@@ -64,7 +65,7 @@ module SciolyFF
     def check_all(rep, logger)
       check(TopLevel, rep, rep, logger) &&
         check(Tournament, rep, rep[:Tournament], logger) &&
-        [Events, Teams, Placings, Penalties].all? do |klass|
+        [Subdivisions, Events, Teams, Placings, Penalties].all? do |klass|
           check_list(klass, rep, logger)
         end &&
         rep[:Placings].map { |p| p[:raw] }.compact.all? do |r|

data/lib/sciolyff/validator/canonical.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Logic for checking against canonical lists of events and schools
+  module Validator::Canonical
+    BASE = 'https://raw.githubusercontent.com/unosmium/canonical-names/master/'
+
+    private
+
+    def canonical?(rep, file, logger)
+      return true if @canonical_warned || !logger.options[:canonical_checks]
+
+      @canonical_list ||= CSV.parse(URI.open(BASE + file))
+      # don't try to make this more efficient, harder than it looks because of
+      # nil comparisons
+      @canonical_list.include?(rep)
+    rescue StandardError => e
+      logger.warn "could not read canonical names file: #{BASE + file}"
+      logger.debug "#{e}\n  #{e.backtrace.first}"
+      @canonical_warned = true
+    end
+  end
+end

data/lib/sciolyff/validator/events.rb

@@ -2,6 +2,7 @@
 
 require 'sciolyff/validator/checker'
 require 'sciolyff/validator/sections'
+require 'sciolyff/validator/canonical'
 
 module SciolyFF
   # Checks for one event in the Events section of a SciolyFF file
@@ -78,6 +79,15 @@ module SciolyFF
         "#{lowest_place} instead of 1"
     end
 
+    include Validator::Canonical
+
+    def in_canonical_list?(event, logger)
+      rep = [event[:name]]
+      return true if canonical?(rep, 'events.csv', logger)
+
+      logger.warn "non-canonical event: #{event[:name]}"
+    end
+
     private
 
     def placings_by_place(event)

data/lib/sciolyff/validator/logger.rb

@@ -8,10 +8,11 @@ module SciolyFF
     INFO  = 2
     DEBUG = 3
 
-    attr_reader :log
+    attr_reader :log, :options
 
-    def initialize(loglevel)
+    def initialize(loglevel, **options)
       @loglevel = loglevel
+      @options = options
       flush
     end
 

data/lib/sciolyff/validator/range.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Helper method to check for value in range and report error if not
+  module Validator::Range
+    private
+
+    def within_range?(rep, key, logger, min, max)
+      value = rep[key]
+      return true if value.nil? || value.between?(min, max)
+
+      logger.error "'#{key}: #{value}' is not within range [#{min}, #{max}]"
+    end
+  end
+end

data/lib/sciolyff/validator/raws.rb

@@ -16,5 +16,19 @@ module SciolyFF
       'tier': Integer,
       'tiebreaker rank': Integer
     }.freeze
+
+    def positive_tier?(raw, logger)
+      tier = raw[:tier]
+      return true if tier.nil? || tier.positive?
+
+      logger.error "'tier: #{tier}' is not positive"
+    end
+
+    def positive_tiebreaker_rank?(raw, logger)
+      rank = raw[:'tiebreaker rank']
+      return true if rank.nil? || rank.positive?
+
+      logger.error "'tiebreaker rank: #{rank}' is not positive"
+    end
   end
 end

data/lib/sciolyff/validator/sections.rb

@@ -27,20 +27,24 @@ module SciolyFF
     def sections_are_correct_type?(rep, logger)
       correct_types = self.class::REQUIRED.merge self.class::OPTIONAL
       rep.all? do |key, value|
-        correct = correct_types[key]
-        next true if
-        (correct.instance_of?(Array) && correct.include?(value)) ||
-        (correct.instance_of?(Class) && value.instance_of?(correct)) ||
-        correct_date?(correct, value)
+        type = correct_types[key]
+        next true if correct_type?(type, value)
 
-        logger.error "#{key}: #{value} is not #{correct}"
+        logger.error "#{key}: #{value} is not #{type}"
       end
     end
 
     private
 
-    def correct_date?(correct, value)
-      correct == Date && Date.parse(value)
+    def correct_type?(type, value)
+      type.nil? ||
+        (type.instance_of?(Array) && type.include?(value)) ||
+        (type.instance_of?(Class) && value.instance_of?(type)) ||
+        correct_date?(type, value)
+    end
+
+    def correct_date?(type, value)
+      type == Date && Date.parse(value)
     rescue StandardError
       false
     end

data/lib/sciolyff/validator/subdivisions.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+require 'sciolyff/validator/range'
+
+module SciolyFF
+  # Checks for one subdivision in the Subdivisions section of a SciolyFF file
+  class Validator::Subdivisions < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      name: String
+    }.freeze
+
+    OPTIONAL = {
+      medals: Integer,
+      trophies: Integer,
+      'maximum place': Integer
+    }.freeze
+
+    def initialize(rep)
+      @names = rep[:Subdivisions].map { |s| s[:name] }
+      @teams = rep[:Teams].group_by { |t| t[:subdivision] }
+    end
+
+    def unique_name?(subdivision, logger)
+      return true if @names.count(subdivision[:name]) == 1
+
+      logger.error "duplicate subdivision name: #{subdivision[:name]}"
+    end
+
+    def matching_teams?(subdivision, logger)
+      name = subdivision[:name]
+      return true if @teams[name]
+
+      logger.error "subdivision with 'name: #{name}' has no teams"
+    end
+
+    include Validator::Range
+
+    def maximum_place_within_range?(subdivision, logger)
+      max = team_count(subdivision)
+      within_range?(subdivision, :'maximum place', logger, 1, max)
+    end
+
+    def medals_within_range?(subdivision, logger)
+      max = [team_count(subdivision), subdivision[:'maximum place']].compact.min
+      within_range?(subdivision, :medals, logger, 1, max)
+    end
+
+    def trophies_within_range?(subdivision, logger)
+      within_range?(subdivision, :trophies, logger, 1, team_count(subdivision))
+    end
+
+    private
+
+    def team_count(subdivision)
+      @teams[subdivision[:name]].count do |t|
+        t[:subdivision] == subdivision[:name] && !t[:exhibition]
+      end
+    end
+  end
+end