tests: show issue 27

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

Cargo.lock

@@ -3,7 +3,7 @@ use crate::helpers::pep508::{format_requirement, get_canonic_requirement_name};
 use crate::helpers::table::{for_entries, reorder_table_keys, Tables};
 
 pub fn fix(tables: &mut Tables, keep_full_version: bool) {
-    let table_element = tables.get(&String::from("build-system"));
+    let table_element = tables.get("build-system");
     if table_element.is_none() {
         return;
     }
@@ -107,6 +107,25 @@ mod tests {
     [[build-system.a]] # empty table within the array
     [[build-system.a]]
     name = "Nail"
+    "#},
+        false
+    )]
+    #[case::reorder(
+        indoc ! {r#"
+    [build-system]
+    requires = [
+      "hatchling",
+    ]
+    build-backend = "hatchling.build"
+
+    "#},
+        indoc ! {r#"
+    [build-system]
+    build-backend = "hatchling.build"
+    requires = [
+      "hatchling",
+    ]
+
     "#},
         false
     )]

rust/src/build_system.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::iter::zip;
 use std::ops::Index;
 
-use taplo::syntax::SyntaxKind::{ENTRY, IDENT, KEY, NEWLINE, TABLE_ARRAY_HEADER, TABLE_HEADER, VALUE};
+use taplo::syntax::SyntaxKind::{COMMA, ENTRY, IDENT, KEY, NEWLINE, TABLE_ARRAY_HEADER, TABLE_HEADER, VALUE};
 use taplo::syntax::{SyntaxElement, SyntaxNode};
 use taplo::HashSet;
 
@@ -154,8 +154,24 @@ fn get_key(k: &str) -> String {
     String::from(k)
 }
 
+pub fn table_active_size(table: &[SyntaxElement]) -> usize {
+    table
+        .iter()
+        .enumerate()
+        .rev()
+        .find_map(|(i, e)| {
+            if e.kind() == VALUE || e.kind() == COMMA {
+                Some(i+1)
+            } else {
+                None
+            }
+        })
+        .unwrap_or(table.len())
+}
+
 pub fn reorder_table_keys(table: &mut RefMut<Vec<SyntaxElement>>, order: &[&str]) {
-    let (size, mut to_insert) = (table.len(), Vec::<SyntaxElement>::new());
+    let size = table_active_size(table);
+    let mut to_insert = Vec::<SyntaxElement>::new();
     let (key_to_position, key_set) = load_keys(table);
     let mut handled_positions = HashSet::<usize>::new();
     for current_key in order {
@@ -186,7 +202,7 @@ pub fn reorder_table_keys(table: &mut RefMut<Vec<SyntaxElement>>, order: &[&str]
     table.splice(0..size, to_insert);
 }
 
-fn load_keys(table: &RefMut<Vec<SyntaxElement>>) -> (HashMap<String, usize>, Vec<Vec<SyntaxElement>>) {
+fn load_keys(table: &[SyntaxElement]) -> (HashMap<String, usize>, Vec<Vec<SyntaxElement>>) {
     let mut key_to_pos = HashMap::<String, usize>::new();
     let mut key_set = Vec::<Vec<SyntaxElement>>::new();
     let entry_set = RefCell::new(Vec::<SyntaxElement>::new());
@@ -238,12 +254,13 @@ pub fn get_table_name(entry: &SyntaxElement) -> String {
     String::new()
 }
 
-pub fn for_entries<F>(table: &RefMut<Vec<SyntaxElement>>, f: &mut F)
+pub fn for_entries<F>(table: &[SyntaxElement], f: &mut F)
 where
     F: FnMut(String, &SyntaxNode),
 {
+    let size = table_active_size(table);
     let mut key = String::new();
-    for table_entry in table.iter() {
+    for table_entry in table.iter().take(size) {
         if table_entry.kind() == ENTRY {
             for entry in table_entry.as_node().unwrap().children_with_tokens() {
                 if entry.kind() == KEY {
@@ -316,3 +333,24 @@ pub fn collapse_sub_tables(tables: &mut Tables, name: &str) {
         sub.clear();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use taplo::parser::parse;
+
+    #[test]
+    fn test_reorder() {
+        let root_ast = parse("[A]\nb = 1\na = 1\n\n[B]\nb = 2")
+            .into_syntax()
+            .clone_for_update();
+        let mut tables = Tables::from_ast(&root_ast);
+        {
+            let table = &mut tables.get("A").unwrap().first().unwrap().borrow_mut();
+            reorder_table_keys(table, &["", "a", "b"]);
+        }
+        tables.reorder(&root_ast, &["B", "A"]);
+        assert_eq!(root_ast.to_string(), "[B]\nb = 2\n\n[A]\na = 1\n\nb = 1\n\n");
+    }
+}

rust/src/helpers/table.rs

@@ -272,6 +272,29 @@ mod tests {
         true,
         (3, 8)
     )]
+    #[case::space_issue_27(
+        indoc ! {r#"
+    [build-system]
+    requires = [
+      "hatchling",
+    ]
+    build-backend = "hatchling.build"
+
+    [project]
+    "#},
+        indoc ! {r#"
+    [build-system]
+    build-backend = "hatchling.build"
+    requires = [
+      "hatchling",
+    ]
+
+    [project]
+    "#},
+        2,
+        true,
+        (3, 8)
+    )]
     fn test_format_toml(
         #[case] start: &str,
         #[case] expected: &str,

rust/src/main.rs

@@ -291,7 +291,7 @@ fn generate_classifiers_to_entry(
 type MaxMinPythonWithClassifier = ((u8, u8), (u8, u8), Vec<u8>, Option<HashSet<String>>);
 
 fn get_python_requires_with_classifier(
-    table: &RefMut<Vec<SyntaxElement>>,
+    table: &mut [SyntaxElement],
     max_supported_python: (u8, u8),
     min_supported_python: (u8, u8),
 ) -> MaxMinPythonWithClassifier {

rust/src/project.rs

@@ -7,6 +7,12 @@
 
 def test_format_toml() -> None:
     txt = """
+    [build-system]
+    requires = [
+        "hatchling",
+    ]
+    build-backend = "hatchling.build"
+
     [project]
     keywords = [
       "A",
@@ -32,6 +38,12 @@ def test_format_toml() -> None:
     res = format_toml(dedent(txt), settings)
 
     expected = """\
+    [build-system]
+    build-backend = "hatchling.build"
+    requires = [
+        "hatchling",
+    ]
+
     [project]
     keywords = [
         "A",