A Ruby sorting program for multiple criteria

class Sorter
  def self.sort(matches)
    self.new(matches).sort
  end
  # ...
end

class Match; end                    # a played match
class MatchAggregator; end          # a set of matches
class Group < MatchAggregator; end  # a World Cup group

class Group < MatchAggregator
  # takes an array of match-result hashes, like those in the question
  def initialize(matches)
    super matches.map { |result| Match.new(result) }
  end

  # returns a sorted array of hashes containing a team's name, and
  # the array used to rank it against the other teams
  def ranking
    # get the teams plus their rank within this group
    unsorted_teams = teams.map { |team| { name: team, rank: rank_for(team) } }

    # group teams by their "basic" rank (points, goal diff, goals),
    # i.e. group them if they're tied
    tie_groups = unsorted_table.group_by { |team| team[:rank] }.values

    # resolve ties (if any)
    # this is essentially a block with side-effects, so it's not pretty
    # but at least the side-effects are well-contained 
    tie_groups.each do |tied_teams|
      # a subset of 1 team can't be tied, so skip it
      next if tied_teams.one?

      # get the names of the tied teams
      names = tied_teams.map { |team| team[:name] } 

      # create a new MatchAggregator containing only matches
      # played between the tied teams
      subgroup = MatchAggregator.new matches_between(*names)

      # update the teams' :rank with their rank in the subgroup,
      # plus a random number
      tied_teams.each { |team| team[:rank] += subgroup.rank_for(team[:name]) + [lots.pop] }

      # the final tie-breaker: Randomness
      lots = (1..teams.count).to_a.shuffle
      tied_teams.each { |team| team[:rank] << lots.pop }
    end

    # Put it all together
    tie_groups.flatten.sort_by { |team| team[:rank] }.reverse
  end
end

class MatchAggregator
  attr_reader :matches

  # Note that this expects Match instances, not hashes.
  # We'll leave the hash -> Match conversion to Group,
  # as that's intended as the public-facing class
  def initialize(matches)
    @matches = matches.freeze
  end

  # returns an array of team names
  def teams
    matches.map(&:teams).flatten.uniq
  end

  # matches that include 1 or more of the given teams
  def matches_including(*teams)
    matches.select { |match| match.includes?(*teams) }
  end

  # matches between any of the given teams
  def matches_between(*teams)
    matches.select { |match| match.between?(*teams) }
  end

  # returns an array of values, based on the matches in
  # this group, that can be used for ranking teams
  def rank_for(team)
    methods = [:points_for, :goal_difference_for, :goals_for]
    methods.map { |method| sum(method, team) }
  end

  protected

  # returns the sum of calling the given method
  # on all matches that include the given team
  def sum(method, team)
    matches_including(team).inject(0) { |memo, match| memo += match.send(method, team) }
  end
end

class Match
  attr_reader :result

  # take a hash like the one you're using now, e.g.
  # { home_team: "Algeria", away_team: "Slovenia", home_score: 2, away_score: 1 }
  def initialize(hash = {})
    @result = {
      hash[:home_team] => hash[:home_score],
      hash[:away_team] => hash[:away_score]
    }.freeze
  end

  # get the names of the competing teams
  def teams
    result.keys
  end

  # did the match include 1 or more of the given teams?
  def includes?(*names)
    (teams & names).any?
  end

  # did this match take place between
  # any 2 of the given competitors?
  def between?(*names)
    (teams & names).count == 2
  end

  # All the following methods should be self-explanatory.
  # In all cases, the `team` argument is a team name

  def goals_for(team)
    result[team] || 0
  end

  def goals_against(team)
    return 0 unless includes?(team)
    opponent = teams.detect { |name| name != team }
    result[opponent] || 0
  end

  def points_for(team)
    return 3 if won_by?(team)
    return 1 if includes?(team) && tied?
    0
  end

  def won_by?(team)
    goal_difference_for(team) > 0
  end

  def tied?
    result.values.uniq.one?
  end

  def goal_difference_for(team)
    goals_for(team) - goals_against(team)
  end
end