Support sorting (#8)

Author: aurexav

mock/Cargo.toml.expect

@@ -48,16 +48,16 @@ std = [
 	"pallet-b/std",
 	"pallet-c/std",
 	# "pallet-d/std",
-	"primitive-a/std",
 	"pallet-a/std",
 	"pallet-d/std",
+	"primitive-a/std",
 ]
 
 runtime-benchmarks = [
 	"pallet-a/runtime-benchmarks",
 	# "pallet-b/runtime-benchmarks",
-	"pallet-c/runtime-benchmarks",
 	"pallet-b/runtime-benchmarks",
+	"pallet-c/runtime-benchmarks",
 	"pallet-d/runtime-benchmarks",
 	# "pallet-d/runtime-benchmarks",
 ]

mock/nested/a/Cargo.toml.expect

@@ -16,6 +16,6 @@ nested-d = { path = "../d", default-features = true }
 [features]
 default = ["std"]
 std = [
-	"nested-d/std",
 	"nested-b/std",
+	"nested-d/std",
 ]

src/analyzer.rs

@@ -11,7 +11,7 @@ use fxhash::FxHashMap;
 use once_cell::sync::{Lazy, OnceCell};
 use serde::Serialize;
 // cargo-featalign
-use crate::{cli::AnalyzerInitiator, prelude::*, util::GetById};
+use crate::{cli::AnalyzerInitiator, prelude::*, shared::FEATURES, util::GetById};
 
 #[allow(clippy::type_complexity)]
 pub static PROBLEMS: Lazy<Arc<Mutex<FxHashMap<PackageId, Vec<ProblemCrate>>>>> =
@@ -37,7 +37,6 @@ static DEFAULT_STD: OnceCell<bool> = OnceCell::new();
 
 #[derive(Debug, Clone)]
 pub struct Analyzer {
-	features: Arc<Vec<String>>,
 	// TODO?: replace with `FxHashMap` packages
 	metadata: Arc<Metadata>,
 	// Remove?
@@ -62,11 +61,7 @@ impl Analyzer {
 			});
 		let resolve = mem::take(&mut metadata.resolve).unwrap();
 
-		Self {
-			features: Arc::new(initiator.features),
-			metadata: Arc::new(metadata),
-			resolve: Arc::new(resolve),
-		}
+		Self { metadata: Arc::new(metadata), resolve: Arc::new(resolve) }
 	}
 
 	pub fn analyze(self, depth: i16) {
@@ -166,11 +161,10 @@ impl Analyzer {
 			let p_name = p.name.as_str();
 			let p_alias = rs.get_by_id(p_name).unwrap_or(p_name);
 			let n = self.resolve.get_by_id(p_id).unwrap();
+			let fs = FEATURES.get().unwrap();
 			let mut missing_fs = Vec::new();
 
-			for (f, required_fs) in
-				package.features.iter().filter(|(f, _)| self.features.contains(f))
-			{
+			for (f, required_fs) in package.features.iter().filter(|(f, _)| fs.contains(f)) {
 				// If the dependency has the feature specified by the user for analyzing.
 				if n.features.contains(f) {
 					let mut problematic = true;

src/cli.rs

@@ -42,6 +42,9 @@ pub struct Cli {
 
 #[derive(Debug, Parser)]
 pub struct SharedInitiator {
+	/// Features to process.
+	#[arg(long, required = true, value_name = "[NAME]", value_delimiter = ',')]
+	pub features: Vec<String>,
 	/// Number of threads to use.
 	///
 	/// The default value is based on the number of logical cores.
@@ -55,6 +58,12 @@ pub struct SharedInitiator {
 	/// Overwrite: Overwrites the original `Cargo.toml` file.
 	#[arg(long, value_enum, verbatim_doc_comment, default_value_t = Mode::Overwrite)]
 	pub mode: Mode,
+	/// Use the given symbol for indentation.
+	#[arg(long, value_enum, default_value_t = IndentSymbol::Tab)]
+	pub indent_symbol: IndentSymbol,
+	/// The number of spaces used for indentation.
+	#[arg(long, value_name = "SIZE", default_value_t = 4)]
+	pub indent_size: usize,
 }
 
 #[derive(Debug, Parser)]
@@ -64,9 +73,6 @@ pub struct AnalyzerInitiator {
 	/// If `Cargo.toml` is not provided, it will be searched for under the specified path.
 	#[arg(value_name = "PATH", default_value = "./Cargo.toml")]
 	pub manifest_path: PathBuf,
-	/// Features to process.
-	#[arg(long, required = true, value_name = "[NAME]", value_delimiter = ',')]
-	pub features: Vec<String>,
 	/// Determines whether to process only workspace members.
 	#[arg(long)]
 	pub workspace_only: bool,
@@ -81,12 +87,9 @@ pub struct AnalyzerInitiator {
 
 #[derive(Debug, Parser)]
 pub struct ResolverInitiator {
-	/// Use the given symbol for indentation.
-	#[arg(long, value_enum, default_value_t = IndentSymbol::Tab)]
-	pub indent_symbol: IndentSymbol,
-	/// The number of spaces used for indentation.
-	#[arg(long, value_name = "SIZE", default_value_t = 4)]
-	pub indent_size: usize,
+	/// Wether to sort the required features during alignment.
+	#[arg(long)]
+	pub sort: bool,
 }
 #[derive(Clone, Debug, ValueEnum)]
 pub enum IndentSymbol {

src/main.rs

@@ -10,6 +10,8 @@ use cli::{Cli, Mode, Parser};
 mod analyzer;
 use analyzer::{Analyzer, PROBLEMS};
 
+mod sorter;
+
 mod resolver;
 use resolver::Resolver;
 

src/resolver.rs

@@ -9,29 +9,26 @@ use cargo_metadata::PackageId;
 use fxhash::FxHashMap;
 use once_cell::sync::{Lazy, OnceCell};
 use regex::Regex;
-use toml_edit::{Document, Value};
+use toml_edit::{visit_mut::VisitMut, Document, Value};
 // cargo-featalign
 use crate::{
 	analyzer::{Problem, ProblemCrate, PROBLEMS},
-	cli::{IndentSymbol, Mode, ResolverInitiator},
+	cli::{Mode, ResolverInitiator},
 	prelude::*,
-	shared::MODE,
+	shared::{FEATURES, INDENTATION, MODE},
+	sorter::SortVisitor,
 };
 
 static PATH_REGEX: Lazy<Regex> =
 	Lazy::new(|| Regex::new(r".+? \d.\d.\d \(path\+file://(/.+?)\)").unwrap());
-static INDENTATION: OnceCell<String> = OnceCell::new();
+
+static SORT: OnceCell<bool> = OnceCell::new();
 
 #[derive(Clone, Debug)]
 pub struct Resolver;
 impl Resolver {
 	pub fn initialize(initiator: ResolverInitiator) -> Self {
-		let indentation = match initiator.indent_symbol {
-			IndentSymbol::Tab => "\n\t".into(),
-			IndentSymbol::Whitespace => format!("\n{}", " ".repeat(initiator.indent_size)),
-		};
-
-		INDENTATION.set(indentation).unwrap();
+		SORT.set(initiator.sort).unwrap();
 
 		Self
 	}
@@ -94,12 +91,14 @@ impl Resolver {
 			}
 		}
 
+		if *SORT.get().unwrap() {
+			SortVisitor(FEATURES.get().unwrap().to_owned()).visit_document_mut(&mut d);
+		}
+
 		match MODE.get().unwrap() {
 			Mode::Check => (),
-			Mode::DryRun => {
-				println!("{id}\n{}", util::diff(&s, &d.to_string()));
-			},
-			m @ Mode::DryRun2 | m @ Mode::Overwrite => {
+			Mode::DryRun => println!("{id}\n{}", util::diff(&s, &d.to_string())),
+			m => {
 				let p_tmp = tmp_path_of(&p);
 				let f_tmp = File::create(&p_tmp)?;
 				let mut w = BufWriter::new(f_tmp);

src/shared.rs

@@ -6,9 +6,11 @@ use std::{
 // crates.io
 use once_cell::sync::{Lazy, OnceCell};
 // cargo-featalign
-use crate::cli::{Mode, SharedInitiator};
+use crate::cli::{IndentSymbol, Mode, SharedInitiator};
 
+pub static FEATURES: OnceCell<Vec<String>> = OnceCell::new();
 pub static MODE: OnceCell<Mode> = OnceCell::new();
+pub static INDENTATION: OnceCell<String> = OnceCell::new();
 
 static THREAD: OnceCell<u16> = OnceCell::new();
 static THREAD_ACTIVE: Lazy<AtomicU16> = Lazy::new(|| AtomicU16::new(1));
@@ -38,9 +40,17 @@ pub fn deactivate_threads<T>(threads: Vec<JoinHandle<T>>) -> Vec<T> {
 pub struct Shared;
 impl Shared {
 	pub fn initialize(initiator: SharedInitiator) -> Self {
+		FEATURES.set(initiator.features).unwrap();
 		THREAD.set(initiator.thread).unwrap();
 		MODE.set(initiator.mode).unwrap();
 
+		let indentation = match initiator.indent_symbol {
+			IndentSymbol::Tab => "\n\t".into(),
+			IndentSymbol::Whitespace => format!("\n{}", " ".repeat(initiator.indent_size)),
+		};
+
+		INDENTATION.set(indentation).unwrap();
+
 		Self
 	}
 }

src/sorter.rs

@@ -0,0 +1,106 @@
+// std
+use std::mem;
+// crates.io
+use toml_edit::{visit_mut::VisitMut, Formatted, RawString, Table, Value};
+// cargo-featalign
+use crate::shared::INDENTATION;
+
+#[derive(Debug)]
+pub struct SortVisitor(pub Vec<String>);
+impl VisitMut for SortVisitor {
+	fn visit_table_mut(&mut self, node: &mut Table) {
+		fn sort(mut v: Vec<Formatted<String>>) -> Vec<Formatted<String>> {
+			fn has_empty_prefix(formatted_string: &Formatted<String>) -> bool {
+				formatted_string
+					.decor()
+					.prefix()
+					.and_then(|s| s.as_str())
+					.map(|s| s.trim().is_empty())
+					.unwrap_or_default()
+			}
+
+			fn sort_sub(v: &mut Vec<Formatted<String>>, prefix: Option<RawString>) {
+				v.sort_by(|a, b| a.value().cmp(b.value()));
+
+				if let Some(p) = prefix {
+					v[0].decor_mut().set_prefix(p);
+				}
+			}
+
+			let mut offset = 0;
+			let mut pivots = Vec::new();
+
+			v.iter_mut().enumerate().for_each(|(i, s)| {
+				if !has_empty_prefix(s) {
+					let d = s.decor_mut();
+					let p = d.prefix().unwrap().to_owned();
+
+					pivots.push((i - offset, p));
+
+					offset = i;
+				}
+
+				s.decor_mut().clear();
+			});
+
+			let mut prefix = None;
+			let mut v_chunks = Vec::new();
+
+			for (i, p) in pivots {
+				let v_chunk = v.split_off(i);
+
+				if !v.is_empty() {
+					sort_sub(&mut v, prefix.take());
+
+					v_chunks.push(mem::take(&mut v));
+				}
+
+				prefix = Some(p);
+				v = v_chunk;
+			}
+
+			sort_sub(&mut v, prefix.take());
+
+			v_chunks.push(v);
+
+			v_chunks.concat()
+		}
+
+		if let Some(v) = node.get_mut("features") {
+			let t = v.as_table_mut().unwrap();
+			let pfs = mem::take(&mut self.0);
+
+			pfs.into_iter().for_each(|f| {
+				if let Some(rfs) = t.get_mut(&f) {
+					let rfs = rfs.as_array_mut().unwrap();
+					let rfs_ = mem::take(rfs);
+
+					rfs.set_trailing(rfs_.trailing().to_owned());
+
+					let rfs_values = rfs_
+						.into_iter()
+						.map(|v| if let Value::String(s) = v { s } else { unreachable!() })
+						.collect::<Vec<_>>();
+
+					sort(rfs_values).into_iter().for_each(|f| {
+						let v = if f.decor().prefix().is_none() {
+							Value::String(f).decorated(INDENTATION.get().unwrap(), "")
+						} else {
+							Value::String(f)
+						};
+
+						rfs.push_formatted(v);
+					});
+
+					if !rfs.is_empty() {
+						rfs.set_trailing_comma(true);
+
+						if rfs.trailing().as_str().map(|s| s.is_empty()).unwrap_or(true) {
+							rfs.set_trailing("\n");
+						}
+					}
+				}
+			});
+		}
+	}
+}