ordered collection strategies (#29)

* generic levenshtein impl

* integrate levenshtein difference as the ordered_array_like collection strategy

Author: knickish

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "structdiff"
-version = "0.6.2"
+version = "0.6.3"
 edition = "2021"
 license = "Apache-2.0 OR MIT"
 repository = "https://github.com/knickish/structdiff"
@@ -12,7 +12,7 @@ categories    = ["compression"]
 nanoserde           = { version = "^0.1.37", optional = true }
 rustc-hash          = { version = "1.1.0", optional = true }
 serde               = { version = "^1.0.0", optional = true, features = ["derive"] }
-structdiff-derive   = { path = "derive", version = "=0.6.2" }
+structdiff-derive   = { path = "derive", version = "=0.6.3" }
 
 [features]
 "default"       = []

README.md

@@ -50,10 +50,11 @@ For more examples take a look at [integration tests](/tests)
 ## Derive macro attributes
 - `#[difference(skip)]` - Do not consider this field when creating a diff
 - `#[difference(recurse)]` - Generate a StructDiff for this field when creating a diff
-- `#[difference(collection_strategy = {})]` 
-    - `"unordered_array_like"` - Generates a changeset for array-like collections of items which implement `Hash + Eq`, rather than cloning the entire list. (currently works for `Vec`, `BTreeSet`, `LinkedList`, and `HashSet`)
-    - `"unordered_map_like"` - Generates a changeset for map-like collections for which the key implements `Hash + Eq`, rather than cloning the entire map. (currently works for `HashMap` and `BTreeMap`)
-- `#[difference(map_equality = {})]` - Used with `unordered_map_like`, specifies whether the equality check should consider keys only, or both keys and values
+- `#[difference(collection_strategy = {})]`
+    - `"ordered_array_like"` - Generates a minimal changeset for ordered, array-like collections of items which implement `PartialEq`. (uses levenshtein difference)
+    - `"unordered_array_like"` - Generates a minimal changeset for unordered, array-like collections of items which implement `Hash + Eq`.
+    - `"unordered_map_like"` - Generates a minimal changeset for unordered, map-like collections for which the key implements `Hash + Eq`.
+- `#[difference(map_equality = {})]` - Used with `unordered_map_like`
     - `"key_only"` - only replace a key-value pair for which the key has changed
     - `"key_and_value"` - replace a key-value pair if either the key or value has changed
 - `#[difference(setters)]` - Generate setters for all fields in the struct (used on struct)

derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "structdiff-derive"
-version = "0.6.2"
+version = "0.6.3"
 authors = ["Makepad <[email protected]>", "Fedor <[email protected]>", "Kirk <[email protected]"]
 edition = "2018"
 description = "derive macro library for structdiff"

derive/src/difference.rs

@@ -482,6 +482,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                     l!(diff_ref_body, "{}", diff_body_fragment_ref);
                 },
                 (true, Some(strat), false) => match strat {
+                    crate::shared::CollectionStrategy::OrderedArrayLike => { panic!("Recursion inside of array-like collections is not yet supported"); },
                     crate::shared::CollectionStrategy::UnorderedArrayLikeHash => { panic!("Recursion inside of array-like collections is not yet supported"); },
                     crate::shared::CollectionStrategy::UnorderedMapLikeHash(crate::shared::MapStrategy::KeyAndValue) => {
                         let generic_names = field.ty.wraps.as_ref().map(|x| x.iter().map(|y| y.full().clone()).collect::<Vec<_>>()).expect("Missing types for map creation").join(",");
@@ -581,13 +582,17 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                             (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
                                 l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                l!(setters_body, "\n\tstructdiff::collections::unordered_map_like_recursive::unordered_hashcmp(self.{}.iter(), value.iter(), true)", field_name);
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like_recursive::unordered_hashcmp(self.{}.iter(), value.iter(), true);", field_name);
+                                l!(setters_body, "\n\tself.{} = value;", field_name);
+                                l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
                             },
                             (true, (_, false, None)) | (false, (true, false, None)) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
                                 l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                l!(setters_body, "\n\tstructdiff::collections::unordered_map_like_recursive::unordered_hashcmp(self.{}.iter(), value.iter(), true)", field_name);
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like_recursive::unordered_hashcmp(self.{}.iter(), value.iter(), true);", field_name);
+                                l!(setters_body, "\n\tself.{} = value;", field_name);
+                                l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
                             },
                             _ => ()
@@ -599,6 +604,74 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                 },
                 (false, Some(_), true) => panic!("Collection strategies inside of options are not yet supported"),
                 (false, Some(strat), false) => match strat {
+                    crate::shared::CollectionStrategy::OrderedArrayLike => {
+                        let generic_ref_names = field.ty.wraps.as_ref().map(|x| x.iter().map(|y| y.full()).collect::<Vec<_>>()).expect("Missing types for map creation").join(", &'__diff_target ");
+                        l!(diff_enum_body, " {}(structdiff::collections::ordered_array_like::OrderedArrayLikeDiffOwned<{}>),", field_name, field.ty.wraps.as_ref().expect("Using collection strategy on a non-collection")[0].full());
+                        l!(diff_ref_enum_body, " {}(structdiff::collections::ordered_array_like::OrderedArrayLikeDiffRef<'__diff_target, {}>),", field_name, generic_ref_names);
+
+                        l!(
+                            apply_single_body,
+                            "Self::Diff::{}(__{}) => self.{} = structdiff::collections::ordered_array_like::apply(__{}, std::mem::take(&mut self.{})).collect(),",
+                            field_name,
+                            index,
+                            field_name,
+                            index,
+                            field_name
+                        );
+
+                        l!(
+                            diff_body,
+                            "if let Some(list_diffs) = structdiff::collections::ordered_array_like::levenshtein(&updated.{}, &self.{}) {{
+                                diffs.push(Self::Diff::{}(list_diffs.into()));
+                            }};"
+                            ,
+                            field_name,
+                            field_name,
+                            field_name
+                        );
+
+                        l!(
+                            diff_ref_body,
+                            "if let Some(list_diffs) = structdiff::collections::ordered_array_like::levenshtein(&updated.{}, &self.{}) {{
+                                diffs.push(Self::DiffRef::{}(list_diffs));
+                            }};"
+                            ,
+                            field_name,
+                            field_name,
+                            field_name
+                        );
+
+                        l!(
+                            ref_into_owned_body,
+                            "\t {}Ref::{}(v) => {}::{}(v.into()),",
+                            enum_name,
+                            field_name,
+                            enum_name,
+                            field_name
+                        );
+
+                        #[cfg(feature = "generated_setters")]
+                        match (all_setters, attrs_setter(&field.attributes)) {
+                            (_, (_, true, _)) => (),
+                            (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
+                                l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
+                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::ordered_array_like::levenshtein(&value, &self.{}).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\n\tself.{} = value;", field_name);
+                                l!(setters_body, "\n\tret");
+                                l!(setters_body, "\n}");
+                            },
+                            (true, (_, false, None)) | (false, (true, false, None)) => {
+                                l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
+                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::ordered_array_like::levenshtein(&value, &self.{}).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\n\tself.{} = value;", field_name);
+                                l!(setters_body, "\n\tret");
+                                l!(setters_body, "\n}");
+                            },
+                            _ => ()
+                        };
+                    }
                     crate::shared::CollectionStrategy::UnorderedArrayLikeHash => {
                         let generic_ref_names = field.ty.wraps.as_ref().map(|x| x.iter().map(|y| y.full()).collect::<Vec<_>>()).expect("Missing types for map creation").join(", &'__diff_target ");
                         l!(diff_enum_body, " {}(structdiff::collections::unordered_array_like::UnorderedArrayLikeDiff<{}>),", field_name, field.ty.wraps.as_ref().expect("Using collection strategy on a non-collection")[0].full());
@@ -651,13 +724,17 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                             (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
                                 l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                l!(setters_body, "\n\tstructdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as StructDiff>::Diff::{}(x.into()))", field_name, field_name);
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\n\tself.{} = value;", field_name);
+                                l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
                             },
                             (true, (_, false, None)) | (false, (true, false, None)) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
                                 l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                l!(setters_body, "\n\tstructdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as StructDiff>::Diff::{}(x.into()))", field_name, field_name);
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\n\tself.{} = value;", field_name);
+                                l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
                             },
                             _ => ()
@@ -717,13 +794,17 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                                 (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
                                     l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                    l!(setters_body, "\n\tstructdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as StructDiff>::Diff::{}(x.into()))", field_name, field_name);
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\n\tself.{} = value;", field_name);
+                                    l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
                                 },
                                 (true, (_, false, None)) | (false, (true, false, None)) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
                                     l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                    l!(setters_body, "\n\tstructdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as StructDiff>::Diff::{}(x.into()))", field_name, field_name);
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\n\tself.{} = value;", field_name);
+                                    l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
                                 },
                                 _ => ()
@@ -782,13 +863,17 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                                 (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
                                     l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                    l!(setters_body, "\n\tstructdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as StructDiff>::Diff::{}(x.into()))", field_name, field_name);
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\n\tself.{} = value;", field_name);
+                                    l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
                                 },
                                 (true, (_, false, None)) | (false, (true, false, None)) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
                                     l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                    l!(setters_body, "\n\tstructdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as StructDiff>::Diff::{}(x.into()))", field_name, field_name);
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\n\tself.{} = value;", field_name);
+                                    l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
                                 },
                                 _ => ()

derive/src/shared.rs

@@ -17,6 +17,7 @@ pub enum MapStrategy {
 
 #[derive(Debug)]
 pub enum CollectionStrategy {
+    OrderedArrayLike,
     UnorderedArrayLikeHash,
     UnorderedMapLikeHash(MapStrategy),
 }
@@ -66,6 +67,7 @@ pub fn attrs_collection_type(attributes: &[crate::parse::Attribute]) -> Option<C
     attributes.iter().find_map(|attr| {
         if attr.tokens.len() == 2 && attr.tokens[0] == "collection_strategy" {
             let strategy = match attr.tokens[1].clone().as_str() {
+                "ordered_array_like" => CollectionStrategy::OrderedArrayLike,
                 "unordered_array_like" => CollectionStrategy::UnorderedArrayLikeHash,
                 "unordered_map_like" => {
                     let map_compare_type = attrs_map_strategy(attributes).unwrap_or_default();

src/collections/mod.rs

@@ -1,3 +1,5 @@
 pub mod unordered_array_like;
 pub mod unordered_map_like;
 pub mod unordered_map_like_recursive;
+
+pub mod ordered_array_like;