def best_match(my_version, their_versions)
      log.debug("version comparison: #{my_version} vs #{their_versions.join(', ')}")

      my_chunks = my_version.split(/[\.\-\_ ~,]/)
      their_chunks_hash = Hash[
                          their_versions.map do |their_version|
                            their_chunks_for_version = (
                              if !their_version.nil?
                                their_version.split(/[\.\-\_ ~,]/)
                              else
                                []
                              end
                            )
                            chunks_count = [my_chunks.length - their_chunks_for_version.length, 0].max
                            their_chunks_for_version += [nil] * chunks_count
                            [their_version, their_chunks_for_version]
                          end
      ]

      max_chunks_length = ([my_chunks.length] + their_chunks_hash.values.map(&:length)).max

      scoreboard = []
      their_versions.each do |their_version|
        their_chunks = their_chunks_hash[their_version]
        score = 0
        their_chunks.each_with_index do |their_chunk, i|
          score_multiplier = 100**(max_chunks_length - i - 1)
          my_chunk = my_chunks[i]
          score += chunk_distance(my_chunk, their_chunk) * score_multiplier
        end
        scoreboard << { version: their_version, score: score }
      end

      scoreboard = scoreboard.sort_by { |element| element[:score] }

      log.debug("scoreboard: ")
      scoreboard.each_with_index do |element, i|
        log.debug("  #{i + 1}. #{element[:version]} (score: #{element[:score]})")
      end

      return scoreboard.first[:version] unless scoreboard.first.nil?
    end
def best_match(my_version, their_versions)
      log.debug("version comparison: #{my_version} vs #{their_versions.join(', ')}")

      my_chunks = my_version.split(/[\.\-\_ ~,]/)
      their_chunks_hash = Hash[
                          their_versions.map do |their_version|
                            their_chunks_for_version = (
                              if !their_version.nil?
                                their_version.split(/[\.\-\_ ~,]/)
                              else
                                []
                              end
                            )
                            chunks_count = [my_chunks.length - their_chunks_for_version.length, 0].max
                            their_chunks_for_version += [nil] * chunks_count
                            [their_version, their_chunks_for_version]
                          end
      ]

      max_chunks_length = ([my_chunks.length] + their_chunks_hash.values.map(&:length)).max

      scoreboard = []
      their_versions.each do |their_version|
        their_chunks = their_chunks_hash[their_version]
        score = 0
        their_chunks.each_with_index do |their_chunk, i|
          score_multiplier = 100**(max_chunks_length - i - 1)
          my_chunk = my_chunks[i]
          score += chunk_distance(my_chunk, their_chunk) * score_multiplier
        end
        scoreboard << { version: their_version, score: score }
      end

      scoreboard = scoreboard.sort_by { |element| element[:score] }

      log.debug("scoreboard: ")
      scoreboard.each_with_index do |element, i|
        log.debug("  #{i + 1}. #{element[:version]} (score: #{element[:score]})")
      end

      return scoreboard.first[:version] unless scoreboard.first.nil?
    end
returns the "best match" between a version number and a set of available version numbers
 using a heuristic criterion. Idea:
  - split the version number in chunks divided by ., - etc.
  - every chunk with same index is "compared", differences make up a score
  - "comparison" is a subtraction if the chunk is an integer, a string distance measure otherwise
  - score weighs differently on chunk index (first chunks are most important)
  - lowest score wins