sciolyff 0.8.0 → 0.9.0

data/lib/sciolyff/interpreter/html.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Grants ability to convert a SciolyFF file into stand-alone HTML and other
+  # formats (YAML, JSON)
+  module Interpreter::HTML
+    require 'erb'
+    require 'sciolyff/interpreter/html/helpers'
+    require 'json'
+
+    def html
+      helpers = Interpreter::HTML::Helpers.new
+      ERB.new(
+        helpers.template,
+        trim_mode: '<>'
+      ).result(helpers.get_binding(self))
+         .gsub(/^\s*$/, '')   # remove empty lines
+         .gsub(/\s+$/, '')    # remove trailing whitespace
+    end
+
+    def yaml
+      stringify_keys(@rep).to_yaml
+    end
+
+    def json(pretty: false)
+      return JSON.pretty_generate(@rep) if pretty
+
+      @rep.to_json
+    end
+
+    private
+
+    def stringify_keys(hash)
+      return hash unless hash.instance_of? Hash
+
+      hash.map do |k, v|
+        new_k = k.to_s
+        new_v = case v
+                when Array then v.map { |e| stringify_keys(e) }
+                when Hash then stringify_keys(v)
+                else v
+                end
+        [new_k, new_v]
+      end.to_h
+    end
+  end
+end

data/lib/sciolyff/interpreter/placing.rb

@@ -5,13 +5,17 @@ require 'sciolyff/interpreter/model'
 module SciolyFF
   # Models the result of a team participating (or not) in an event
   class Interpreter::Placing < Interpreter::Model
+    require 'sciolyff/interpreter/raw'
+
     def link_to_other_models(interpreter)
       super
       @event = interpreter.events.find { |e| e.name   == @rep[:event] }
       @team  = interpreter.teams .find { |t| t.number == @rep[:team]  }
+
+      link_to_placing_in_subdivision_interpreter(interpreter)
     end
 
-    attr_reader :event, :team
+    attr_reader :event, :team, :subdivision_placing
 
     def participated?
       @rep[:participated] == true || @rep[:participated].nil?
@@ -30,11 +34,19 @@ module SciolyFF
     end
 
     def tie?
-      @rep[:tie] == true
+      raw? ? @tie ||= event.raws.count(raw) > 1 : @rep[:tie] == true
     end
 
     def place
-      @rep[:place]
+      raw? ? @place ||= event.raws.find_index(raw) + 1 : @rep[:place]
+    end
+
+    def raw
+      @raw ||= Raw.new(@rep[:raw], event.low_score_wins?) if raw?
+    end
+
+    def raw?
+      @rep.key? :raw
     end
 
     def did_not_participate?
@@ -56,12 +68,13 @@ module SciolyFF
     end
 
     def isolated_points
-      n = event.maximum_place
+      max_place = event.maximum_place
+      n = max_place + tournament.n_offset
 
       if    disqualified? then n + 2
       elsif did_not_participate? then n + 1
       elsif participation_only? || unknown? then n
-      else  [calculate_points, n].min
+      else  [calculate_points, max_place].min
       end
     end
 
@@ -80,7 +93,11 @@ module SciolyFF
 
     def points_limited_by_maximum_place?
       tournament.custom_maximum_place? &&
-        (unknown? || (place && calculate_points > event.maximum_place))
+        (unknown? ||
+         (place &&
+          (calculate_points > event.maximum_place ||
+           calculate_points == event.maximum_place && tie?
+          )))
     end
 
     private
@@ -98,5 +115,13 @@ module SciolyFF
           p.place < place
       end
     end
+
+    def link_to_placing_in_subdivision_interpreter(interpreter)
+      return @subdivision_placing = nil unless (sub = team.subdivision)
+
+      @subdivision_placing = interpreter.subdivisions[sub].placings.find do |p|
+        p.event.name == event.name && p.team.number == team.number
+      end
+    end
   end
 end

data/lib/sciolyff/interpreter/raw.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Models the raw score representation for a Placing
+  class Interpreter::Placing::Raw
+    def initialize(rep, low_score_wins)
+      @rep = rep
+      @low_score_wins = low_score_wins
+    end
+
+    def score
+      @rep[:score]
+    end
+
+    def tiered?
+      tier > 1
+    end
+
+    def tier
+      @rep[:tier] || 1
+    end
+
+    def lost_tiebreaker?
+      tiebreaker_rank > 1
+    end
+
+    def tiebreaker_rank
+      @rep[:'tiebreaker rank'] || Float::INFINITY
+    end
+
+    def ==(other)
+      score == other.score &&
+        tier == other.tier &&
+        tiebreaker_rank == other.tiebreaker_rank
+    end
+
+    def <=>(other)
+      [
+        tier,
+        @low_score_wins ? score : -score,
+        tiebreaker_rank
+      ] <=>
+        [
+          other.tier,
+          @low_score_wins ? other.score : -other.score,
+          other.tiebreaker_rank
+        ]
+    end
+  end
+end

data/lib/sciolyff/interpreter/subdivisions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Subdivision logic, to be used in the Interpreter class
+  module Interpreter::Subdivisions
+    private
+
+    def subdivision_rep(sub)
+      # make a deep copy of rep and remove teams not in the subdivision
+      rep = Marshal.load(Marshal.dump(@rep))
+      rep[:Teams].select! { |t| t.delete(:subdivision) == sub }
+
+      team_numbers = rep[:Teams].map { |t| t[:number] }
+      rep[:Placings].select! { |p| team_numbers.include? p[:team] }
+
+      fix_placings_for_existing_teams(rep)
+      rep
+    end
+
+    def fix_placings_for_existing_teams(rep)
+      rep[:Placings]
+        .group_by { |p| p[:event] }
+        .each { |_, ep| fix_event_placings(ep) }
+    end
+
+    def fix_event_placings(event_placings)
+      event_placings
+        .select { |p| p[:place] }
+        .sort_by { |p| p[:place] }
+        .each_with_index { |p, i| p[:temp_place] = i + 1 }
+        .each { |p| fix_placing_ties(p, event_placings) }
+        .each { |p| p.delete(:temp_place) }
+    end
+
+    def fix_placing_ties(placing, event_placings)
+      ties = event_placings.select { |o| o[:place] == placing[:place] }
+      placing[:place] = ties.map { |t| t[:temp_place] }.max - ties.count + 1
+      ties.count > 1 ? placing[:tie] = true : placing.delete(:tie)
+    end
+  end
+end

data/lib/sciolyff/interpreter/team.rb

@@ -12,11 +12,10 @@ module SciolyFF
       @placings_by_event =
         @placings.group_by(&:event).transform_values!(&:first)
 
-      @placings.freeze
-      @penalties.freeze
+      link_to_team_in_subdivision_interpreter(interpreter)
     end
 
-    attr_reader :placings, :penalties
+    attr_reader :placings, :penalties, :subdivision_team
 
     def school
       @rep[:school]
@@ -38,6 +37,10 @@ module SciolyFF
       @rep[:exhibition] == true
     end
 
+    def disqualified?
+      @rep[:disqualified] == true
+    end
+
     def number
       @rep[:number]
     end
@@ -89,5 +92,15 @@ module SciolyFF
                 .count { |p| p.isolated_points == medal_points }
       end
     end
+
+    private
+
+    def link_to_team_in_subdivision_interpreter(interpreter)
+      return @subdivision_team = nil unless (sub = subdivision)
+
+      @subdivision_team = interpreter.subdivisions[sub].teams.find do |t|
+        t.number == number
+      end
+    end
   end
 end

data/lib/sciolyff/interpreter/tiebreaks.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SciolyFF
+  # Tie-breaking logic for teams, to be used in the Interpreter class
+  module Interpreter::Tiebreaks
+    private
+
+    def sort_teams_by_points(teams)
+      teams.sort do |team_a, team_b|
+        cmp = team_a.points <=> team_b.points
+        cmp.zero? ? break_tie(team_a, team_b) : cmp
+      end
+    end
+
+    def break_tie(team_a, team_b)
+      team_a.medal_counts
+            .zip(team_b.medal_counts)
+            .map { |counts| counts.last - counts.first }
+            .find(proc { break_second_tie(team_a, team_b) }, &:nonzero?)
+    end
+
+    def break_second_tie(team_a, team_b)
+      cmp = team_a.trial_event_points <=> team_b.trial_event_points
+      cmp.zero? ? break_third_tie(team_a, team_b) : cmp
+    end
+
+    def break_third_tie(team_a, team_b)
+      team_a.trial_event_medal_counts
+            .zip(team_b.trial_event_medal_counts)
+            .map { |counts| counts.last - counts.first }
+            .find(proc { team_a.number <=> team_b.number }, &:nonzero?)
+    end
+  end
+end

data/lib/sciolyff/interpreter/tournament.rb

@@ -14,9 +14,10 @@ module SciolyFF
       @teams = interpreter.teams
       @placings = interpreter.placings
       @penalties = interpreter.penalties
+      @subdivisions = interpreter.subdivisions
     end
 
-    attr_reader :events, :teams, :placings, :penalties
+    attr_reader :events, :teams, :placings, :penalties, :subdivisions
 
     undef tournament
 
@@ -53,19 +54,19 @@ module SciolyFF
     end
 
     def worst_placings_dropped?
-      @rep.key? :'worst placings dropped'
+      worst_placings_dropped.positive?
     end
 
     def worst_placings_dropped
-      worst_placings_dropped? ? @rep[:'worst placings dropped'] : 0
+      @rep[:'worst placings dropped'] || 0
     end
 
     def exempt_placings?
-      @rep.key? :'exempt placings'
+      exempt_placings.positive?
     end
 
     def exempt_placings
-      exempt_placings? ? @rep[:'exempt placings'] : 0
+      @rep[:'exempt placings'] || 0
     end
 
     def custom_maximum_place?
@@ -77,5 +78,27 @@ module SciolyFF
 
       @teams.count { |t| !t.exhibition? }
     end
+
+    def per_event_n?
+      @rep[:'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.map do |p|
+        p.tie? && !p.points_limited_by_maximum_place?
+      end.any?
+    end
+
+    def subdivisions?
+      !@subdivisions.empty?
+    end
   end
 end

data/lib/sciolyff/interpreter.rb

@@ -10,26 +10,42 @@ module SciolyFF
     require 'sciolyff/interpreter/placing'
     require 'sciolyff/interpreter/penalty'
 
+    require 'sciolyff/interpreter/tiebreaks'
+    require 'sciolyff/interpreter/subdivisions'
+    require 'sciolyff/interpreter/html'
+
     attr_reader :tournament, :events, :teams, :placings, :penalties
 
     def initialize(rep)
-      create_models(rep)
+      if rep.instance_of? String
+        rep = YAML.safe_load(File.read(rep),
+                             permitted_classes: [Date],
+                             symbolize_names: true)
+      end
+      create_models(@rep = rep)
       link_models(self)
 
       sort_events_naturally
       sort_teams_by_rank
+    end
 
-      freeze_models
+    def subdivisions
+      @subdivisions ||=
+        teams.map(&:subdivision)
+             .uniq
+             .compact
+             .map { |sub| [sub, Interpreter.new(subdivision_rep(sub))] }
+             .to_h
     end
 
     private
 
     def create_models(rep)
       @tournament = Tournament.new(rep)
-      @events    = map_array_to_models rep[:Events],    Event,   rep
-      @teams     = map_array_to_models rep[:Teams],     Team,    rep
-      @placings  = map_array_to_models rep[:Placings],  Placing, rep
-      @penalties = map_array_to_models rep[:Penalties], Penalty, rep
+      @events     = map_array_to_models rep[:Events],    Event,   rep
+      @teams      = map_array_to_models rep[:Teams],     Team,    rep
+      @placings   = map_array_to_models rep[:Placings],  Placing, rep
+      @penalties  = map_array_to_models rep[:Penalties], Penalty, rep
     end
 
     def map_array_to_models(arr, object_class, rep)
@@ -47,49 +63,23 @@ module SciolyFF
       @tournament.link_to_other_models(interpreter)
     end
 
-    def freeze_models
-      @events.freeze
-      @teams.freeze
-      @placings.freeze
-      @penalties.freeze
-    end
-
     def sort_events_naturally
-      @events.sort! do |a, b|
-        next  1 if  a.trial? && !b.trial?
-        next -1 if !a.trial? &&  b.trial?
-
-        a.name <=> b.name
-      end
+      @events.sort_by! { |e| [e.trial?.to_s, e.name] }
     end
 
     def sort_teams_by_rank
-      @teams.sort! do |team_a, team_b|
-        next  1 if  team_a.exhibition? && !team_b.exhibition?
-        next -1 if !team_a.exhibition? &&  team_b.exhibition?
-
-        cmp = team_a.points <=> team_b.points
-        cmp.zero? ? break_tie(team_a, team_b) : cmp
-      end
-    end
-
-    def break_tie(team_a, team_b)
-      team_a.medal_counts
-            .zip(team_b.medal_counts)
-            .map { |counts| counts.last - counts.first }
-            .find(proc { break_second_tie(team_a, team_b) }, &:nonzero?)
+      sorted =
+        @teams
+        .group_by { |t| [t.disqualified?.to_s, t.exhibition?.to_s] }
+        .map { |key, teams| [key, sort_teams_by_points(teams)] }
+        .sort_by(&:first)
+        .map(&:last)
+        .flatten
+      @teams.map!.with_index { |_, i| sorted[i] }
     end
 
-    def break_second_tie(team_a, team_b)
-      cmp = team_a.trial_event_points <=> team_b.trial_event_points
-      cmp.zero? ? break_third_tie(team_a, team_b) : cmp
-    end
-
-    def break_third_tie(team_a, team_b)
-      team_a.trial_event_medal_counts
-            .zip(team_b.trial_event_medal_counts)
-            .map { |counts| counts.last - counts.first }
-            .find(proc { team_a.number <=> team_b.number }, &:nonzero?)
-    end
+    include Interpreter::Tiebreaks
+    include Interpreter::Subdivisions
+    include Interpreter::HTML
   end
 end

data/lib/sciolyff/validator/checker.rb

@@ -0,0 +1,20 @@
+# 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 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,96 @@
+# frozen_string_literal: true
+
+require 'sciolyff/validator/checker'
+require 'sciolyff/validator/sections'
+
+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
+      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
+
+    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

data/lib/sciolyff/validator/logger.rb

@@ -0,0 +1,47 @@
+# 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
+
+    def initialize(loglevel)
+      @loglevel = loglevel
+      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