Ruby: how to sort array of string parsing the content

[Edit: My initial solution, which follows this edit, does not work with the revised statement of the question. I will leave it, however, as it might be of interest regardless.

The following is a way to perform the sort under the revised rules, as I understand them. If I have misinterpreted the rules, I expect the fix would be minor.

Regex to use

Let's start with the regex I'll use:

R = /
    \{       # match char
    (        # begin capture group
    \d+      # match one or more digits
    (?:      # begin non-capture group
    \.       # match decimal
    \d+      # match one or more digits
    )        # end non-capture group
    |        # or
    \d*      # match zero or more digits
    )        # match end capture group
    \}       # match char
    /x

Examples:

a = ["{5}something", "{61}{64}could", "{}be", "{54}{31.24}{0.2}write",
     "{11}{21}{87}{65}here", "[]or", "{31}not", "{31} cat"]
a.each_with_object({}) { |s,h| h[s] = s.scan(R).flatten }
  # => {"{5}something"        =>["5"],
  #    "{61}{64}could"        =>["61", "64"],
  #    "{}be"                 =>[""],
  #    "{54}{31.24}{0.2}write"=>["54", "31.24", "0.2"],
  #    "{11}{21}{87}{65}here" =>["11", "21", "87", "65"],
  #    "[]or"                 =>[],
  #    "{31}not"              =>["31"]
  #    "{31} cat"             =>["31"]} 

custom_sort method

We can write the method custom_sort as follows (change sort_by to sort_by! for custom_sort!):

class Array
  def custom_sort
    sort_by do |s|
      a = s.scan(R).flatten
      raise SyntaxError,
        "'#{s}' contains empty braces" if a.any?(&:empty?)
      raise SyntaxError,
        "'#{s}' contains zero or > 3 pair of braces" if a.size.zero?||a.size > 3
      a.map(&:to_f) << s[a.join.size+2*a.size..-1].tr(' ', 255.chr)
    end
  end
end

Examples

Let's try it:

a.custom_sort
  #=> SyntaxError: '{}be' contains empty braces

Remove "{}be" from a:

a = ["{5}something", "{61}{64}could", "{54}{31.24}{0.2}write",
     "{11}{21}{87}{65}here", "[]or", "{31}not", "{31} cat"]
a.custom_sort
  #SyntaxError: '{11}{21}{87}{65}here' contains > 3 pair of braces

Remove "{11}{21}{87}{65}here":

a = ["{5}something", "{61}{64}could", "{54}{31.24}{0.2}write",
     "[]or", "{31}not", "{31} cat"]
a.custom_sort
  #=> SyntaxError: '[]or' contains zero or > 3 pair of braces

Remove "[]or":

a = ["{5}something", "{61}{64}could", "{54}{31.24}{0.2}write",
     "{31}not", "{31} cat"]
a.custom_sort
  #=> ["{5}something",
  #    "{31}not",
  #    "{31} cat",
  #    "{54}{31.24}{0.2}write", "{61}{64}could"] 

Explanation

Suppose one of the strings to be sorted was:

s = "{54}{31.24}{0.2}write a letter"

Then in the sort_by block, we would compute:

a = s.scan(R).flatten
  #=> ["54", "31.24", "0.2"]
raise SyntaxError, "..." if a.any?(&:empty?)
  #=> raise SyntaxError, "..." if false 
raise SyntaxError, "..." if a.size.zero?||a.size > 3
  #=> SyntaxError, "..." if false || false
b = a.map(&:to_f)
  #=> [54.0, 31.24, 0.2] 
t = a.join
  #=> "5431.240.2" 
n = t.size + 2*a.size
  #=> 16 
u = s[n..-1]
  #=> "wr i te" 
v = u.tr(' ', 255.chr)
  #=> "wr\xFFi\xFFte" 
b << v
  #=> [54.0, 31.24, 0.2, "wr\xFFi\xFFte"] 

Note that the use of String#tr (or you could use String#gsub) puts spaces at the end of the sort order of ASCII characters:

255.times.all? { |i| i.chr < 255.chr }
  #=> true

tidE]

I have assumed that, in sorting, pairs of strings are to be compared in a manner analogous to Array#<=>. The first comparison considers the strings of digits within the the first pair of braces in each string (after conversion to a float). Ties are broken by comparing the strings of digits in the second pairs of braces (converted to floats). If there is still a tie, the third pairs digits enclosed in braces are compared, etc. If one string has n pairs of braces and another has m > n pairs, and the values within the braces are the same for the first n pairs, I assume the first string is to precede the second in the sort.

Code

R = /
    \{    # match char
    (\d+) # capture digits
    \}    # match char
    +     # capture one or more times
    /x

class Array
  def custom_sort!
    sort_by! { |s| s.scan(R).map { |e| e.first.to_f } }
  end
end

Example

array = ["{109}{08} OK",
         "{109}{07} OK",
         "{98} Thx",
         "{108}{0.8}{908} aa",
         "{108}{0.8}{907} aa",
         "{8}{51} lorem ipsum"]

a = array.custom_sort!
  #=> ["{8}{51} lorem ipsum",
  #    "{98} Thx",
  #    "{108}{0.8}{907} aa",
  #    "{108}{0.8}{908} aa",
  #    "{109}{07} OK",
  #    "{109}{08} OK"]

array == a
  #=> true

Explanation

Let's now calculate the value in Array#sort_by!'s block for the first element of array

s = "{109}{08} OK"

a = s.scan(R)
  #=> [["109"], ["08"]] 
b = a.map { |e| e.first.to_f }
  #=> [109.0, 8.0] 

Let's now do the same for the other strings and put the results in an array:

c = array.map { |s| [s, s.scan(R).map { |e| e.first.to_f }] }
  #=> [["{8}{51} lorem ipsum", [8.0, 51.0]],
  #    ["{98} Thx",            [98.0]],
  #    ["{108}{0.8}{907} aa",  [108.0, 907.0]],
  #    ["{108}{0.8}{908} aa",  [108.0, 908.0]],
  #    ["{109}{07} OK",        [109.0, 7.0]],
  #    ["{109}{08} OK",        [109.0, 8.0]]] 

sort_by in custom_sort! is therefore equivalent to:

c.sort_by(&:last).map(&:first)
  #=> ["{8}{51} lorem ipsum",
  #    "{98} Thx",
  #    "{108}{0.8}{907} aa",
  #    "{108}{0.8}{908} aa",
  #    "{109}{07} OK",
  #    "{109}{08} OK"]