Question

I need to sort league table in Rails 3, so I have LeagueTable model, Team model and Match model.
Basic sorting is done by points summary, so this is easy part. But when two teams got the same points number, I want to sort them by points won in matches between this two teams.
I got no idea how to do this.

EDIT:

# league_table.rb model
class LeagueTable < ActiveRecord::Base
    belongs_to :team
end


# match.rb model
class Match < ActiveRecord::Base
    belongs_to :team_home, :class_name => "Team"
    belongs_to :team_away, :class_name => "Team"
end


# team.rb model
class Team < ActiveRecord::Base
    has_many :matches
end


# schema.rb
create_table "league_tables", :force => true do |t|
    t.integer  "team_id"
    t.integer  "points"
    t.integer  "wins"
    t.integer  "draws"
    t.integer  "looses"
    t.integer  "goals_won"
    t.integer  "goals_lost"
    t.datetime "created_at"
    t.datetime "updated_at"
    t.integer  "matches"
    t.integer  "priority"
  end

  create_table "matches", :force => true do |t|
    t.integer  "team_home_id"
    t.integer  "team_away_id"
    t.integer  "score_home"
    t.integer  "score_away"
    t.datetime "created_at"
    t.datetime "updated_at"
  end

  create_table "teams", :force => true do |t|
    t.string   "name"
    t.datetime "created_at"
    t.datetime "updated_at"
  end

Answer 1

Very interesting question. Here is (more less) how I would handle it, using recursion and the magic of group_by.

1. You would need a class method that, given an array of teams, calculates the number of points (goals for, goals against…) each team has got in the matches between those teams only. Assume you return a hash of hashes: {team_foo => {:points => 10, :goals_for => 33, :goals_against => 6}, team_bar => {:points => 18, :goals_for => 50, :goals_against => 11}...}.
2. The final order of the teams will be put into an array final_order, which is empty now.
3. Take all teams to an array and apply the method mentioned above. You should now have teams and the number of points (goals for, goals against…) all the teams have gained in all the games currently played. Store it somewhere, say under the name all_teams_scores.
4. Take all teams and group them using group_by: teams.group_by {|t| all_teams_scores[t][:points]}. What you get is an OrderedHash, looking like: {10 => [team_foo], 18 => [team_bar, team_xyz]}. The key is what you group by, the value is always an array. Store this hash, e.g. as league_table.
5. Sort the keys of league_table (remember to reverse when needed) and check the values of league_table according to them. If the array has two or more elements, apply points 3.-5. to the teams in that array. If the array has one element, append this element to final_order.
6. Done.

Some remarks:

• Remember that in the worst case you are left with two or more teams that have gained the same number of points (goals…) in the direct games. You need to handle that, or sort by random.
• The above steps group by points only. If you need to first sort by points in all games, then points in direct games, it will work. If you want to sort by points in all games, points in direct games, goals in all games – you need to refine the above algorithm. It should not be hard, though 😉
• You can group_by an array (which helps when you want to sort over a number of things before or after you sort by direct games).
• Unless your site is going to be heavily used, generate the table whenever requested. No need to store it in the dabase – unless the season is over and no changes to the game results are to be made.
• If you decide to store the table in the database, ensure that the fields related to the position of a team in the table are not editable by the user. The best way probably would be to implement the above algorithm as a stored procedure (PostgreSQL supports pl/Ruby, although I never used it), create view based on that and access league table from Rails through it (views are, generally, read only). Of course, removing the access to these fields from the administrative interface is also ok, for 99.99% situations 😉
• This may not (and probably is not) the optimal solution in terms of speed or memory efficiency (although I have not checked it), but I suppose the code produced according to this method should be easy to read, understand and maintain later on.

Hope this helps.