From 376bfb28524c72b29bfc2a90d49bf86989e2723e Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Mon, 3 Jul 2023 08:26:04 +0200 Subject: [PATCH 1/2] Experimental sort of exported content --- README.md | 7 +++++++ src/cli.rs | 5 +++++ src/main.rs | 5 +++++ 3 files changed, 17 insertions(+) diff --git a/README.md b/README.md index 67dbf6a..3c3fea8 100644 --- a/README.md +++ b/README.md @@ -58,6 +58,13 @@ Hierzu ist die Option `--compact` vorgesehen. Es können, je nach Datei, bis zu Bei der Auflistung der Inhalte, kann die Option `--sorted` dazu verwendet werden, die angezeigten Einträge alphabetisch zu sortieren. Die Sortierung erfolgt dabei nach Namen des Katalogs oder des Formulars. +##### Experimentell: Sortierung nach Modifikation + +Beim Modifizieren der Inhalte kann die experimentelle Option `--x-sorted` dazu verwendet werden, die Einträge im Anschluss an die Modifikation +nach Namen zu sortieren. +Dies erlaubt eine konsistente Reihenfolge der Einträge, wodurch ein direkter Vergleich mit Vorversionen ermöglicht wird. +ACHTUNG: Es kann sein, dass dadurch ein Import der resultierenden OSC-Datei nicht mehr möglich ist, da das genaue Verhalten des Imports aktuell noch nicht bekannt ist. + ## Profile Zum Erstellen von Varianten einer OSC-Datei wird eine Profildatei im YAML-Format verwendet. diff --git a/src/cli.rs b/src/cli.rs index eb048a7..2a3d6fb 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -52,6 +52,11 @@ pub enum Command { outputfile: Option, #[arg(long = "compact", help = "Kompakte Ausgabe, ohne Einrücken (Optional)")] compact: bool, + #[arg( + long = "x-sorted", + help = "EXPERIMENTELL: Sortiere Kataloge und Formulare nach Name (Optional). Kann negative Auswirkungen auf den ordnungsgemäßen Import haben." + )] + sorted: bool, }, #[command(about = "Vergleiche zwei Dateien anhand der Revision der enthaltenen Inhalte")] Diff { diff --git a/src/main.rs b/src/main.rs index 79bbda3..d9dde7d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -122,6 +122,7 @@ fn main() -> Result<(), Box> { profile, outputfile, compact, + sorted, } => { let data = &mut read_inputfile(inputfile)?; @@ -132,6 +133,10 @@ fn main() -> Result<(), Box> { data.apply_profile(&profile); } + if sorted { + data.sorted(); + } + let mut buf = String::new(); let mut serializer = Serializer::new(&mut buf); From e84a39b7c46324d3c1246ffc3e5e13fbab67d473 Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Mon, 7 Aug 2023 14:16:44 +0200 Subject: [PATCH 2/2] Apply exported sorting to items itself and nested items --- src/model/data_catalogue.rs | 33 +++++++++++ src/model/data_form.rs | 43 ++++++++++++++ src/model/mod.rs | 6 ++ src/model/onkostar_editor.rs | 18 +++++- src/model/property_catalogue.rs | 100 ++++++++++++++++++++++++++++++++ src/model/unterformular.rs | 43 ++++++++++++++ 6 files changed, 242 insertions(+), 1 deletion(-) diff --git a/src/model/data_catalogue.rs b/src/model/data_catalogue.rs index 02d3dd7..1c98b2b 100644 --- a/src/model/data_catalogue.rs +++ b/src/model/data_catalogue.rs @@ -70,6 +70,16 @@ impl Sortable for DataCatalogue { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + self.entries + .entry + .sort_unstable_by_key(|item| item.sorting_key()); + self.entries.entry.iter_mut().for_each(|item| { + item.sorted(); + }); + self + } } impl Comparable for DataCatalogue { @@ -151,6 +161,23 @@ pub struct Entry { revision: u16, } +impl Sortable for Entry { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut use_) = self.use_ { + use_.program_module + .sort_unstable_by_key(|item| item.sorting_key()) + } + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct Use { @@ -166,3 +193,9 @@ pub struct ProgramModule { #[serde(rename = "@name")] name: String, } + +impl Sortable for ProgramModule { + fn sorting_key(&self) -> String { + format!("{}-{}", self.program, self.name) + } +} diff --git a/src/model/data_form.rs b/src/model/data_form.rs index eff5eab..b545258 100644 --- a/src/model/data_form.rs +++ b/src/model/data_form.rs @@ -192,6 +192,29 @@ impl Sortable for DataForm { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + self.data_catalogues.data_catalogue.sort_unstable(); + + self.entries + .entry + .sort_unstable_by_key(|item| item.sorting_key()); + + self.entries.entry.iter_mut().for_each(|item| { + item.sorted(); + }); + + if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule { + plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone()); + + plausibility_rule.iter_mut().for_each(|item| { + if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name { + data_form_entry_names.sort_unstable(); + } + }); + } + self + } } impl Comparable for DataForm { @@ -433,6 +456,26 @@ impl FormEntry for Entry { } } +impl Sortable for Entry { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut filter) = self.filter { + if let Some(ref mut ref_entries) = filter.ref_entries { + if let Some(ref mut ref_entry) = ref_entries.ref_entry { + ref_entry.sort_unstable() + } + } + } + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct DataFormEntries { diff --git a/src/model/mod.rs b/src/model/mod.rs index 67783d2..bb20d0d 100644 --- a/src/model/mod.rs +++ b/src/model/mod.rs @@ -239,6 +239,12 @@ pub trait Listable { pub trait Sortable { fn sorting_key(&self) -> String; + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + self + } } pub trait Comparable: Debug { diff --git a/src/model/onkostar_editor.rs b/src/model/onkostar_editor.rs index 1ec3307..914856a 100644 --- a/src/model/onkostar_editor.rs +++ b/src/model/onkostar_editor.rs @@ -79,17 +79,33 @@ impl OnkostarEditor { .property_catalogue .sort_unstable_by_key(|e| e.sorting_key()); + self.editor.property_catalogue.iter_mut().for_each(|item| { + item.sorted(); + }); + self.editor .data_catalogue .sort_unstable_by_key(|e| e.sorting_key()); + self.editor.data_catalogue.iter_mut().for_each(|item| { + item.sorted(); + }); + self.editor .data_form .sort_unstable_by_key(|e| e.sorting_key()); + self.editor.data_form.iter_mut().for_each(|item| { + item.sorted(); + }); + self.editor .unterformular .sort_unstable_by_key(|e| e.sorting_key()); + + self.editor.unterformular.iter_mut().for_each(|item| { + item.sorted(); + }); } pub fn print_diff(&mut self, other: &mut Self, strict: bool) { @@ -182,7 +198,7 @@ impl OnkostarEditor { _ => { if strict && entry_a.get_hash() != entry_b.get_hash() { println!( - "{}: {} (z.B. Reihenfolge von Unterelementen)", + "{}: {} (z.B. GUID oder Reihenfolge von Unterelementen)", entry_a.get_name(), style("Inhaltlich verschieden").yellow() ); diff --git a/src/model/property_catalogue.rs b/src/model/property_catalogue.rs index 72f8256..3d59850 100644 --- a/src/model/property_catalogue.rs +++ b/src/model/property_catalogue.rs @@ -67,6 +67,16 @@ impl Sortable for PropertyCatalogue { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + if let Some(ref mut versions) = self.versions.entry { + versions.sort_unstable_by_key(|item| item.version_number); + versions.iter_mut().for_each(|version| { + version.sorted(); + }); + } + self + } } impl Comparable for PropertyCatalogue { @@ -115,6 +125,40 @@ pub struct Version { categories: Categories, } +impl Sortable for Version { + fn sorting_key(&self) -> String { + self.oid.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut abbildung) = self.abbildung { + abbildung.sort_unstable_by_key(|item| item.sorting_key()); + abbildung.iter_mut().for_each(|item| { + item.sorted(); + }); + } + + self.entries + .content + .sort_unstable_by_key(|item| item.sorting_key()); + self.entries.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self.categories + .content + .sort_unstable_by_key(|item| item.sorting_key()); + self.categories.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct VersionEntries { @@ -141,6 +185,12 @@ pub struct VersionEntry { position: String, } +impl Sortable for VersionEntry { + fn sorting_key(&self) -> String { + self.code.clone() + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct Categories { @@ -165,6 +215,26 @@ pub struct Category { category_entries: CategoryEntries, } +impl Sortable for Category { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + self.category_entries + .content + .sort_unstable_by_key(|item| item.sorting_key()); + self.category_entries.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct CategoryEntries { @@ -191,6 +261,12 @@ pub struct CategoryEntry { note: Option, } +impl Sortable for CategoryEntry { + fn sorting_key(&self) -> String { + self.code.clone() + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct Abbildung { @@ -200,6 +276,24 @@ pub struct Abbildung { content: Vec, } +impl Sortable for Abbildung { + fn sorting_key(&self) -> String { + self.ziel_mk_version_oid.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + self.content.sort_unstable_by_key(|item| item.sorting_key()); + self.content.iter_mut().for_each(|item| { + item.sorted(); + }); + + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct AbbildungEintrag { @@ -209,6 +303,12 @@ pub struct AbbildungEintrag { entry_to: AbbildungEntry, } +impl Sortable for AbbildungEintrag { + fn sorting_key(&self) -> String { + format!("{}-{}", self.entry_from.code, self.entry_to.code) + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct AbbildungEntry { diff --git a/src/model/unterformular.rs b/src/model/unterformular.rs index 01a60c1..8d37472 100644 --- a/src/model/unterformular.rs +++ b/src/model/unterformular.rs @@ -211,6 +211,29 @@ impl Sortable for Unterformular { fn sorting_key(&self) -> String { self.name.clone() } + + fn sorted(&mut self) -> &Self { + self.data_catalogues.data_catalogue.sort_unstable(); + + self.entries + .entry + .sort_unstable_by_key(|item| item.sorting_key()); + + self.entries.entry.iter_mut().for_each(|item| { + item.sorted(); + }); + + if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule { + plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone()); + + plausibility_rule.iter_mut().for_each(|item| { + if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name { + data_form_entry_names.sort_unstable(); + } + }); + } + self + } } impl Comparable for Unterformular { @@ -453,6 +476,26 @@ impl FormEntry for Entry { } } +impl Sortable for Entry { + fn sorting_key(&self) -> String { + self.name.clone() + } + + fn sorted(&mut self) -> &Self + where + Self: Sized, + { + if let Some(ref mut filter) = self.filter { + if let Some(ref mut ref_entries) = filter.ref_entries { + if let Some(ref mut ref_entry) = ref_entries.ref_entry { + ref_entry.sort_unstable() + } + } + } + self + } +} + #[derive(Serialize, Deserialize, Debug)] #[serde(deny_unknown_fields)] pub struct DataFormEntries {