simplify algorithm a lot, now only one best font is kept open at a time

Author: jkrumbiegel

src/findfonts.jl

@@ -37,6 +37,8 @@ function style_name(x::FTFont)
     lowercase(x.style_name)
 end
 
+const REGULAR_STYLES = ("regular", "normal", "medium", "standard", "roman")
+
 
 """
 Match a font using the user-specified search string. Each part of the search string
@@ -70,34 +72,37 @@ Then this is how this function would match different search strings:
 - "times"               => no match
 - "arial"               => no match
 """
-function match_font_by_family_and_style(face::FTFont, searchparts)::Tuple{Int, Int}
+function match_font(face::FTFont, searchparts)::Tuple{Int, Int, Bool, Int}
 
     fname = family_name(face)
+    sname = style_name(face)
+    is_regular_style = any(occursin(s, sname) for s in REGULAR_STYLES)
 
-    family_matches = any(occursin(part, fname) for part in searchparts)
+    fontlength_penalty = -(length(fname) + length(sname))
 
-    # return early if family name doesn't have a match
-    family_matches || return (0, 0)
 
-    # now enhance the score with style information
+    family_matches = any(occursin(part, fname) for part in searchparts)
 
-    remaining_parts = filter(part -> !occursin(part, fname), searchparts)
+    # return early if family name doesn't have a match
+    family_matches || return (0, 0, is_regular_style, fontlength_penalty)
 
     family_score = sum(length(part) for part in searchparts if occursin(part, fname))
 
-    # return early if no parts remain for style scoring
-    isempty(remaining_parts) && return (family_score, 0)
-
-    sname = style_name(face)
+    # now enhance the score with style information
+    remaining_parts = filter(part -> !occursin(part, fname), searchparts)
 
-    style_name_matches = any(occursin(part, sname) for part in remaining_parts)
+    if isempty(remaining_parts)
+        return (family_score, 0, is_regular_style, fontlength_penalty)
+    end
 
-    # return early if no remaining part matches the style name
-    style_name_matches || return (family_score, 0)
+    # check if any parts match the style name, otherwise return early
+    if !any(occursin(part, sname) for part in remaining_parts)
+        return (family_score, 0, is_regular_style, fontlength_penalty)
+    end
 
     style_score = sum(length(part) for part in remaining_parts if occursin(part, sname))
 
-    (family_score, style_score)
+    (family_score, style_score, is_regular_style, fontlength_penalty)
 end
 
 function try_load(fpath)
@@ -110,6 +115,7 @@ end
 
 fontname(ft::FTFont) = "$(family_name(ft)) $(style_name(ft))"
 
+
 function findfont(
         searchstring::String;
         italic::Bool=false, # this is unused in the new implementation
@@ -125,89 +131,40 @@ function findfont(
 
     candidates = Pair{FTFont, Tuple{Int, Int}}[]
 
+    best_score_so_far = (0, 0, false, typemin(Int))
+    best_font = nothing
+
     for folder in font_folders
         for font in readdir(folder)
             fpath = joinpath(folder, font)
             face = try_load(fpath)
             face === nothing && continue
-            family_score, style_score = match_font_by_family_and_style(face, searchparts)
-            # only take results with net positive character matches into account
-            if family_score > 0
-                push!(candidates, face => (family_score, style_score))
-            else
-                # help gc a bit! Otherwise, this won't end well with the font keeping tons of open files
-                finalize(face)
-            end
-        end
-    end
 
-    isempty(candidates) && return nothing
+            score = match_font(face, searchparts)
 
-    # sort by family score then style score, highest first
-    sort!(candidates; by=x -> x[2], rev = true)
+            # we can compare all four tuple elements of the score at once
+            # in order of importance:
 
+            # 1. number of family match characters
+            # 2. number of style match characters
+            # 3. is font a "regular" style variant?
+            # 4. the negative length of the font name, the shorter the better
 
-    # best score for comparison
-    highscore = candidates[1][2] # tuple{int, int}
+            family_match_score = score[1]
+            if family_match_score > 0 && score > best_score_so_far
+                # finalize previous best font to close the font file
+                if !isnothing(best_font)
+                    finalize(best_font)
+                end
 
-    # remove all candidates that have lesser scores than the first one
-    for i in 2:length(candidates)
-        if candidates[i][2][1] < highscore[1] || candidates[i][2][2] < highscore[2]
-            # remove fonts from back to front and finalize them to close
-            # their files
-            for j in length(candidates):-1:i
-                to_remove = pop!(candidates)[1]
-                finalize(to_remove)
-            end
-            # there will be no other i's we need to check after this
-            break
-        end
-    end
-
-    # return early if only one font remains
-    length(candidates) == 1 && return candidates[1][1]
-
-    # there is still more than one candidate
-    # all candidates have the same family and style score
-
-    # prefer regular fonts among the remaining options
-    regular_styles = ("regular", "normal", "medium", "standard", "roman")
-    regular_matches = filter(candidates) do c
-        any(occursin(style, style_name(c[1])) for style in regular_styles)
-    end
-
-    # if any fonts match a regular-type style name, choose the overall shortest
-    if !isempty(regular_matches)
-
-        sort!(regular_matches,
-            by = c -> length(fontname(c[1])))
-
-        shortest = regular_matches[1][1]
-
-        # close all non-used font files
-        for c in candidates
-            if c[1] !== shortest
-                finalize(c)
+                # new candidate
+                best_font = face
+                best_score_so_far = score
+            else
+                finalize(face)
             end
         end
-
-        return shortest
-    end
-
-    # we didn't find any font with a "regular" name
-    # as a last heuristic, we just choose the font with the shortest name
-
-    sort!(candidates,
-        by = c -> length(fontname(c[1])))
-
-    shortest = candidates[1][1]
-
-    # close all non-used font files
-    for c in candidates
-        if c[1] !== shortest
-            finalize(c)
-        end
     end
 
-    shortest
+    best_font
 end