sciolyff-duosmium 0.13.0

data/lib/sciolyff/validator/logger.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Prints extra information produced by validation process
+  class Validator::Logger
+    ERROR = 0
+    WARN  = 1
+    INFO  = 2
+    DEBUG = 3
+
+    attr_reader :log, :options
+
+    def initialize(loglevel, **options)
+      @loglevel = loglevel
+      @options = options
+      flush
+    end
+
+    def flush
+      @log = String.new
+    end
+
+    def error(msg)
+      return false if @loglevel < ERROR
+
+      @log << "ERROR (invalid SciolyFF): #{msg}\n"
+      false # convenient for using logging the error as return value
+    end
+
+    def warn(msg)
+      return true if @loglevel < WARN
+
+      @log << "WARNING (still valid SciolyFF): #{msg}\n"
+    end
+
+    def info(msg)
+      return true if @loglevel < INFO
+
+      @log << "INFO: #{msg}\n"
+    end
+
+    def debug(msg)
+      return true if @loglevel < DEBUG
+
+      @log << "DEBUG (possible intentional exception): #{msg}\n"
+    end
+  end
+end

data/lib/sciolyff/validator/penalties.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+
+module SciolyFF
+  # Checks for one penalty in the Penalties section of a SciolyFF file
+  class Validator::Penalties < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      team: Integer,
+      points: Integer
+    }.freeze
+
+    OPTIONAL = {
+    }.freeze
+  end
+end

data/lib/sciolyff/validator/placings.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+
+module SciolyFF
+  # Checks for one placing in the Placings section of a SciolyFF file
+  class Validator::Placings < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      event: String,
+      team: Integer
+    }.freeze
+
+    OPTIONAL = {
+      place: Integer,
+      participated: [true, false],
+      disqualified: [true, false],
+      exempt: [true, false],
+      tie: [true, false],
+      unknown: [true, false],
+      raw: Hash
+    }.freeze
+
+    def initialize(rep)
+      @events_by_name = group(rep[:Events], :name)
+      @teams_by_number = group(rep[:Teams], :number)
+      @event_names = @events_by_name.keys
+      @team_numbers = @teams_by_number.keys
+      @placings = rep[:Placings]
+      @maximum_place = rep[:Tournament][:'maximum place']
+      @has_places = rep[:Placings].any? { |p| p[:place] }
+    end
+
+    def matching_event?(placing, logger)
+      return true if @event_names.include? placing[:event]
+
+      logger.error "'event: #{placing[:event]}' in Placings "\
+        'does not match any event name in Events'
+    end
+
+    def matching_team?(placing, logger)
+      return true if @team_numbers.include? placing[:team]
+
+      logger.error "'team: #{placing[:team]}' in Placings "\
+        'does not match any team number in Teams'
+    end
+
+    def unique_event_and_team?(placing, logger)
+      return true if @placings.count do |other|
+        placing[:event] == other[:event] && placing[:team] == other[:team]
+      end == 1
+
+      logger.error "duplicate #{placing_log(placing)}"
+    end
+
+    def having_a_place_makes_sense?(placing, logger)
+      return true unless placing[:place] &&
+                         (placing[:participated] == false ||
+                          placing[:disqualified] ||
+                          placing[:unknown] ||
+                          placing[:raw])
+
+      logger.error 'having a place does not make sense for '\
+        "#{placing_log(placing)}"
+    end
+
+    def having_a_raw_makes_sense?(placing, logger)
+      return true unless placing[:raw] &&
+                         (placing[:participated] == false ||
+                          placing[:disqualified] ||
+                          placing[:unknown] ||
+                          placing[:place])
+
+      logger.error 'having raw section does not make sense for '\
+        "#{placing_log(placing)}"
+    end
+
+    def having_a_tie_makes_sense?(placing, logger)
+      return true unless placing.key?(:tie) && placing[:raw]
+
+      logger.error 'having a tie value does make sense for '\
+        "#{placing_log(placing)}"
+    end
+
+    def possible_participated_disqualified_combination?(placing, logger)
+      return true unless placing[:participated] == false &&
+                         placing[:disqualified]
+
+      logger.error 'impossible participation-disqualified combination for '\
+        "#{placing_log(placing)}"
+    end
+
+    def possible_unknown_disqualified_combination?(placing, logger)
+      return true unless placing[:unknown] && placing[:disqualified]
+
+      logger.error 'impossible unknown-disqualified combination for '\
+        "#{placing_log(placing)}"
+    end
+
+    def unknown_allowed?(placing, logger)
+      event = @events_by_name[placing[:event]]
+      team = @teams_by_number[placing[:team]]
+      return true unless invalid_unknown?(placing, event, team)
+
+      logger.error "unknown place not allowed for #{placing_log(placing)} "\
+        '(either placing must be exempt or event must be trial/trialed)'
+    end
+
+    def no_mix_of_raws_and_places(placing, logger)
+      return true unless @has_places && placing.key?(:raw)
+
+      logger.error "cannot mix 'raw:' and 'place:' in same file"
+    end
+
+    private
+
+    def placing_log(placing)
+      "placing with 'team: #{placing[:team]}' and 'event: #{placing[:event]}'"
+    end
+
+    def invalid_unknown?(placing, event, team)
+      placing[:unknown] &&
+        @maximum_place.nil? &&
+        !placing[:exempt] &&
+        !event[:trial] &&
+        !event[:trialed] &&
+        !team[:exhibition]
+    end
+
+    def group(arr, key)
+      arr.group_by { |e| e[key] }.transform_values(&:first)
+    end
+  end
+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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+
+module SciolyFF
+  # Checks for one raw of a placing in the Placings section of a SciolyFF file
+  class Validator::Raws < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      score: Float
+    }.freeze
+
+    OPTIONAL = {
+      'tier': Integer,
+      'tiebreaker rank': Integer
+    }.freeze
+
+    def score_is_not_nan?(raw, logger)
+      return true unless raw[:score].nan?
+
+      logger.error "'score: .nan' (not a number) is not permitted"
+    end
+
+    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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Generic tests for (sub-)sections and types. Including classes must have two
+  # hashes REQUIRED and OPTIONAL (see other files in this dir for examples)
+  module Validator::Sections
+    def rep_is_hash?(rep, logger)
+      return true if rep.instance_of? Hash
+
+      logger.error "entry in #{section_name} is not a Hash"
+    end
+
+    def all_required_sections?(rep, logger)
+      missing = self.class::REQUIRED.keys - rep.keys
+      return true if missing.empty?
+
+      logger.error "missing required sections: #{missing.join ', '}"
+    end
+
+    def no_extra_sections?(rep, logger)
+      extra = rep.keys - (self.class::REQUIRED.keys + self.class::OPTIONAL.keys)
+      return true if extra.empty?
+
+      logger.error "extra section(s) found: #{extra.join ', '}"
+    end
+
+    def sections_are_correct_type?(rep, logger)
+      correct_types = self.class::REQUIRED.merge self.class::OPTIONAL
+      rep.all? do |key, value|
+        type = correct_types[key]
+        next true if correct_type?(type, value)
+
+        logger.error "#{key}: #{value} is not #{type}"
+      end
+    end
+
+    private
+
+    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
+
+    def section_name
+      self.class.to_s.split('::').last
+    end
+  end
+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

data/lib/sciolyff/validator/teams.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+require 'sciolyff/validator/canonical'
+
+module SciolyFF
+  # Checks for one team in the Teams section of a SciolyFF file
+  class Validator::Teams < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      number: Integer,
+      school: String,
+      state: String
+    }.freeze
+
+    OPTIONAL = {
+      'school abbreviation': String,
+      subdivision: String,
+      suffix: String,
+      city: String,
+      disqualified: [true, false],
+      exhibition: [true, false]
+    }.freeze
+
+    def initialize(rep)
+      initialize_teams_info(rep[:Teams])
+      @subdivisions = rep[:Subdivisions]&.map { |s| s[:name] } || []
+      @placings = rep[:Placings].group_by { |p| p[:team] }
+      @exempt = rep[:Tournament][:'exempt placings'] || 0
+    end
+
+    def unique_number?(team, logger)
+      return true if @numbers.count(team[:number]) == 1
+
+      logger.error "duplicate team number: #{team[:number]}"
+    end
+
+    def unique_suffix_per_school?(team, logger)
+      full_school = [team[:school], team[:city], team[:state]]
+      return true if @schools[full_school].count do |other|
+        !other[:suffix].nil? && other[:suffix] == team[:suffix]
+      end <= 1
+
+      logger.error "team number #{team[:number]} has the same suffix "\
+        'as another team from the same school'
+    end
+
+    def suffix_needed?(team, logger)
+      rep = [team[:school], team[:city], team[:state]]
+      return true unless team[:suffix] && @schools[rep].count == 1
+
+      logger.warn "team number #{team[:number]} may have unnecessary "\
+        "suffix: #{team[:suffix]}"
+    end
+
+    def unambiguous_cities_per_school?(team, logger)
+      return true unless @schools.keys.find do |other|
+        team[:city].nil? && !other[1].nil? &&
+        team[:school] == other[0] &&
+        team[:state] == other[2]
+      end
+
+      logger.error "city for team number #{team[:number]} is ambiguous, "\
+        'value is required for unambiguity'
+    end
+
+    def correct_number_of_exempt_placings?(team, logger)
+      count = @placings[team[:number]].count { |p| p[:exempt] }
+      return true if count == @exempt || team[:exhibition]
+
+      logger.error "'team: #{team[:number]}' has incorrect number of "\
+        "exempt placings (#{count} insteand of #{@exempt})"
+    end
+
+    def matching_subdivision?(team, logger)
+      sub = team[:subdivision]
+      return true if sub.nil? || @subdivisions.include?(sub)
+
+      logger.error "'subdivision: #{sub}' does not match any name in "\
+        'section Subdivisions'
+    end
+
+    def in_a_subdivision_if_possible?(team, logger)
+      return true unless !@subdivisions.empty? && !team[:subdivision]
+
+      logger.warn "missing subdivision for 'team: #{team[:number]}'"
+    end
+
+    include Validator::Canonical
+
+    def in_canonical_list?(team, logger)
+      rep = [team[:school], team[:city], team[:state]]
+      return true if canonical?(rep, 'schools.csv', logger)
+
+      location = rep[1..-1].compact.join ', '
+      logger.warn "non-canonical school: #{team[:school]} in #{location}"
+    end
+
+    private
+
+    def initialize_teams_info(teams)
+      @numbers = teams.map { |t| t[:number] }
+      @schools = teams.group_by { |t| [t[:school], t[:city], t[:state]] }
+    end
+  end
+end