Configurable collapse

common/src/table.rs

@@ -1,11 +1,12 @@
 use std::cell::{RefCell, RefMut};
-use std::collections::HashMap;
+use std::collections::{HashMap, BTreeSet};
 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::{SyntaxElement, SyntaxNode};
 use taplo::HashSet;
+use taplo::{dom::node::DomNode as _, parser::parse};
 
 use crate::create::{make_empty_newline, make_key, make_newline, make_table_entry};
 use crate::string::load_text;
@@ -279,7 +280,7 @@
     None
 }
 
-pub fn collapse_sub_tables(tables: &mut Tables, name: &str) {
+pub fn collapse_sub_tables(tables: &mut Tables, name: &str, exclude: &[Vec<String>]) {
     let h2p = tables.header_to_pos.clone();
     let sub_name_prefix = format!("{name}.");
     let sub_table_keys: Vec<&String> = h2p.keys().filter(|s| s.starts_with(sub_name_prefix.as_str())).collect();
@@ -296,6 +297,14 @@
     if main_positions.len() != 1 {
         return;
     }
+
+    // remove `name` from `exclude`s (and skip if `name` is not a prefix)
+    let prefix = parse_ident(name).expect("could not parse prefix");
+    let exclude: BTreeSet<_> = exclude.into_iter().filter_map(|id| {
+        let (prefix_2, rest) = id.split_at(prefix.len()+1);
+        (prefix == prefix_2).then_some(rest)
+    }).collect();
+
     let mut main = tables.table_set[*main_positions.first().unwrap()].borrow_mut();
     for key in sub_table_keys {
         let sub_positions = tables.header_to_pos[key].clone();
@@ -340,3 +349,35 @@
         sub.clear();
     }
 }
+
+pub fn parse_ident(ident: &str) -> Result<Vec<String>, String> {
+    let parsed = parse(&format!("{ident} = 1"));
+    if let Some(e) = parsed.errors.first() {
+        return Err(format!("syntax error: {e}"));
+    }
+
+    let root = parsed.into_dom();
+    let errors = root.errors();
+    if let Some(e) = errors.get().first() {
+        return Err(format!("semantic error: {e}"));
+    }
+
+    dbg!(&root.errors());
+
+    // We cannot use `.into_syntax()` since only the DOM transformation
+    // allows accessing ident `.value()`s without quotes.
+    let mut node = root;
+    let mut parts = vec![];
+    while let Ok(table) = node.try_into_table() {
+        let entries = table.entries().get();
+        if entries.len() != 1 {
+            return Err("expected exactly one entry".to_string());
+        }
+        let mut it = entries.iter();
+        let (key, next_node) = it.next().unwrap(); // checked if len == 1 above
+
+        parts.push(key.value().to_string());
+        node = next_node.clone();
+    }
+    Ok(parts)
+}

pyproject-fmt/rust/src/dependency_groups.rs

@@ -7,8 +7,8 @@ use common::util::iter;
 use lexical_sort::natural_lexical_cmp;
 use std::cmp::Ordering;
 
-pub fn fix(tables: &mut Tables, keep_full_version: bool) {
-    collapse_sub_tables(tables, "dependency-groups");
+pub fn fix(tables: &mut Tables, keep_full_version: bool, do_not_collapse: &[Vec<String>]) {
+    collapse_sub_tables(tables, "dependency-groups", do_not_collapse);
     let table_element = tables.get("dependency-groups");
     if table_element.is_none() {
         return;

pyproject-fmt/rust/src/main.rs

@@ -2,7 +2,9 @@ use std::string::String;
 
 use common::taplo::formatter::{format_syntax, Options};
 use common::taplo::parser::parse;
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::{PyModule, PyModuleMethods};
+use pyo3::types::PyTuple;
 use pyo3::{pyclass, pyfunction, pymethods, pymodule, wrap_pyfunction, Bound, PyResult};
 
 use crate::global::reorder_tables;
@@ -25,19 +27,21 @@ pub struct Settings {
     max_supported_python: (u8, u8),
     min_supported_python: (u8, u8),
     generate_python_version_classifiers: bool,
+    do_not_collapse: Vec<Vec<String>>,
 }
 
 #[pymethods]
 impl Settings {
     #[new]
-    #[pyo3(signature = (*, column_width, indent, keep_full_version, max_supported_python, min_supported_python, generate_python_version_classifiers ))]
+    #[pyo3(signature = (*, column_width, indent, keep_full_version, max_supported_python, min_supported_python, generate_python_version_classifiers, do_not_collapse))]
     const fn new(
         column_width: usize,
         indent: usize,
         keep_full_version: bool,
         max_supported_python: (u8, u8),
         min_supported_python: (u8, u8),
         generate_python_version_classifiers: bool,
+        do_not_collapse: Vec<Vec<String>>,
     ) -> Self {
         Self {
             column_width,
@@ -46,6 +50,7 @@ impl Settings {
             max_supported_python,
             min_supported_python,
             generate_python_version_classifiers,
+            do_not_collapse,
         }
     }
 }
@@ -64,9 +69,10 @@ pub fn format_toml(content: &str, opt: &Settings) -> String {
         opt.max_supported_python,
         opt.min_supported_python,
         opt.generate_python_version_classifiers,
+        opt.do_not_collapse.as_slice(),
     );
-    dependency_groups::fix(&mut tables, opt.keep_full_version);
-    ruff::fix(&mut tables);
+    dependency_groups::fix(&mut tables, opt.keep_full_version, opt.do_not_collapse.as_slice());
+    ruff::fix(&mut tables, opt.do_not_collapse.as_slice());
     reorder_tables(&root_ast, &tables);
 
     let options = Options {
@@ -94,13 +100,24 @@ pub fn format_toml(content: &str, opt: &Settings) -> String {
     format_syntax(root_ast, options)
 }
 
+/// Parse a nested toml identifier into a tuple of idents
+///
+/// >>> parse_ident('a."b.c"')
+/// ('a', 'b.c')
+#[pyfunction]
+pub fn parse_ident<'py>(py: pyo3::Python<'py>, ident: &str) -> PyResult<Bound<'py, PyTuple>> {
+    let parts = common::table::parse_ident(ident).map_err(|e| PyValueError::new_err(e))?;
+    PyTuple::new(py, parts)
+}
+
 /// # Errors
 ///
 /// Will return `PyErr` if an error is raised during formatting.
 #[pymodule]
 #[pyo3(name = "_lib")]
 pub fn _lib(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(format_toml, m)?)?;
+    m.add_function(wrap_pyfunction!(parse_ident, m)?)?;
     m.add_class::<Settings>()?;
     Ok(())
 }

pyproject-fmt/rust/src/project.rs

@@ -20,8 +20,9 @@ pub fn fix(
     max_supported_python: (u8, u8),
     min_supported_python: (u8, u8),
     generate_python_version_classifiers: bool,
+    do_not_collapse: &[Vec<String>],
 ) {
-    collapse_sub_tables(tables, "project");
+    collapse_sub_tables(tables, "project", do_not_collapse);
     let table_element = tables.get("project");
     if table_element.is_none() {
         return;

pyproject-fmt/rust/src/ruff.rs

@@ -4,8 +4,8 @@ use common::table::{collapse_sub_tables, for_entries, reorder_table_keys, Tables
 use lexical_sort::natural_lexical_cmp;
 
 #[allow(clippy::too_many_lines)]
-pub fn fix(tables: &mut Tables) {
-    collapse_sub_tables(tables, "tool.ruff");
+pub fn fix(tables: &mut Tables, do_not_collapse: &[Vec<String>]) {
+    collapse_sub_tables(tables, "tool.ruff", do_not_collapse);
     let table_element = tables.get("tool.ruff");
     if table_element.is_none() {
         return;

pyproject-fmt/rust/src/tests/main_tests.rs

@@ -191,6 +191,7 @@ fn test_format_toml(
         max_supported_python,
         min_supported_python: (3, 9),
         generate_python_version_classifiers: true,
+        do_not_collapse: vec![],
     };
     let got = format_toml(start, &settings);
     assert_eq!(got, expected);
@@ -216,6 +217,7 @@ fn test_issue_24(data: PathBuf) {
         max_supported_python: (3, 9),
         min_supported_python: (3, 9),
         generate_python_version_classifiers: true,
+        do_not_collapse: vec![],
     };
     let got = format_toml(start.as_str(), &settings);
     let expected = read_to_string(data.join("ruff-order.expected.toml")).unwrap();
@@ -246,6 +248,7 @@ fn test_column_width() {
         max_supported_python: (3, 13),
         min_supported_python: (3, 13),
         generate_python_version_classifiers: true,
+        do_not_collapse: vec![],
     };
     let got = format_toml(start, &settings);
     let expected = indoc! {r#"

pyproject-fmt/src/pyproject_fmt/__main__.py

@@ -7,7 +7,7 @@
 
 from toml_fmt_common import ArgumentGroup, FmtNamespace, TOMLFormatter, _build_cli, run  # noqa: PLC2701
 
-from pyproject_fmt._lib import Settings, format_toml
+from pyproject_fmt._lib import Settings, format_toml, parse_ident
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -19,6 +19,7 @@ class PyProjectFmtNamespace(FmtNamespace):
     keep_full_version: bool
     max_supported_python: tuple[int, int]
     generate_python_version_classifiers: bool
+    do_not_collapse: list[tuple[str, ...]]
 
 
 class PyProjectFormatter(TOMLFormatter[PyProjectFmtNamespace]):
@@ -73,6 +74,15 @@ def _version_argument(got: str) -> tuple[int, int]:
             help="latest Python version the project supports (e.g. 3.14)",
         )
 
+        parser.add_argument(
+            "--do-not-collapse",
+            metavar="table.name",
+            type=parse_ident,
+            default=[],
+            action="append",
+            help="do not collapse the given table.name (can be specified multiple times)",
+        )
+
     @property
     def override_cli_from_section(self) -> tuple[str, ...]:
         """:return: path where config overrides live"""
@@ -93,6 +103,7 @@ def format(self, text: str, opt: PyProjectFmtNamespace) -> str:  # noqa: PLR6301
             max_supported_python=opt.max_supported_python,
             min_supported_python=(3, 10),  # default for when the user didn't specify via requires-python
             generate_python_version_classifiers=opt.generate_python_version_classifiers,
+            do_not_collapse=opt.do_not_collapse,
         )
         return format_toml(text, settings)
 

pyproject-fmt/src/pyproject_fmt/_lib.pyi

@@ -8,6 +8,7 @@ class Settings:
         max_supported_python: tuple[int, int],
         min_supported_python: tuple[int, int],
         generate_python_version_classifiers: bool,
+        do_not_collapse: list[tuple[str, ...]],
     ) -> None: ...
     @property
     def column_width(self) -> int: ...
@@ -21,3 +22,4 @@ class Settings:
     def min_supported_python(self) -> tuple[int, int]: ...
 
 def format_toml(content: str, settings: Settings) -> str: ...
+def parse_ident(ident: str) -> tuple[str, ...]: ...

pyproject-fmt/tests/test_lib.py

@@ -4,7 +4,7 @@
 
 import pytest
 
-from pyproject_fmt._lib import Settings, format_toml
+from pyproject_fmt._lib import Settings, format_toml, parse_ident
 
 
 @pytest.mark.parametrize(
@@ -76,6 +76,32 @@ def test_format_toml(start: str, expected: str) -> None:
         min_supported_python=(3, 7),
         max_supported_python=(3, 8),
         generate_python_version_classifiers=True,
+        do_not_collapse=[],
     )
     res = format_toml(dedent(start), settings)
     assert res == dedent(expected)
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        ("a.b", ("a", "b")),
+        ("a.'b.c'", ("a", "b.c")),
+    ],
+)
+def test_parse_idents(arg: str, expected: tuple[str, ...]) -> None:
+    assert parse_ident(arg) == expected
+
+
+@pytest.mark.parametrize(
+    ("arg", "exc_cls", "msg_pat"),
+    [
+        (None, TypeError, r"None"),
+        ("1 b", ValueError, r"syntax error"),
+        ("[]", ValueError, r"syntax error"),
+        ("x.", ValueError, r"syntax error"),
+    ],
+)
+def test_parse_idents_errors(arg: object, exc_cls: type[Exception], msg_pat: str) -> None:
+    with pytest.raises(exc_cls, match=msg_pat):
+        parse_ident(arg)

pyproject.toml

@@ -7,7 +7,6 @@ lint.select = [
   "ALL",
 ]
 lint.ignore = [
-  "ANN101", # no type annotation for self
   "ANN401", # allow Any as type annotation
   "COM812", # Conflict with formatter
   "CPY",    # No copyright statements