sciolyff-duosmium 0.13.0

data/lib/sciolyff/interpreter/tournament.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'sciolyff/interpreter/model'
+require 'sciolyff/interpreter/bids'
+
+module SciolyFF
+  # Models a Science Olympiad tournament
+  class Interpreter::Tournament < Interpreter::Model
+    def initialize(rep)
+      @rep = rep[:Tournament]
+    end
+
+    def link_to_other_models(interpreter)
+      @events = interpreter.events
+      @teams = interpreter.teams
+      @placings = interpreter.placings
+      @penalties = interpreter.penalties
+      @subdivisions = interpreter.subdivisions
+    end
+
+    attr_reader :events, :teams, :placings, :penalties, :subdivisions
+
+    undef tournament
+
+    %i[
+      name
+      location
+      level
+      state
+      division
+      year
+    ].each do |sym|
+      define_method(sym) { @rep[sym] }
+    end
+
+    def short_name
+      @rep[:'short name']
+    end
+
+    def date
+      @date ||= if @rep[:date].instance_of?(Date)
+                  @rep[:date]
+                else
+                  unless @rep[:date].nil?
+                    Date.parse(@rep[:date])
+                  end
+                end
+    end
+
+    def start_date
+      @start_date ||= if !@rep[:'start date'].nil?
+                        if @rep[:'start date'].instance_of?(Date)
+                          @rep[:'start date']
+                        else
+                          Date.parse(@rep[:'start date'])
+                        end
+                      else
+                        if @rep[:date].instance_of?(Date)
+                          @rep[:date]
+                        else
+                          unless @rep[:date].nil?
+                            Date.parse(@rep[:date])
+                          end
+                        end
+                      end
+    end
+
+    def end_date
+      @end_date ||= if !@rep[:'end date'].nil?
+                      if @rep[:'end date'].instance_of?(Date)
+                        @rep[:'end date']
+                      else
+                        Date.parse(@rep[:'end date'])
+                      end
+                    else
+                      if @rep[:date].instance_of?(Date)
+                        @rep[:date]
+                      else
+                        unless @rep[:date].nil?
+                          Date.parse(@rep[:date])
+                        end
+                      end
+                    end
+    end
+
+    def awards_date
+      @awards_date ||= if !@rep[:'awards date'].nil?
+                         if @rep[:'awards date'].instance_of?(Date)
+                           @rep[:'awards date']
+                         else
+                           Date.parse(@rep[:'awards date'])
+                         end
+                       else
+                         if !@rep[:'end date'].nil?
+                           if @rep[:'end date'].instance_of?(Date)
+                             @rep[:'end date']
+                           else
+                             Date.parse(@rep[:'end date'])
+                           end
+                         else
+                           if @rep[:date].instance_of?(Date)
+                             @rep[:date]
+                           else
+                             unless @rep[:date].nil?
+                               Date.parse(@rep[:date])
+                             end
+                           end
+                         end
+                       end
+    end
+
+    def medals
+      @rep[:medals] || [calc_medals, maximum_place].min
+    end
+
+    def trophies
+      @rep[:trophies] || [calc_trophies, nonexhibition_teams_count].min
+    end
+
+    def bids
+      @rep[:bids] || 0
+    end
+
+    def bids_per_school
+      @rep[:'bids per school'] || 1
+    end
+
+    def worst_placings_dropped?
+      worst_placings_dropped.positive?
+    end
+
+    def worst_placings_dropped
+      @rep[:'worst placings dropped'] || 0
+    end
+
+    def exempt_placings?
+      exempt_placings.positive?
+    end
+
+    def exempt_placings
+      @rep[:'exempt placings'] || 0
+    end
+
+    def custom_maximum_place?
+      maximum_place != nonexhibition_teams_count
+    end
+
+    def maximum_place
+      @rep[:'maximum place'] || nonexhibition_teams_count
+    end
+
+    def per_event_n
+      @rep[:'per-event n']
+    end
+
+    def per_event_n?
+      @rep.key? :'per-event n'
+    end
+
+    def n_offset
+      @rep[:'n offset'] || 0
+    end
+
+    def ties?
+      @ties ||= placings.map(&:tie?).any?
+    end
+
+    def ties_outside_of_maximum_places?
+      @ties_outside_of_maximum_places ||= placings.any? do |p|
+        p.tie? && !p.points_limited_by_maximum_place?
+      end
+    end
+
+    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.clamp(3, 10)
+    end
+
+    def calc_trophies
+      (nonexhibition_teams_count / 6r).ceil.clamp(3, 10)
+    end
+  end
+end

data/lib/sciolyff/validator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Checks if SciolyFF YAML files and/or representations (i.e. hashes that can
+  # be directly converted to YAML) comply with spec (i.e. safe for interpreting)
+  class Validator
+    require 'sciolyff/validator/logger'
+    require 'sciolyff/validator/checker'
+    require 'sciolyff/validator/sections'
+
+    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, canonical: true)
+      @logger = Logger.new loglevel, canonical_checks: canonical
+      @checkers = {}
+    end
+
+    def valid?(rep_or_yaml)
+      @logger.flush
+
+      if rep_or_yaml.instance_of? String
+        valid_yaml?(rep_or_yaml, @logger)
+      else
+        valid_rep?(rep_or_yaml, @logger)
+      end
+    end
+
+    def last_log
+      @logger.log
+    end
+
+    private
+
+    def valid_rep?(rep, logger)
+      unless rep.instance_of? Hash
+        logger.error 'improper file structure'
+        return false
+      end
+
+      result = check_all(rep, logger)
+
+      @checkers.clear # aka this method is not thread-safe
+      result
+    end
+
+    def valid_yaml?(yaml, logger)
+      rep = Psych.safe_load(
+        yaml,
+        permitted_classes: [Date],
+        symbolize_names: true
+      )
+    rescue StandardError => e
+      logger.error "could not read input as YAML:\n#{e.message}"
+    else
+      valid_rep?(rep, logger)
+    end
+
+    def check_all(rep, logger)
+      check(TopLevel, rep, rep, logger) &&
+        check(Tournament, rep, rep[:Tournament], logger) &&
+        [Subdivisions, Events, Teams, Placings, Penalties].all? do |klass|
+          check_list(klass, rep, logger)
+        end &&
+        rep[:Placings].map { |p| p[:raw] }.compact.all? do |r|
+          check(Raws, rep, r, logger)
+        end
+    end
+
+    def check_list(klass, rep, logger)
+      key = klass.to_s.split('::').last.to_sym
+      return true unless rep.key? key # ignore optional sections like Penalties
+
+      rep[key].map { |e| check(klass, rep, e, logger) }.all?
+    end
+
+    def check(klass, top_level_rep, rep, logger)
+      @checkers[klass] ||= klass.new top_level_rep, logger
+      checks = klass.instance_methods - Checker.instance_methods
+      checks.map { |im| @checkers[klass].send im, rep, logger }.all?
+    end
+  end
+end

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/checker.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # An empty base class to ensure consistent inheritance. All instance methods
+  # in children classes should take the arguments rep and logger.
+  class Validator::Checker
+    def initialize(rep); end
+
+    # Wraps initialize for child classes
+    module SafeInitialize
+      def initialize(rep, logger)
+        super rep
+      rescue StandardError => e
+        logger.debug "#{e}\n  #{e.backtrace.first}"
+      end
+    end
+
+    def self.inherited(subclass)
+      subclass.prepend SafeInitialize
+    end
+
+    # wraps method calls (always using send in Validator) so that exceptions
+    # in the check cause check to pass, as what caused the exception should
+    # cause some other check to fail if the SciolyFF is truly invalid
+    #
+    # this simplifies the checking code greatly, even if it is a bit hacky
+    def send(method, *args)
+      super
+    rescue StandardError => e
+      args[1].debug "#{e}\n  #{e.backtrace.first}" # args[1] is the logger
+    end
+  end
+end

data/lib/sciolyff/validator/events.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+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
+  class Validator::Events < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      name: String
+    }.freeze
+
+    OPTIONAL = {
+      trial: [true, false],
+      trialed: [true, false],
+      scoring: %w[high low]
+    }.freeze
+
+    def initialize(rep)
+      @events = rep[:Events]
+      @names = @events.map { |e| e[:name] }
+      @placings = rep[:Placings].group_by { |p| p[:event] }
+      @teams = rep[:Teams].count
+    end
+
+    def unique_name?(event, logger)
+      return true if @names.count(event[:name]) == 1
+
+      logger.error "duplicate event name: #{event[:name]}"
+    end
+
+    def placings_for_all_teams?(event, logger)
+      count = @placings[event[:name]]&.count || 0
+      return true if count == @teams
+
+      logger.error "'event: #{event[:name]}' has incorrect number of "\
+        "placings (#{count} instead of #{@teams})"
+    end
+
+    def ties_marked?(event, logger)
+      unmarked_ties = placings_by_place(event).select do |_place, placings|
+        placings.count { |p| !p[:tie] } > 1
+      end
+      return true if unmarked_ties.empty?
+
+      logger.error "'event: #{event[:name]}' has unmarked ties at "\
+        "place #{unmarked_ties.keys.join ', '}"
+    end
+
+    def ties_paired?(event, logger)
+      unpaired_ties = placings_by_place(event).select do |_place, placings|
+        placings.count { |p| p[:tie] } == 1
+      end
+      return true if unpaired_ties.empty?
+
+      logger.error "'event: #{event[:name]}' has unpaired ties at "\
+        "place #{unpaired_ties.keys.join ', '}"
+    end
+
+    def no_gaps_in_places?(event, logger)
+      places = places_with_expanded_ties(event)
+      return true if places.empty?
+
+      gaps = (places.min..places.max).to_a - places
+      return true if gaps.empty?
+
+      logger.error "'event: #{event[:name]}' has gaps in "\
+        "place #{gaps.join ', '}"
+    end
+
+    def places_start_at_one?(event, logger)
+      lowest_place = @placings[event[:name]].map { |p| p[:place] }.compact.min
+      return true if lowest_place == 1 || lowest_place.nil?
+
+      logger.error "places for 'event: #{event[:name]}' start at "\
+        "#{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)
+      @placings[event[:name]]
+        .select { |p| p[:place] }
+        .group_by { |p| p[:place] }
+    end
+
+    def places_with_expanded_ties(event)
+      # e.g. [6, 6, 8] -> [6, 7, 8]
+      placings_by_place(event).map do |place, placings|
+        (place..(place + (placings.size - 1))).to_a
+      end.flatten
+    end
+  end
+end