sciolyff 0.8.0 → 0.9.0

data/lib/sciolyff/placings.rb

@@ -1,198 +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 Placings < Minitest::Test
-    def setup
-      skip unless SciolyFF.rep.instance_of? Hash
-      @placings = SciolyFF.rep[:Placings]
-      skip unless @placings.instance_of? Array
-    end
-
-    def test_has_valid_placings
-      @placings.each do |placing|
-        assert_instance_of Hash, placing
-      end
-    end
-
-    def test_each_placing_does_not_have_extra_info
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        info = Set.new %i[event team participated disqualified exempt place tie]
-        info << :unknown
-        assert Set.new(placing.keys).subset? info
-      end
-    end
-
-    def test_each_placing_has_valid_event
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        assert_instance_of String, placing[:event]
-        skip unless SciolyFF.rep[:Events].instance_of? Array
-
-        event_names = SciolyFF.rep[:Events].map { |e| e[:name] }
-        assert_includes event_names, placing[:event]
-      end
-    end
-
-    def test_each_placing_has_valid_team
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        assert_instance_of Integer, placing[:team]
-        skip unless SciolyFF.rep[:Teams].instance_of? Array
-
-        team_numbers = SciolyFF.rep[:Teams].map { |t| t[:number] }
-        assert_includes team_numbers, placing[:team]
-      end
-    end
-
-    def test_each_placing_has_valid_participated
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        if placing.key? :participated
-          assert_includes [true, false], placing[:participated]
-        end
-      end
-    end
-
-    def test_each_placing_has_valid_disqualified
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        if placing.key? :disqualified
-          assert_includes [true, false], placing[:disqualified]
-        end
-      end
-    end
-
-    def test_each_placing_has_valid_exempt
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        assert_includes [true, false], placing[:exempt] if placing.key? :exempt
-      end
-    end
-
-    def test_each_team_has_correct_number_of_exempt_placings
-      skip unless SciolyFF.rep.instance_of? Hash
-      skip unless SciolyFF.rep[:Tournament].instance_of? Hash
-
-      exempt_placings = SciolyFF.rep[:Tournament][:'exempt placings']
-      exempt_placings = 0 if exempt_placings.nil?
-      skip unless exempt_placings.instance_of? Integer
-
-      @placings.select { |p| p.instance_of?(Hash) && p[:'exempt'] }
-               .group_by { |p| p[:team] }
-               .each do |team_number, placings|
-        assert placings.count == exempt_placings,
-               "Team number #{team_number} has the incorrect number of exempt "\
-               "placings (#{placings.count} instead of #{exempt_placings})"
-      end
-    end
-
-    def test_each_placing_has_valid_tie
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        next unless placing.key? :tie
-
-        assert_includes [true, false], placing[:tie]
-        next unless placing[:tie]
-
-        all_paired = @placings.select do |p_other|
-          p_other.instance_of?(Hash) &&
-            p_other != placing &&
-            p_other[:event] == placing[:event] &&
-            p_other[:place] == placing[:place]
-        end.all? { |p_other| p_other[:tie] }
-
-        assert all_paired,
-               "The event #{placing[:event]} has unpaired ties at "\
-               "#{placing[:place]}"
-      end
-    end
-
-    def test_each_placing_has_valid_unknown
-      skip if SciolyFF.rep[:Tournament]&.key? :'maximum place'
-
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        next unless placing.key? :unknown
-
-        assert_includes [true, false], placing[:unknown]
-        next unless placing[:unknown]
-
-        skip unless SciolyFF.rep[:Events].instance_of? Array
-
-        event = SciolyFF.rep[:Events].find do |e|
-          e[:name] == placing[:event]
-        end
-        assert event[:trial] || event[:trialed] || placing[:exempt],
-               'Cannot have unknown place for non-trial/trialed event '\
-               'or non-exempt place'
-      end
-    end
-
-    def test_each_placing_has_valid_place
-      @placings.select { |p| p.instance_of? Hash }.each do |placing|
-        next if placing[:disqualified] == true ||
-                placing.key?(:participated) ||
-                placing[:unknown] == true ||
-                placing[:exempt] == true
-
-        assert_instance_of Integer, placing[:place]
-        max_place = @placings.count do |p|
-          p[:event] == placing[:event] &&
-            !p[:disqualified] &&
-            p[:participated] != false
-        end
-        assert_includes 1..max_place, placing[:place],
-                        "The event #{placing[:event]} "\
-                        'has an out-of-range placing'
-      end
-    end
-
-    def test_placings_are_unique_for_event_and_place
-      skip unless SciolyFF.rep[:Events].instance_of? Array
-
-      SciolyFF.rep[:Events].each do |event|
-        next unless event.instance_of? Hash
-
-        places = @placings.select { |p| p[:event] == event[:name] }
-                          .reject { |p| p[:tie] }
-                          .map { |p| p[:place] }
-                          .compact
-
-        dups = places.select.with_index do |p, i|
-          places.index(p) != i
-        end
-
-        assert_empty dups,
-                     "The event #{event[:name]} has unmarked ties at #{dups}"
-      end
-    end
-
-    def test_placings_are_unique_for_event_and_team
-      skip unless SciolyFF.rep[:Teams].instance_of? Array
-
-      SciolyFF.rep[:Teams].each do |team|
-        next unless team.instance_of? Hash
-
-        assert_nil @placings.select { |p| p[:team] == team[:number] }
-                            .map { |p| p[:event] }
-                            .compact
-                            .uniq!
-      end
-    end
-
-    def test_each_team_has_placings_for_all_events
-      skip unless SciolyFF.rep[:Teams].instance_of?(Array) &&
-                  SciolyFF.rep[:Events].instance_of?(Array)
-
-      SciolyFF.rep[:Teams].select { |t| t.instance_of? Hash }.each do |team|
-        events = SciolyFF.rep[:Events].select { |e| e.instance_of? Hash }
-                         .map { |e| e[:name] }
-
-        events_with_placings =
-          @placings.select { |p| p.instance_of? Hash }
-                   .select { |p| p[:team] == team[:number] }
-                   .map { |p| p[:event] }
-
-        assert_equal events.sort, events_with_placings.sort
-      end
-    end
-  end
-end

data/lib/sciolyff/scores.rb

@@ -1,148 +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 Scores < Minitest::Test
-    def setup
-      skip unless SciolyFF.rep.instance_of? Hash
-      @scores = SciolyFF.rep[:Scores]
-      skip unless @scores.instance_of? Array
-    end
-
-    def test_has_valid_scores
-      @scores.each do |score|
-        assert_instance_of Hash, score
-      end
-    end
-
-    def test_each_score_does_not_have_extra_info
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        a = %i[event team participated disqualified exempt unknown score tier]
-        a << :'tiebreaker place'
-        info = Set.new a
-        assert Set.new(score.keys).subset? info
-      end
-    end
-
-    def test_each_score_has_valid_event
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        assert_instance_of String, score[:event]
-        skip unless SciolyFF.rep[:Events].instance_of? Array
-
-        event_names = SciolyFF.rep[:Events].map { |e| e[:name] }
-        assert_includes event_names, score[:event]
-      end
-    end
-
-    def test_each_score_has_valid_team
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        assert_instance_of Integer, score[:team]
-        skip unless SciolyFF.rep[:Teams].instance_of? Array
-
-        team_numbers = SciolyFF.rep[:Teams].map { |t| t[:number] }
-        assert_includes team_numbers, score[:team]
-      end
-    end
-
-    def test_each_score_has_valid_participated
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        if score.key? :participated
-          assert_includes [true, false], score[:participated]
-        end
-      end
-    end
-
-    def test_each_score_has_valid_disqualified
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        if score.key? :disqualified
-          assert_includes [true, false], score[:disqualified]
-        end
-      end
-    end
-
-    def test_each_score_has_valid_exempt
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        assert_includes [true, false], score[:exempt] if score.key? :exempt
-      end
-    end
-
-    def test_each_score_has_valid_unknown
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        assert_includes [true, false], score[:unknown] if score.key? :unknown
-      end
-    end
-
-    def test_each_score_has_valid_score
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        next if score[:disqualified] == true ||
-                score.key?(:participated) ||
-                placing[:exempt] == true
-
-        assert_kind_of Numeric, score[:score]
-      end
-    end
-
-    def test_each_score_has_valid_tiebreaker_place
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        next unless score.key? 'tiebreaker place'
-
-        max_place = @scores.count do |s|
-          s[:event] == score[:event] &&
-            s[:score] == score[:score]
-        end
-        assert_instance_of Integer, score['tiebreaker place']
-        assert_includes 1..max_place, score['tiebreaker place']
-      end
-    end
-
-    def test_each_score_has_valid_tier
-      skip unless SciolyFF.rep[:Events].instance_of? Array
-
-      @scores.select { |s| s.instance_of? Hash }.each do |score|
-        next unless score.key? :tier
-
-        assert_instance_of Integer, score[:tier]
-
-        max_tier = SciolyFF.rep[:Events].find do |event|
-          event[:name] == score[:event]
-        end&.[](:tiers)
-
-        refute_nil max_tier, "#{score[:event]} does not have tiers"
-        assert_includes 1..max_tier, score[:tier]
-      end
-    end
-
-    def test_scores_are_unique_for_event_and_team
-      skip unless SciolyFF.rep[:Teams].instance_of? Array
-
-      SciolyFF.rep[:Teams].each do |team|
-        next unless team.instance_of? Hash
-
-        assert_nil @scores.select { |s| s[:team] == team[:number] }
-                          .map { |s| s[:event] }
-                          .compact
-                          .uniq!
-      end
-    end
-
-    def test_each_team_has_scores_for_all_events
-      skip unless SciolyFF.rep[:Teams].instance_of?(Array) &&
-                  SciolyFF.rep[:Events].instance_of?(Array)
-
-      SciolyFF.rep[:Teams].select { |t| t.instance_of? Hash }.each do |team|
-        events = SciolyFF.rep[:Events].select { |e| e.instance_of? Hash }
-                         .map { |e| e[:name] }
-
-        events_with_scores = @scores.select { |s| s.instance_of? Hash }
-                                    .select { |s| s[:team] == team[:number] }
-                                    .map { |s| s[:event] }
-
-        assert_equal events, events_with_scores
-      end
-    end
-  end
-end

data/lib/sciolyff/sections.rb

@@ -1,40 +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 Sections < Minitest::Test
-    def setup
-      @rep = SciolyFF.rep
-      skip unless @rep.instance_of? Hash
-    end
-
-    def test_has_tournament
-      assert_instance_of Hash, @rep[:Tournament]
-    end
-
-    def test_has_events
-      assert_instance_of Array, @rep[:Events]
-    end
-
-    def test_has_teams
-      assert_instance_of Array, @rep[:Teams]
-    end
-
-    def test_has_placings
-      assert_instance_of Array, @rep[:Placings]
-    end
-
-    def test_has_penalties
-      assert_instance_of Array, @rep[:Penalties] if @rep.key? :Penalties
-    end
-
-    def test_does_not_have_extra_sections
-      sections = Set.new %i[Tournament Events Teams Placings Scores Penalties]
-      assert Set.new(@rep.keys).subset? sections
-    end
-  end
-end

data/lib/sciolyff/teams.rb

@@ -1,96 +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 Teams < Minitest::Test
-    def setup
-      skip unless SciolyFF.rep.instance_of? Hash
-      @teams = SciolyFF.rep[:Teams]
-      skip unless @teams.instance_of? Array
-    end
-
-    def test_has_valid_teams
-      @teams.each do |team|
-        assert_instance_of Hash, team
-      end
-    end
-
-    def test_each_team_does_not_have_extra_info
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        fo = Set.new %i[school suffix subdivision exhibition number city state]
-        fo << :'school abbreviation'
-        assert Set.new(team.keys).subset? fo
-      end
-    end
-
-    def test_each_team_has_valid_school
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_instance_of String, team[:school]
-      end
-    end
-
-    def test_each_team_has_valid_school_abbreviation
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_instance_of String, team[:'school abbreviation'] \
-          if team.key? :'school abbreviation'
-      end
-    end
-
-    def test_each_team_has_valid_suffix
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_instance_of String, team[:suffix] if team.key? :suffix
-      end
-    end
-
-    def test_each_team_has_valid_subdivision
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_instance_of String, team[:subdivision] \
-          if team.key? :subdivision
-      end
-    end
-
-    def test_each_team_has_valid_exhibition
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_includes [true, false], team[:exhibition] \
-          if team.key? :exhibition
-      end
-    end
-
-    def test_each_team_has_valid_number
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_instance_of Integer, team[:number]
-      end
-    end
-
-    def test_each_team_has_valid_city
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_instance_of String, team[:city] if team.key? :city
-      end
-    end
-
-    def test_each_team_has_valid_state
-      @teams.select { |t| t.instance_of? Hash }.each do |team|
-        assert_instance_of String, team[:state]
-      end
-    end
-
-    def test_each_team_has_unique_number
-      numbers = @teams.select { |t| t.instance_of? Hash }
-                      .map { |t| t[:number] }
-      assert_nil numbers.uniq!
-    end
-
-    def test_each_suffix_is_unique_per_school
-      @teams.select { |t| t.instance_of? Hash }
-            .group_by { |t| [t[:school], t[:state], t[:city]] }
-            .each do |group, teams|
-        assert_nil teams.map { |t| t[:suffix] }.compact.uniq!,
-                   "#{group} has the same suffix for multiple teams"
-      end
-    end
-  end
-end

data/lib/sciolyff/top_level.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/test'
-
-module SciolyFF
-  # Tests that also serve as the specification for the sciolyff file format
-  #
-  class TopLevel < Minitest::Test
-    def test_is_hash
-      assert_instance_of Hash, SciolyFF.rep
-    end
-  end
-end

data/lib/sciolyff/tournament.rb

@@ -1,94 +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 Tournament < Minitest::Test
-    def setup
-      skip unless SciolyFF.rep.instance_of? Hash
-      @tournament = SciolyFF.rep[:Tournament]
-      skip unless @tournament.instance_of? Hash
-    end
-
-    def test_has_info
-      refute_nil @tournament[:location]
-      refute_nil @tournament[:level]
-      refute_nil @tournament[:division]
-      refute_nil @tournament[:year]
-      refute_nil @tournament[:date]
-    end
-
-    def test_does_not_have_extra_info
-      info = Set.new %i[name location level division state year date]
-      info << :'short name' << :'worst placings dropped' << :'exempt placings'
-      info << :'maximum place'
-      assert Set.new(@tournament.keys).subset? info
-    end
-
-    def test_has_valid_name
-      skip unless @tournament.key? :name
-      assert_instance_of String, @tournament[:name]
-    end
-
-    def test_has_valid_short_name
-      skip unless @tournament.key? :'short name'
-      assert @tournament.key?(:name), 'Cannot have short name without name'
-      assert_instance_of String, @tournament[:'short name']
-
-      skip unless @tournament[:name].instance_of? String
-      assert @tournament[:'short name'].length < @tournament[:name].length,
-             'Length of short name must be shorter than length of name'
-    end
-
-    def test_has_valid_location
-      skip unless @tournament.key? :location
-      assert_instance_of String, @tournament[:location]
-    end
-
-    def test_has_valid_level
-      skip unless @tournament.key? :level
-      level = @tournament[:level]
-      assert_includes %w[Invitational Regionals States Nationals], level
-    end
-
-    def test_has_valid_division
-      skip unless @tournament.key? :division
-      assert_includes %w[A B C], @tournament[:division]
-    end
-
-    def test_has_valid_state
-      skip unless @tournament.key? :level
-      level = @tournament[:level]
-      skip unless %w[Regionals States].include? level
-      assert_instance_of String, @tournament[:state]
-    end
-
-    def test_has_valid_year
-      skip unless @tournament.key? :year
-      assert_instance_of Integer, @tournament[:year]
-    end
-
-    def test_has_valid_date
-      skip unless @tournament.key? :date
-      assert_instance_of Date, @tournament[:date]
-    end
-
-    def test_has_valid_worst_placings_dropped
-      skip unless @tournament.key? :'worst placings dropped'
-      assert_instance_of Integer, @tournament[:'worst placings dropped']
-    end
-
-    def test_has_valid_exempt_placings
-      skip unless @tournament.key? :'exempt placings'
-      assert_instance_of Integer, @tournament[:'exempt placings']
-    end
-
-    def test_has_valid_maximum_place
-      skip unless @tournament.key? :'maximum place'
-      assert_instance_of Integer, @tournament[:'maximum place']
-    end
-  end
-end