Diffing_Engine: Align to changes from Id to ID (#3242)

Author: Fraser Greenroyd

Diffing_Engine/Compute/DiffWithCustomIds.cs

@@ -74,36 +74,36 @@ public static Diff DiffWithCustomIds(List<object> pastObjects, List<string> past
         // "followingObjectsIds": Ids of the "followingObjects" that should be used to match them with the "pastObjects". If no match is found, a followingObject is identified as "added".
         // "diffingConfig": Additional configurations.
         // "recordEvents": Because this method can be called from many different places, some Notes/Warnings/Errors may not be relevant in all cases, so we give the option to turn them off.
-        private static Diff Diffing(IEnumerable<object> pastObjects, IEnumerable<string> pastObjectsIds, IEnumerable<object> followingObjects, IEnumerable<string> followingObjectsIds, DiffingConfig diffingConfig = null, bool recordEvents = true)
+        private static Diff Diffing(IEnumerable<object> pastObjects, IEnumerable<string> pastObjectsIDs, IEnumerable<object> followingObjects, IEnumerable<string> followingObjectsIDs, DiffingConfig diffingConfig = null, bool recordEvents = true)
         {
             // Null guards.
             if (pastObjects == null) pastObjects = new List<object>();
-            if (pastObjectsIds == null) pastObjectsIds = new List<string>();
+            if (pastObjectsIDs == null) pastObjectsIDs = new List<string>();
             if (followingObjects == null) followingObjects = new List<object>();
-            if (followingObjectsIds == null) followingObjectsIds = new List<string>();
+            if (followingObjectsIDs == null) followingObjectsIDs = new List<string>();
             if (diffingConfig == null) diffingConfig = new DiffingConfig();
             diffingConfig.ComparisonConfig = diffingConfig.ComparisonConfig.SetNewEmptyIEnumPropsIfNull();
 
             // Check if we do not allow duplicate Ids
             // (we do not allow duplicate Ids by default – it may make sense in rare cases with Ids imported from some software that allows duplicates).
-            if (!diffingConfig.AllowDuplicateIds)
+            if (!diffingConfig.AllowDuplicateIDs)
             {
                 // Take precautions if duplicate Ids are found.
                 bool duplicateIdsFound = false;
 
                 // Get the distinct Ids from the input Id lists (do not admit duplicates).
-                HashSet<string> pastObjsIdsDistinct = new HashSet<string>(pastObjectsIds);
-                HashSet<string> follObjsIdsDistinct = new HashSet<string>(followingObjectsIds);
+                HashSet<string> pastObjsIdsDistinct = new HashSet<string>(pastObjectsIDs);
+                HashSet<string> follObjsIdsDistinct = new HashSet<string>(followingObjectsIDs);
 
-                if (pastObjsIdsDistinct.Count() != pastObjectsIds.Count())
+                if (pastObjsIdsDistinct.Count() != pastObjectsIDs.Count())
                 {
-                    if (recordEvents) BH.Engine.Base.Compute.RecordWarning($"Some of the input {nameof(pastObjectsIds)} were duplicate.");
+                    if (recordEvents) BH.Engine.Base.Compute.RecordWarning($"Some of the input {nameof(pastObjectsIDs)} were duplicate.");
                     duplicateIdsFound = true;
                 }
 
-                if (follObjsIdsDistinct.Count() != followingObjectsIds.Count())
+                if (follObjsIdsDistinct.Count() != followingObjectsIDs.Count())
                 {
-                    if (recordEvents) BH.Engine.Base.Compute.RecordWarning($"Some of the input {nameof(followingObjectsIds)} were duplicate.");
+                    if (recordEvents) BH.Engine.Base.Compute.RecordWarning($"Some of the input {nameof(followingObjectsIDs)} were duplicate.");
                     duplicateIdsFound = true;
                 }
 
@@ -112,21 +112,21 @@ private static Diff Diffing(IEnumerable<object> pastObjects, IEnumerable<string>
             }
 
             // Check if input objects and correspondent Id lists are of equal size.
-            if (pastObjects.Count() != pastObjectsIds.Count())
+            if (pastObjects.Count() != pastObjectsIDs.Count())
             {
-                if (recordEvents) BH.Engine.Base.Compute.RecordError($"The number of input `{nameof(pastObjects)}` must be the same as the number of input `{nameof(pastObjectsIds)}`.");
+                if (recordEvents) BH.Engine.Base.Compute.RecordError($"The number of input `{nameof(pastObjects)}` must be the same as the number of input `{nameof(pastObjectsIDs)}`.");
                 return null;
             }
 
-            if (followingObjects.Count() != followingObjectsIds.Count())
+            if (followingObjects.Count() != followingObjectsIDs.Count())
             {
-                if (recordEvents) BH.Engine.Base.Compute.RecordError($"The number of input `{nameof(followingObjects)}` must be the same as the number of input `{nameof(followingObjectsIds)}`.");
+                if (recordEvents) BH.Engine.Base.Compute.RecordError($"The number of input `{nameof(followingObjects)}` must be the same as the number of input `{nameof(followingObjectsIDs)}`.");
                 return null;
             }
 
             // Make dictionary with object ids to speed up/simplify the lookups.
-            Dictionary<string, object> pastObjs_dict = pastObjectsIds.Zip(pastObjects, (k, v) => new { k, v }).ToDictionary(x => x.k, x => x.v);
-            Dictionary<string, object> follObjs_dict = followingObjectsIds.Zip(followingObjects, (k, v) => new { k, v }).ToDictionary(x => x.k, x => x.v);
+            Dictionary<string, object> pastObjs_dict = pastObjectsIDs.Zip(pastObjects, (k, v) => new { k, v }).ToDictionary(x => x.k, x => x.v);
+            Dictionary<string, object> follObjs_dict = followingObjectsIDs.Zip(followingObjects, (k, v) => new { k, v }).ToDictionary(x => x.k, x => x.v);
 
             // Dispatch the objects: new, modified or deleted
             List<object> addedObjs = new List<object>();
@@ -240,7 +240,7 @@ private static Diff Diffing(IEnumerable<object> pastObjects, IEnumerable<string>
                 .Select(k => pastObjs_dict[k]).ToList();
 
             // Add user warnings/notes for specific usage scenarios.
-            if (!followingObjectsIds.Intersect(pastObjectsIds).Any())
+            if (!followingObjectsIDs.Intersect(pastObjectsIDs).Any())
             {
                 // If there is no overlap in the keys between the two sets, no "modified" object can have been detected.
                 // This could be either because there are truly no modified objects, or more likely because the user has input objects that do not have a valid Id assigned. 
@@ -265,7 +265,7 @@ private static Diff Diffing(IEnumerable<object> pastObjects, IEnumerable<string>
                         $"\nThis can also happen if the input objects come from models that were completely re-created between revisions (i.e. their IDs are completely different). In this latter case, the Diffing worked successfully but you may want to use a different ID.");
             }
 
-            if (followingObjectsIds.Intersect(pastObjectsIds).Any() && diffingConfig.ComparisonConfig.PropertiesToConsider.Any() && !modifiedObjs.Any())
+            if (followingObjectsIDs.Intersect(pastObjectsIDs).Any() && diffingConfig.ComparisonConfig.PropertiesToConsider.Any() && !modifiedObjs.Any())
             {
                 // If no modified object was found and some PropertiesToConsider was specified,
                 // add a Note to remind the user that if no differences were found it's probably because of that.

Diffing_Engine/Convert/TryParseObjectToGuid.cs

@@ -62,15 +62,15 @@ public static bool TryParseObjectToGuid(this object obj, out Guid guid)
                 var sP = obj as StreamPointer;
                 if (sP != null)
                 {
-                    guid = sP.StreamId;
+                    guid = sP.StreamID;
                     return true;
                 }
 
                 // Check if it's a Revision, and extract the StreamId from there.
                 var rev = obj as Revision;
                 if (rev != null)
                 {
-                    guid = rev.StreamId;
+                    guid = rev.StreamID;
                     return true;
                 }
 

Diffing_Engine/Create/Delta.cs

@@ -43,9 +43,9 @@ public static partial class Create
         // ----------------------------------------------- //
 
         [Description("Returns a Delta object with the Diff between the two input Revisions, also called `Diff-based Delta`.")]
-        [Input("previousRevision", "A previous Revision")]
+        [Input("pastRevision", "A previous Revision")]
         [Input("currentRevision", "A new Revision")]
-        [Input("DiffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
+        [Input("diffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
         public static Delta Delta(Revision pastRevision, Revision currentRevision, DiffingConfig diffingConfig = null, string comment = null)
         {
             if(pastRevision == null)
@@ -62,7 +62,7 @@ public static Delta Delta(Revision pastRevision, Revision currentRevision, Diffi
 
             Diff diff = Compute.DiffRevisions(pastRevision, currentRevision, diffingConfig);
 
-            return new Delta(pastRevision.StreamId, diff, pastRevision.RevisionId, currentRevision.RevisionId, DateTime.UtcNow.Ticks, m_Author, comment);
+            return new Delta(pastRevision.StreamID, diff, pastRevision.RevisionID, currentRevision.RevisionID, DateTime.UtcNow.Ticks, m_Author, comment);
         }
 
         // ----------------------------------------------- //
@@ -71,7 +71,7 @@ public static Delta Delta(Revision pastRevision, Revision currentRevision, Diffi
 
         [Description("Returns a Delta object containing all the objects of the input Revision, also called `Revision-Based Delta`.")]
         [Input("revision", "A new Revision")]
-        [Input("DiffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
+        [Input("diffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
         public static Delta Delta(Revision revision, DiffingConfig diffingConfig = null, string comment = null)
         {
             if(revision == null)
@@ -82,31 +82,32 @@ public static Delta Delta(Revision revision, DiffingConfig diffingConfig = null,
 
             Diff diff = Compute.DiffRevisions(null, revision, diffingConfig);
 
-            return new Delta(revision.StreamId, diff, revision.RevisionId, new Guid(), DateTime.UtcNow.Ticks, m_Author, comment);
+            return new Delta(revision.StreamID, diff, revision.RevisionID, new Guid(), DateTime.UtcNow.Ticks, m_Author, comment);
         }
 
+        [PreviousInputNames("streamID", "streamId")]
         [Description("Returns a Delta object, containing all the input objects wrapped in a Revision. Also called `Revision-Based Delta`.")]
         [Input("objects", "Objects that will be wrapped into a new Revision in order to produce this Delta.")]
-        [Input("streamId", "Id of the Stream that will own the revision produced by this Delta.")]
+        [Input("streamID", "Id of the Stream that will own the revision produced by this Delta.")]
         [Input("revisionName", "Name to be assigned to the Revision that this Delta will produce.")]
         [Input("comment", "Comment to be stored along the Revision that this Delta will produce.")]
-        [Input("DiffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
-        public static Delta Delta(List<IBHoMObject> objects, object streamId, string revisionName = null,
+        [Input("diffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
+        public static Delta Delta(List<IBHoMObject> objects, object streamID, string revisionName = null,
              string comment = null, DiffingConfig diffingConfig = null)
         {
-            Revision revision = Create.Revision(objects, streamId, revisionName, comment, diffingConfig);
+            Revision revision = Create.Revision(objects, streamID, revisionName, comment, diffingConfig);
             return Delta(revision, diffingConfig, comment);
         }
 
         [Description("Returns a Delta object based on the provided Diff.")]
         [Input("diff", "Diff that will be included in this Delta.")]
-        [Input("streamId", "Id of the Stream that will own the revision produced by this Delta.")]
-        [Input("revisionName", "Name to be assigned to the Revision that this Delta will produce.")]
+        [Input("streamID", "ID of the Stream that will own the revision produced by this Delta.")]
+        [Input("revisionFrom", "ID of revision this delta is going from..")]
         [Input("comment", "Comment to be stored along the Revision that this Delta will produce.")]
-        [Input("DiffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
-        public static Delta Delta(Diff diff, object streamId, Guid revision_from, string comment = null, DiffingConfig diffingConfig = null)
+        [Input("diffingConfig", "Sets configs such as properties to be ignored in the diffing, or enable/disable property-by-property diffing.\nBy default it takes the DiffingConfig property of the Revision. This input can be used to override it.")]
+        public static Delta Delta(Diff diff, object streamID, Guid revisionFrom, string comment = null, DiffingConfig diffingConfig = null)
         {
-            return new Delta(ProcessStreamId(streamId), diff, revision_from, new Guid(), DateTime.UtcNow.Ticks, m_Author, comment);
+            return new Delta(ProcessStreamId(streamID), diff, revisionFrom, new Guid(), DateTime.UtcNow.Ticks, m_Author, comment);
         }
 
         // ----------------------------------------------- //