sciolyff 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 557d9424fccd8e1ef1cf039ac09a7f775475ab041238ce73a1eca5ce0e2ad7a1
+  data.tar.gz: 79c56f1488d33f5fa250c08216492da04dbfac9f980cf953673f3b3df48421a6
+SHA512:
+  metadata.gz: a85a02fcb51e980d635d63a612fde179217118a81385e157001d91d733dbeea359b5d35fa24d94317555ce10ea72c1e26e70c829b2dade87689d4afe1bbbec35
+  data.tar.gz: 603d152c2efc7de191c050703add7803c4561c4c91b29a4ca5c9f893527b53d1259db11029508bf54d8410f4946b13925993370cd763eca998c6ed394d83d9fc

data/bin/sciolyff

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optimist'
+require 'yaml'
+require 'sciolyff'
+
+opts = Optimist.options do
+  version 'sciolyff 0.2.0'
+  banner <<~STRING
+    Checks if a given file is in the Scioly File Format
+
+    Usage:
+            #{File.basename(__FILE__)} [options] <file>
+
+    where [options] are:
+  STRING
+  opt :verbose, 'Run Minitest in verbose mode'
+end
+
+if ARGV.first.nil? || !File.exist?(ARGV.first)
+  puts "Error: file '#{ARGV.first}' not found."
+  puts 'Try --help for help.'
+  exit 1
+end
+
+puts 'More than one file given, ignoring all but first.' if ARGV.length > 1
+
+SciolyFF.validate_file(ARGV.first, opts: opts)

data/lib/sciolyff/events.rb

@@ -0,0 +1,66 @@
+# 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

@@ -0,0 +1,51 @@
+# 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]
+      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

data/lib/sciolyff/placings.rb

@@ -0,0 +1,124 @@
+# 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 place]
+        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_place
+      @placings.select { |p| p.instance_of? Hash }.each do |placing|
+        next if placing[:disqualified] == true ||
+                placing.key?(:participated)
+
+        assert_instance_of Integer, placing[:place]
+        max_place = @placings.count { |p| p[:event] == placing[:event] }
+        assert_includes 1..max_place, placing[:place]
+      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] }
+                          .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 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, events_with_placings
+      end
+    end
+  end
+end

data/lib/sciolyff/scores.rb

@@ -0,0 +1,135 @@
+# 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 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_score
+      @scores.select { |s| s.instance_of? Hash }.each do |score|
+        next if score[:disqualified] == true ||
+                score[:participated] == false
+
+        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

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,79 @@
+# 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]
+        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_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
+  end
+end

data/lib/sciolyff/top_level.rb

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,67 @@
+# 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]
+      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_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
+  end
+end

data/lib/sciolyff.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'yaml'
+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'
+
+# 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
+
+  # Wrapper class around a SciolyFF Ruby object representation with utility
+  # methods to help in displaying results
+  class Helper
+    attr_reader :rep, :tournament, :events_by_name, :teams_by_number
+    attr_reader :placings_by_event, :placings_by_team, :penalties_by_team
+
+    def initialize(rep)
+      @rep = rep
+      @tournament = rep[:Tournament]
+      @events_by_name = index_array(rep[:Events], [:name])
+      @teams_by_number = index_array(rep[:Teams], [:number])
+      @placings_by_event = index_array(rep[:Placings], %i[event team])
+      @placings_by_team = index_array(rep[:Placings], %i[team event])
+      return unless rep[:Penalties]
+
+      @penalties_by_team = index_array(rep[:Penalties], [:team])
+    end
+
+    def event_points(team_number, event_name)
+      placing = @placings_by_event[event_name][team_number]
+
+      if placing[:disqualified] then @teams_by_number.count + 2
+      elsif placing[:participated] == false then @teams_by_number.count + 1
+      elsif placing[:place].nil? then @teams_by_number.count
+      else calculate_event_points(placing)
+      end
+    end
+
+    def team_points(team_number)
+      @placings_by_team[team_number]
+        .values
+        .reject { |p| @events_by_name[p[:event]][:trial] }
+        .reject { |p| @events_by_name[p[:event]][:trialed] }
+        .sum { |p| event_points(team_number, p[:event]) } \
+      + team_points_from_penalties(team_number)
+    end
+
+    def sort_teams_by_rank
+      @teams_by_number
+        .values
+        .sort do |a, b|
+        cmp = team_points(a[:number]) - team_points(b[:number])
+        cmp.zero? ? break_tie(a[:number], b[:number]) : cmp
+      end
+    end
+
+    def medal_counts(team_number)
+      (1..(@teams_by_number.count + 2)).map do |m|
+        @events_by_name
+          .values
+          .reject { |e| e[:trial] || e[:trialed] }
+          .count { |e| event_points(team_number, e[:name]) == m }
+      end
+    end
+
+    private
+
+    def index_array(arr, index_keys)
+      return arr.first if index_keys.empty?
+
+      indexed_hash = arr.group_by { |x| x[index_keys.first] }
+
+      indexed_hash.transform_values do |a|
+        index_array(a, index_keys.drop(1))
+      end
+    end
+
+    def calculate_event_points(placing)
+      # Points is place minus number of exhibition teams with a better place
+      placing[:place] -
+        @placings_by_event[placing[:event]]
+        .values
+        .select { |p| @teams_by_number[p[:team]][:exhibition] && p[:place] }
+        .count { |p| p[:place] < placing[:place] }
+    end
+
+    def team_points_from_penalties(team_number)
+      if @penalties_by_team.nil? || @penalties_by_team[team_number].nil? then 0
+      else @penalties_by_team[team_number][:points]
+      end
+    end
+
+    def break_tie(team_number_a, team_number_b)
+      medal_counts(team_number_a)
+        .zip(medal_counts(team_number_b))
+        .map { |count| count.last - count.first }
+        .find(proc { team_number_a <=> team_number_b }, &:nonzero?)
+    end
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: sciolyff
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Em Zhan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-15 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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: 
+email: 
+executables:
+- sciolyff
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/sciolyff
+- lib/sciolyff.rb
+- lib/sciolyff/events.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
+homepage: https://github.com/zqianem/sciolyff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A file format for Science Olympiad tournament results.
+test_files: []