fileserver: Implement natural sort for browse templates

[ChandlerSwift]

For files with regions of numbers and other characters, it's intuitive to have the numbers sorted by increasing numeric value rather than by ASCII code. (Jeff Atwood has a nice article here:
https://blog.codinghorror.com/sorting-for-humans-natural-sort-order/)

For example, the listing for a directory containing foo1, foo2, and foo10 would sort in that order, rather than putting foo10 between foo1 and foo2.

Closes #7226

Since this library is so little code, I opted to copy the code into the repo rather than adding it as a dependency. (Per the Go Proverb, "A little copying is better than a little dependency" 🙂)

Responding to comments from the issue that this PR closes:

I actually use https://pkg.go.dev/github.com/maruel/natural, which you mentioned above, in another project already, and so far it seems to be correct and efficient.

I tried (twice!) to switch this PR over to use that package instead, but wasn't able to convince myself it was correct. (I have no reason to believe it's not correct either! I just couldn't quite internalize it enough to be able to vouch for its correctness. Not sure why—it seems well written!—but I guess that implementation just doesn't quite mesh with the way I think about the algorithm.)

Because of that, I stuck with the implementation from the https://github.com/fvbommel/sortorder package, for which I can say I agree with its correctness. That said, if you'd rather I swap over to the other implementation, I'm definitely happy to do that.

Maybe only the HTML output should be natural sorted though.

Right now, the code makes the assumption that the output will be the same regardless of the format it is presented in. If I were to special-case the HTML output, I'd have to pass some additional context into applySortAndLimit (and maybe a level further?), too, which would balloon the scope of this change.

I'd personally find it surprising if the sort implementation varied depending on what format the output is returned in, so I'd advocate for natural sort regardless of output format

---

The included test was drafted by a large language model, but largely rewritten (and validated) by me.

[Forza-tng]

I've tested the implementation for my own web/fileserver.

With normal version number style filenames, things look good, but when numbers are real decimal numbers, it doesn't quite work. I think it is "how it should be" in that the algorithm assumes more digits means larger numbers. But in the context of a real decimal number it is not correct.

Version number sort means

• 1.0.1
• 1.0.3
• 1.1.0
• 1.2.0

Decimal number sort should be:

• 0.100
• 0.10001
• 0.1001
• 0.101
• 0.123

Perhaps there ought to be a Caddyfile option for specifying what type of sort that should be applied for specific directory trees?

Good example:

https://mirrors.tnonline.net/btrfs/btrfs-progs/sources/kernel.org/

Bad example:

https://mirrors.tnonline.net/misc/img-compare/001_Juvenile_leopard_in_the_Serengeti_National_Park_Photo_by_Giles_Laurent/640x427/

[ChandlerSwift]

I'd definitely agree that's not ideal for non-integer decimal numbers! I think that in general it's not going to be possible for Caddy to infer if a number is a decimal number or a version number or other number that should be "natural"-sorted. I'd be interested if you have an opinion on what a config option might look like here! (Not that I'll necessarily be able to implement it—this is my first attempt at modifying Caddy—but I can give it a shot!)

I was curious about what other software that does file listing does in this case. I did some testing, and it looks like, for the second set of files you provided, both KDE and GNOME render these in "natural", non-numerical order:

while Firefox uses, as far as I can tell, an ASCIIbetical sort (so e.g. 1.0.10 < 1.0.9):

[ChandlerSwift]

Ah, and I should have checked (and then mentioned): KDE Dolphin, perhaps unsurprisingly, provides an option to toggle this!

I was unable to find a corresponding option in GNOME's Nautilus.

[Forza-tng]

I'd definitely agree that's not ideal for non-integer decimal numbers! I think that in general it's not going to be possible for Caddy to infer if a number is a decimal number or a version number or other number that should be "natural"-sorted. I'd be interested if you have an opinion on what a config option might look like here! (Not that I'll necessarily be able to implement it—this is my first attempt at modifying Caddy—but I can give it a shot!)

How about something like:

file_server {
    browse {
        # default method if no rule matches this directory
        # one of: lex | natural | version | auto
        sorter default natural  

        # per directory/path rules
        sorter /misc/img-compare natural
        sorter /btrfs/btrfs-progs/sources version

        # (optional)
        # ?cmp=lex|natural|version|auto
        sorter allow_query true  
    }
}

auto would choose one of the other three modes depending on which matches best (most matches, or other heuristic)
lex is standard lexicographical order as is default today.