Eliminate reliance on cargo-sort

Author: smoelius

.github/workflows/ci.yml

@@ -96,7 +96,7 @@ jobs:
 
       - uses: taiki-e/install-action@v2
         with:
-          tool: cargo-sort, cargo-udeps
+          tool: cargo-udeps
 
       # smoelius: I expect this list to grow.
       - name: Install tools

Cargo.lock

@@ -55,6 +55,7 @@ subprocess = "0.2"
 syn = { version = "2.0", features = ["full", "parsing", "visit", "visit-mut"] }
 tempfile = "3.23"
 termsize = "0.1"
+toml_edit = "0.23"
 walkdir = "2.5"
 xshell = "0.2"
 

Cargo.toml

@@ -29,6 +29,7 @@ semver = { workspace = true }
 serde_json = { workspace = true }
 similar-asserts = { workspace = true }
 tempfile = { workspace = true }
+toml_edit = { workspace = true }
 walkdir = { workspace = true }
 
 testing = { workspace = true }

test-fuzz/Cargo.toml

@@ -6,6 +6,7 @@ use std::{
     ffi::OsStr,
     fs::{read_dir, read_to_string, write},
     io::Write,
+    ops::Range,
     path::Path,
     process::{Command, ExitStatus},
     str::FromStr,
@@ -181,19 +182,83 @@ fn shellcheck() {
 }
 
 #[test]
-fn sort() {
+fn dependencies_are_sorted() {
     for entry in WalkDir::new("..")
         .into_iter()
         .filter_map(Result::ok)
         .filter(|e| e.file_name() == OsStr::new("Cargo.toml"))
     {
-        let dir = entry.path().parent().unwrap();
-        Command::new("cargo")
-            .args(["sort", "--check", "--grouped", "--no-format"])
-            .current_dir(dir)
-            .logged_assert()
-            .success();
+        let path = entry.path();
+        let contents = read_to_string(path).unwrap();
+        let document = contents.parse::<toml_edit::Document<_>>().unwrap();
+        for table_name in ["dependencies", "dev-dependencies", "build-dependencies"] {
+            let Some(span) = key_value_pair_span(&document, table_name) else {
+                continue;
+            };
+            assert!(
+                key_value_pairs_are_sorted(&document, span),
+                "`{table_name}` in `{}` are not sorted",
+                path.display()
+            );
+        }
+    }
+}
+
+fn key_value_pair_span<S>(
+    document: &toml_edit::Document<S>,
+    table_name: &str,
+) -> Option<Range<usize>> {
+    // smoelius: The table might not exist.
+    let item = document.get(table_name)?;
+    let table = item.as_table().unwrap();
+    // smoelius: The table might exist but be empty.
+    let (_, last_item) = table.iter().last()?;
+    let header_span = table.span().unwrap();
+    let last_item_span = last_item.span().unwrap();
+    Some(header_span.end..last_item_span.end)
+}
+
+fn key_value_pairs_are_sorted<S: AsRef<str>>(
+    document: &toml_edit::Document<S>,
+    span: Range<usize>,
+) -> bool {
+    for group in groups(document, span) {
+        let pairs = &document.raw()[group]
+            .parse::<toml_edit::Document<_>>()
+            .unwrap();
+        if !pairs.iter().map(|(k, _)| k).is_sorted() {
+            return false;
+        }
     }
+    true
+}
+
+fn groups<S: AsRef<str>>(
+    document: &toml_edit::Document<S>,
+    span: Range<usize>,
+) -> Vec<Range<usize>> {
+    let group_starts = group_starts(document, &span);
+    let mut groups = Vec::with_capacity(group_starts.len() + 1);
+    let mut start = span.start;
+    for partition in group_starts {
+        groups.push(start..partition);
+        start = partition;
+    }
+    groups.push(start..span.end);
+    groups
+}
+
+/// Find the offsets in `span` that are not newlines, but that are preceded by two (or more)
+/// newlines.
+fn group_starts<S: AsRef<str>>(
+    document: &toml_edit::Document<S>,
+    span: &Range<usize>,
+) -> Vec<usize> {
+    let raw = &document.raw()[span.clone()].as_bytes();
+    (2..raw.len())
+        .filter(|&i| raw[i - 2] == b'\n' && raw[i - 1] == b'\n' && raw[i] != b'\n')
+        .map(|i| span.start + i)
+        .collect()
 }
 
 // smoelius: No other test uses supply_chain.json.