Files ordered weirdly

[RichardFevrier]

Lapce Version

nightly-b4a6ec5

System information

Fedora Silverblue 38 Hyprland

Describe the bug

Files are ordered weirdly (at least to me) in the left pane now.
Capitalized files are now ordered before non ones.
E.g.

README.md
docker-compose.yaml

When on the latest stable version it was:

docker-compose.yaml
README.md

If it is the new expected behavior please, makes it customizable in the settings (I have searched for sort and order nothing cames out).

[matteobongio]

Hi!

I'm not an expert, just someone trying to learn, I skimmed through some of the code, I believe the sorting is being done by an external crate "human_sort", being called in impl Ord for FileNodeItem in lapce-rpc/src/file.rs.

According to a quick git blame, that part of the cargo.toml file was changed at 2023-06-19 958709b, I don't know if the version bump was the cause of the problem.

In any case, the current code being used to sort files and directories is this:

pub fn compare_chars_iters<'a>(mut c1: Chars<'a>, mut c2: Chars<'a>) -> Ordering {
    loop {
        // cloning std iterators is super cheap (only pedantic reasons why they aren't [`Copy`])
        // we could use [`Peekable`] here, but that doesn't support [`Chars::as_str`] used by [`BigNum::extract`].
        match (c1.clone().next(), c2.clone().next()) {
            (Some(x), Some(y)) => {
                let cmp = if x.is_digit(10) && y.is_digit(10) {
                    BigNum::extract(&mut c1).unwrap().cmp(&BigNum::extract(&mut c2).unwrap())
                } else {
                    x.cmp(&y)
                };

                match cmp {
                    Ordering::Equal => { c1.next(); c2.next(); },
                    a => return a,
                }
            }
            (Some(_), None) => return Ordering::Greater,
            (None, Some(_)) => return Ordering::Less,
            (None, None) => return Ordering::Equal,
        }
    }
}

(copied from human sort)

This doesn't seem to differentiate between capitalized and non-capitalized words. In theory they should be sorted by x.cmp(&y), maybe this is the reason behind this, I don't know why this behavior would change? According to a quick test, assert!('A' > 'a').

In this case, this option could be implemented by simply having a toggle to make all characters lowercase when sorting. Although, I think it would be better to implement in the human sort code, like this:

make_ascii_lowercase

pub fn compare_chars_iters<'a>(mut c1: Chars<'a>, mut c2: Chars<'a>) -> Ordering {
    loop {
        // cloning std iterators is super cheap (only pedantic reasons why they aren't [`Copy`])
        // we could use [`Peekable`] here, but that doesn't support [`Chars::as_str`] used by [`BigNum::extract`].
        match (c1.clone().next(), c2.clone().next()) {
            (Some(x), Some(y)) => {
                let cmp = if x.is_digit(10) && y.is_digit(10) {
                    BigNum::extract(&mut c1).unwrap().cmp(&BigNum::extract(&mut c2).unwrap())
                } else {
                    x.make_ascii_lowercase().cmp(&y.make_ascii_lowercase())
                };

                match cmp {
                    Ordering::Equal => { c1.next(); c2.next(); },
                    a => return a,
                }
            }
            (Some(_), None) => return Ordering::Greater,
            (None, Some(_)) => return Ordering::Less,
            (None, None) => return Ordering::Equal,
        }
    }
}

or something similar, so as to pass the borrow checker.