1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

module Enumerable
  # Sorts the enumeration by mapping the
  # values in the enumeration through the given block.
  #
  # The method takes a tuple of Symbols which indicate the sort direction
  # for each value returned by the block.
  #
  # The block must return a tuple of the same size as the direction tuple.
  def sort_by_multiple(*directions, &block)
    raise LocalJumpError, "No block given." if block == nil
    # Performance optimization
    if directions.all? { |d| d == :ascending || d == :asc }
      return self.sort_by(&block)
    elsif directions.all? { |d| d == :descending || d == :desc }
      return self.sort_by(&block).reverse
    end
    sorted = ((self.collect do |obj|
      [block.call(obj), obj]
    end).sort do |a, b|
      if !a[0].kind_of?(Array) || !b[0].kind_of?(Array)
        raise TypeError,
          "The block must return values of type Array."
      elsif a[0].size != directions.size || b[0].size != directions.size
        raise ArgumentError,
          "Size mismatch between block return value and " +
          "directions parameter: " +
          "#{a[0].inspect}, #{b[0].inspect}, #{directions.inspect}"
      else
        result = 0
        directions.each_with_index do |direction, index|
          value_a = a[0][index]
          value_b = b[0][index]
          if direction == :descending || direction == :desc
            result = value_b <=> value_a
          elsif direction == :ascending || direction == :asc
            result = value_a <=> value_b
          else
            raise ArgumentError,
              "Direction must be one of: :ascending, :descending, " +
              "was: #{direction.inspect}."
          end
          break if result != 0
        end
        result
      end
    end).collect do |pair|
      pair[1]
    end
    sorted
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

require File.dirname(__FILE__) + '/../spec_helper'

describe Enumerable, "when sorting in multiple directions" do
  it "should correctly sort the array" do
    result = [
      [1,2,3],
      [3,2,1],
      [1,1,1],
      [2,3,1],
      [3,2,3]
    ].sort_by_multiple(
      :ascending, :descending, :ascending
    ) { |o| o }
    result.should == [
      [1,2,3],
      [1,1,1],
      [2,3,1],
      [3,2,1],
      [3,2,3]
    ]
  end

  it "should correctly sort the array" do
    result = [
      [1,2,3],
      [3,2,1],
      [1,1,1],
      [2,3,1],
      [3,2,3]
    ].sort_by_multiple(
      :descending, :ascending, :ascending
    ) { |o| o }
    result.should == [
      [3,2,1],
      [3,2,3],
      [2,3,1],
      [1,1,1],
      [1,2,3]
    ]
  end

  it "should correctly sort the array" do
    result = [
      [1,2,3],
      [3,2,1],
      [1,1,1],
      [2,3,1],
      [3,2,3]
    ].sort_by_multiple(
      :ascending, :ascending, :ascending
    ) { |o| o }
    result.should == [
      [1,1,1],
      [1,2,3],
      [2,3,1],
      [3,2,1],
      [3,2,3]
    ]
  end

  it "should correctly sort the array" do
    result = [
      [1,2,3],
      [3,2,1],
      [1,1,1],
      [2,3,1],
      [3,2,3]
    ].sort_by_multiple(
      :descending, :descending, :descending
    ) { |o| o }
    result.should == [
      [3,2,3],
      [3,2,1],
      [2,3,1],
      [1,2,3],
      [1,1,1]
    ]
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

module Enumerable
  # Sorts the enumeration by mapping the
  # values in the enumeration through the given block.
  #
  # The method takes a tuple of Symbols which indicate the sort direction
  # for each value returned by the block.
  #
  # The block must return a tuple of the same size as the direction tuple.
  def sort_by_multiple(*directions, &block)
    raise LocalJumpError, "No block given." if block == nil
    # Performance optimization
    if directions.all? { |d| d == :ascending || d == :asc }
      return self.sort_by(&block)
    elsif directions.all? { |d| d == :descending || d == :desc }
      return self.sort_by(&block).reverse
    end
    unless (directions.all? do |d|
      d == :ascending || d == :asc || d == :descending || d == :desc
    end) then
      raise ArgumentError,
        "Directions must all be one of: :ascending, :descending, " +
        "was: #{directions.inspect}."
    end
    sorted = ((self.collect do |obj|
      [block.call(obj), obj]
    end).sort do |a, b|
      if !a[0].kind_of?(Array) || !b[0].kind_of?(Array)
        raise TypeError,
          "The block must return values of type Array."
      elsif a[0].size != directions.size || b[0].size != directions.size
        raise ArgumentError,
          "Size mismatch between block return value and " +
          "directions parameter: " +
          "#{a[0].inspect}, #{b[0].inspect}, #{directions.inspect}"
      else
        result = 0
        directions.each_with_index do |direction, index|
          result = a[0][index] <=> b[0][index]
          next if result == 0
          result = -result if direction == :descending || direction == :desc
          break
        end
        result
      end
    end).collect do |pair|
      pair[1]
    end
    sorted
  end
end

Sorter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

require "activesupport"

class Sorter < ActiveSupport::OrderedHash
  def initialize(array, &block)
    block ||= lambda { |element| element }
    super(array.map { |element| block.call(element).clone }.group_by { |element| element.delete_at(0) })
  end
  
  def sort(*directions)
    keys.sort(&method(directions.shift)).inject([]) do |result,key|
      next [ result, key ].flatten if self[key].flatten.empty?
      
      Sorter.new(self[key]).sort(*directions).each do |array|
        result << [ key, *array ].flatten
      end
      
      result
    end
  end
  
  private
    def ascending(a, b)
      a <=> b
    end
    
    def descending(a, b)
      b <=> a
    end
end

Enumerable

1
2
3
4
5

module Enumerable
  def sort_by_multiple(*directions, &block)
    Sorter.new(self, &block).sort(*directions)
  end
end

1
2
3
4
5
6
7
8
9
10
11
12

module Enumerable
  # Ruby 1.8.7 introduces group_by, but the result isn't ordered. Override it.
  remove_method(:group_by) if [].respond_to?(:group_by) && RUBY_VERSION < '1.9'
 
  def group_by
    inject ActiveSupport::OrderedHash.new do |grouped, element|
      (grouped[yield(element)] ||= []) << element
      grouped
    end
  end unless [].respond_to?(:group_by)

  ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  it "should correctly sort the array" do
    result = [
      [[1],2,[3]],
      [[3],2,[1]],
      [[1],1,[1]],
      [[2],3,[1]],
      [[3],2,[3]]
    ].sort_by_multiple(
      :ascending, :descending, :ascending
    ) { |o| o }
    result.should == [
      [[1],2,[3]],
      [[1],1,[1]],
      [[2],3,[1]],
      [[3],2,[1]],
      [[3],2,[3]]
    ]
  end

1

super((array.map { |element| block.call(element).clone }.group_by { |element| element.delete_at(0) }).to_a)