sciolyff 0.8.0 → 0.9.0

data/lib/sciolyff/validator/placings.rb

@@ -0,0 +1,120 @@
+# 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 = rep[:Events].group_by { |e| e[:name] }
+                                    .transform_values(&:first)
+      @teams_by_number = rep[:Teams].group_by { |t| t[:number] }
+                                    .transform_values(&:first)
+      @event_names = @events_by_name.keys
+      @team_numbers = @teams_by_number.keys
+      @placings = rep[:Placings]
+      @maximum_place = rep[:Tournament][:'maximum 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 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
+
+    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
+  end
+end

data/lib/sciolyff/validator/raws.rb

@@ -0,0 +1,19 @@
+# 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 = {
+      'tiebreaker rank': Integer
+    }.freeze
+  end
+end

data/lib/sciolyff/validator/sections.rb

@@ -0,0 +1,32 @@
+# 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 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|
+        correct = correct_types[key]
+        next true if (correct.instance_of?(Array) && correct.include?(value)) ||
+                     (value.instance_of? correct)
+
+        logger.error "#{key}: #{value} is not #{correct}"
+      end
+    end
+  end
+end

data/lib/sciolyff/validator/teams.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+
+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])
+      @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 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 in_a_subdivision_if_possible?(team, logger)
+      return true unless @subdivisions && !team[:subdivision]
+
+      logger.warn "missing subdivision for 'team: #{team[:number]}'"
+    end
+
+    private
+
+    def initialize_teams_info(teams)
+      @numbers = teams.map { |t| t[:number] }
+      @schools = teams.group_by { |t| [t[:school], t[:city], t[:state]] }
+      @subdivisions = teams.find { |t| t[:subdivision] }
+    end
+  end
+end

data/lib/sciolyff/validator/top_level.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+
+module SciolyFF
+  # Top-level sections of a SciolyFF file
+  class Validator::TopLevel < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      Tournament: Hash,
+      Events: Array,
+      Teams: Array,
+      Placings: Array
+    }.freeze
+
+    OPTIONAL = {
+      Penalties: Array
+    }.freeze
+  end
+end

data/lib/sciolyff/validator/tournament.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+
+module SciolyFF
+  # Checks for Tournament section of a SciolyFF file
+  class Validator::Tournament < Validator::Checker
+    include Validator::Sections
+
+    REQUIRED = {
+      location: String,
+      level: %w[Invitational Regionals States Nationals],
+      division: %w[A B C],
+      year: Integer,
+      date: Date
+    }.freeze
+
+    OPTIONAL = {
+      name: String,
+      state: String,
+      'short name': String,
+      'worst placings dropped': Integer,
+      'exempt placings': Integer,
+      'maximum place': Integer,
+      'per-event n': [true, false],
+      'n offset': Integer
+    }.freeze
+
+    def initialize(rep)
+      @maximum_place = rep[:Teams].count { |t| !t[:exhibition] }
+    end
+
+    def name_for_not_states_or_nationals?(tournament, logger)
+      level = tournament[:level]
+      return true if %w[States Nationals].include?(level) || tournament[:name]
+
+      logger.error 'name for Tournament required '\
+        "('level: #{level}' is not States or Nationals)"
+    end
+
+    def state_for_not_nationals?(tournament, logger)
+      return true if tournament[:level] == 'Nationals' || tournament[:state]
+
+      logger.error 'state for Tournament required '\
+        "('level: #{tournament[:level]}' is not Nationals)"
+    end
+
+    def short_name_is_relevant?(tournament, logger)
+      return true unless tournament[:'short name'] && !tournament[:name]
+
+      logger.error "'short name: #{tournament[:'short name']}' for Tournament "\
+        "requires a normal 'name:' as well"
+    end
+
+    def short_name_is_short?(tournament, logger)
+      return true if tournament[:'short name'].nil? ||
+                     tournament[:'short name'].length < tournament[:name].length
+
+      logger.error "'short name: #{tournament[:'short name']}' for Tournament "\
+        "is longer than normal 'name: #{tournament[:name]}'"
+    end
+
+    def maximum_place_within_range?(tournament, logger)
+      return true if tournament[:'maximum place'].nil? ||
+                     tournament[:'maximum place'].between?(1, @maximum_place)
+
+      logger.error "custom 'maximum place: #{tournament[:'maximum place']}' "\
+        "is not within range [1, #{@maximum_place}]"
+    end
+  end
+end

data/lib/sciolyff/validator.rb

@@ -0,0 +1,88 @@
+# 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/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
+      @checkers = {}
+    end
+
+    def valid?(rep_or_file)
+      @logger.flush
+
+      if rep_or_file.instance_of? String
+        valid_file?(rep_or_file, @logger)
+      else
+        valid_rep?(rep_or_file, @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_file?(path, logger)
+      rep = YAML.safe_load(
+        File.read(path),
+        permitted_classes: [Date],
+        symbolize_names: true
+      )
+    rescue StandardError => e
+      logger.error "could not read file 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) &&
+        [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
+      checks = klass.instance_methods - Checker.instance_methods
+      checks.map { |im| @checkers[klass].send im, rep, logger }.all?
+    end
+  end
+end

data/lib/sciolyff.rb

@@ -2,49 +2,6 @@
 
 require 'yaml'
 require 'date'
-require 'sciolyff/top_level'
-require 'sciolyff/sections'
-require 'sciolyff/tournament'
-require 'sciolyff/events'
-require 'sciolyff/teams'
-require 'sciolyff/placings'
-require 'sciolyff/scores'
-require 'sciolyff/penalties'
-require 'sciolyff/interpreter'
-
-# API methods for the Scioly File Format
-#
-module SciolyFF
-  class << self
-    attr_accessor :rep
-  end
-
-  # Assumes rep is the output of YAML.load
-  def self.validate(rep, opts: {})
-    SciolyFF.rep = rep
-
-    mt_args = []
-    mt_args << '--verbose' if opts[:verbose]
-
-    Minitest.run mt_args
-  end
 
-  def self.validate_file(path, opts: {})
-    file = File.read(path)
-    rep = YAML.safe_load(file, permitted_classes: [Date], symbolize_names: true)
-  rescue StandardError => e
-    puts 'Error: could not read file as YAML.'
-    warn e.message
-  else
-    puts FILE_VALIDATION_MESSAGE
-    validate(rep, opts: opts)
-  end
-
-  FILE_VALIDATION_MESSAGE = <<~STRING
-    Validating file with Minitest...
-
-    Overkill? Probably.
-    Doesn't give line numbers from original file? Yeah.
-
-  STRING
-end
+require 'sciolyff/interpreter'
+require 'sciolyff/validator'

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: sciolyff
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Em Zhan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-20 00:00:00.000000000 Z
+date: 2020-04-08 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
 - !ruby/object:Gem::Dependency
   name: optimist
   requirement: !ruby/object:Gem::Requirement
@@ -61,22 +47,31 @@ extra_rdoc_files: []
 files:
 - bin/sciolyff
 - lib/sciolyff.rb
-- lib/sciolyff/events.rb
 - lib/sciolyff/interpreter.rb
 - lib/sciolyff/interpreter/event.rb
+- lib/sciolyff/interpreter/html.rb
+- lib/sciolyff/interpreter/html/helpers.rb
+- lib/sciolyff/interpreter/html/template.html.erb
 - lib/sciolyff/interpreter/model.rb
 - lib/sciolyff/interpreter/penalty.rb
 - lib/sciolyff/interpreter/placing.rb
+- lib/sciolyff/interpreter/raw.rb
+- lib/sciolyff/interpreter/subdivisions.rb
 - lib/sciolyff/interpreter/team.rb
+- lib/sciolyff/interpreter/tiebreaks.rb
 - lib/sciolyff/interpreter/tournament.rb
 - lib/sciolyff/interpreter/ztestscript.rb
-- lib/sciolyff/penalties.rb
-- lib/sciolyff/placings.rb
-- lib/sciolyff/scores.rb
-- lib/sciolyff/sections.rb
-- lib/sciolyff/teams.rb
-- lib/sciolyff/top_level.rb
-- lib/sciolyff/tournament.rb
+- lib/sciolyff/validator.rb
+- lib/sciolyff/validator/checker.rb
+- lib/sciolyff/validator/events.rb
+- lib/sciolyff/validator/logger.rb
+- lib/sciolyff/validator/penalties.rb
+- lib/sciolyff/validator/placings.rb
+- lib/sciolyff/validator/raws.rb
+- lib/sciolyff/validator/sections.rb
+- lib/sciolyff/validator/teams.rb
+- lib/sciolyff/validator/top_level.rb
+- lib/sciolyff/validator/tournament.rb
 homepage: https://github.com/zqianem/sciolyff
 licenses:
 - MIT
@@ -96,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A file format for Science Olympiad tournament results.

data/lib/sciolyff/events.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/test'
-require 'set'
-
-module SciolyFF
-  # Tests that also serve as the specification for the sciolyff file format
-  #
-  class Events < Minitest::Test
-    def setup
-      skip unless SciolyFF.rep.instance_of? Hash
-      @events = SciolyFF.rep[:Events]
-      skip unless @events.instance_of? Array
-    end
-
-    def test_has_valid_events
-      @events.each do |event|
-        assert_instance_of Hash, event
-      end
-    end
-
-    def test_each_event_does_not_have_extra_info
-      @events.select { |e| e.instance_of? Hash }.each do |event|
-        info = Set.new %i[name trial trialed scoring tiers]
-        assert Set.new(event.keys).subset? info
-      end
-    end
-
-    def test_each_event_has_valid_name
-      @events.select { |e| e.instance_of? Hash }.each do |event|
-        assert_instance_of String, event[:name]
-      end
-    end
-
-    def test_each_event_has_valid_trial
-      @events.select { |e| e.instance_of? Hash }.each do |event|
-        assert_includes [true, false], event[:trial] if event.key? :trial
-      end
-    end
-
-    def test_each_event_has_valid_trialed
-      @events.select { |e| e.instance_of? Hash }.each do |event|
-        assert_includes [true, false], event[:trialed] if event.key? :trialed
-      end
-    end
-
-    def test_each_event_has_valid_scoring
-      @events.select { |e| e.instance_of? Hash }.each do |event|
-        assert_includes %w[high low], event[:scoring] if event.key? :scoring
-      end
-    end
-
-    def test_each_event_has_valid_tiers
-      @events.select { |e| e.instance_of? Hash }.each do |event|
-        assert_instance_of Integer, event[:tiers] if event.key? :tiers
-        assert_includes (1..), event[:tiers] if event.key? :tiers
-      end
-    end
-
-    def test_each_event_has_unique_name
-      names = @events.select { |e| e.instance_of? Hash }
-                     .map { |e| e[:name] }
-      assert_nil names.uniq!
-    end
-  end
-end

data/lib/sciolyff/penalties.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/test'
-require 'set'
-
-module SciolyFF
-  # Tests that also serve as the specification for the sciolyff file format
-  #
-  class Penalties < Minitest::Test
-    def setup
-      skip unless SciolyFF.rep.instance_of? Hash
-      @penalties = SciolyFF.rep[:Penalties]
-      skip unless @penalties.instance_of? Array
-    end
-
-    def test_has_valid_penalties
-      @penalties.each do |penalty|
-        assert_instance_of Hash, penalty
-      end
-    end
-
-    def test_each_penalty_does_not_have_extra_info
-      @penalties.select { |p| p.instance_of? Hash }.each do |penalty|
-        info = Set.new %i[team points]
-        assert Set.new(penalty.keys).subset? info
-      end
-    end
-
-    def test_each_penalty_has_valid_team
-      @penalties.select { |p| p.instance_of? Hash }.each do |penalty|
-        assert_instance_of Integer, penalty[:team]
-        skip unless SciolyFF.rep[:Teams].instance_of? Array
-
-        team_numbers = SciolyFF.rep[:Teams].map { |t| t[:number] }
-        assert_includes team_numbers, penalty[:team]
-      end
-    end
-
-    def test_each_penalty_has_valid_points
-      @penalties.select { |p| p.instance_of? Hash }.each do |penalty|
-        assert_instance_of Integer, penalty[:points]
-        assert penalty[:points] >= 0
-      end
-    end
-
-    def test_penalties_are_unique_for_team
-      teams = @penalties.select { |p| p.instance_of? Hash }
-                        .map { |p| p[:team] }
-      assert_nil teams.uniq!
-    end
-  end
-end