I've been testing a variation of your Heckel implementation in a macOS CollectionView project and found an issue. Using hashValue as the key in the table is not reliable. I've made this same mistake myself in early versions of the data structures used in that collection view implementation. My basic solution for now is to replace with [T.Element:TableEntry] and the issue hasn't come up again.

From the Apple Docs

A hash value, provided by a type’s hashValue property, is an integer that is the same for any two instances that compare equally. That is, for two instances a and b of the same type, if a == b, then a.hashValue == b.hashValue. The reverse is not true: Two instances with equal hash values are not necessarily equal to each other.

I'm having trouble getting the default algorithm to do replacements instead of deletes followed by inserts. Even this basic code...

let old = [
    "New York",
    "Imagine City",
    "London"
]

let new = [
    "New York",
    "Oslo",
    "London",
    ]

let changes = diff(old: old, new: new)

...gives me a delete followed by an insert. Whereas using let changes = diff(old: old, new: new, algorithm: WagnerFischer()) makes everything work correctly.

Is this an intentional attribute of the Heckel algorithm?

Both UICollectionView+Extensions and UITableView+Extensions need to add closures for updating the data model after performBatchUpdates is called but before updates are applied (Example fix below):

public func reload<T: Hashable>(
    changes: [Change<T>],
    section: Int = 0,
    updateModel: (() -> Void)? = nil, // <===== This should fix #8 
    completion: ((Bool) -> Void)? = nil) {
    
    let changesWithIndexPath = IndexPathConverter().convert(changes: changes, section: section)
    
    // reloadRows needs to be called outside the batch
    
    performBatchUpdates({
      updateModel?()                  // <===== This should fix #8 
      internalBatchUpdates(changesWithIndexPath: changesWithIndexPath)
    }, completion: { finished in
      completion?(finished)
    })
    
    changesWithIndexPath.replaces.executeIfPresent {
      self.reloadItems(at: $0)
    }
  }

Otherwise, you'll see NSInternalInconsistencyExceptions since the model will already have the same number of items before and after update.

hi! wondering if you'd be able to set the Build Libraries For Distribution flag to YES in the project's build settings. i use deep diff through Carthage and this would help to ensure support for new swift versions which seem to come with every new xcode release.

thank you !

I have try to make extension for ASTableNode & ASCollectionNode (both from ASDK) with DeepDiff. So the ChangeWithIndexPath, IndexPathConverter & Array.executeIfPresent need to be public.

Could you make it happen?

Hey @onmyway133

I've faced a crash when using sections in UITableView. I have a regular controller with some array of data

var data: Array<ParticipantData> = []

By design I want to use each item of this array as a section and inner array (items) as rows in this section. Here is ParticipantData:

class ParticipantData {
 let id: Int
 let items: Array<Item>

    class func compareContent(_ a: ParticipantData, _ b: ParticipantData) -> Bool {
       // Compare ids and items
        return a.id == b.id && Comparator.compare(a.items, b.items)
    }

    public var diffId: Int {
        return self.id
    }
}

For calculating difference between collections I'm calling following code:

if (!newData.isEmpty) {
               // Calculate diff between old and new data
                let changes = diff(old: self.data, new: newData)

               // deliver results
              // Neither section: self.data.count nor newData.count works
                self.tableView.reload(changes: changes, section: self.data.count, replacementAnimation: UITableView.RowAnimation.none, updateData: {
                    self.data = newData
                })
} else {
               // Tried a fix with reloading data when it's empty
                self.tableView.reloadData()
}

And code which is responsible for displaying sections and rows:

extension MainController: UITableViewDataSource, UITableViewDelegate {
    public func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
       // Each section has as many rows as it has items 
       return data[section].items.count
    }

    public func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = UITableViewCell()
        cell.textLabel?.text = "\(indexPath.section): \(indexPath.row)"
        return cell
    }

    public func numberOfSections(in tableView: UITableView) -> Int {
        // We have as many sections as items in array
        return data.count
    }

    public func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
        return "Title"
    }
}

As result I have a crash 'NSInternalInconsistencyException', reason: 'Invalid update: invalid number of sections. The number of sections contained in the table view after the update (1) must be equal to the number of sections contained in the table view before the update (0), plus or minus the number of sections inserted or deleted (0 inserted, 0 deleted).'

Interesting thing: it's working when there is no numberOfSections method

Hey! We're trying to use DeepDiff with UIStackView which does not offer batch updates support as UITableView and UICollectionView. This means that when we get an insert we insert a new arrangedSubview, when we get a delete we delete it, and so on.

We narrowed down the problem to the following example:

var old = ["Category3", "Category2", "Category4", "Category5", "Category1"]
let new = ["Category1", "Category2", "Category3", "Category4", "Category5"]

let algorithm = WagnerFischer<String>()
let changes = algorithm.diff(old: old, new: new)

changes.forEach { change in
    switch change {
    case .insert(let info):
        old.insert(info.item, at: info.index)
    case .delete(let info):
        old.remove(at: info.index)
    case .move(let info):
        old.remove(at: info.fromIndex)
        old.insert(info.item, at: info.toIndex)
    case .replace(let info):
        old.remove(at: info.index)
        old.insert(info.newItem, at: info.index)
    }
}

print(old) // ["Category1", "Category2", "Category3", "Category4", "Category1"]

(lldb) po changes
▿ replace : Replace<String>
  - oldItem : "Category3"
  - newItem : "Category1"
  - index : 0
▿ insert : Insert<String>
  - item : "Category3"
  - index : 2
▿ delete : Delete<String>
  - item : "Category1"
  - index : 4

As you can see the output is not correct. We're probably missing something at some point but cannot identify where.

Let us know. Thanks!

While this issue is related to #1 , what I propose is to make DeepDiff applicable to calculate Diff in any section other than 0. Currently, the section number is hardcoded to be 0.

What I propose, is to add a section parameter to the API to generate valid IndexPaths, for example:

let changes = diff(old: oldItems, new: items, section: 4)

hey! I was surprised to see that Heckel didn't have static functions, and instead expects diffs to be carried out on an instance. i noticed that in my usage of the class, i have

    public func update(data: [ListSection], animating: Bool = false, completion: (() -> Void)? = nil) {
        if self.data.isNotEmpty {
            let diff = HeckelDiffingAlgorithm().diff(old: self.data, new: data)

where I create a new instance each time. Is that required? or can I create one instance and reuse it each time my data changes?

Hi, I am trying to use DeepDiff and my models are sql objects that are returned from my backend. To enable the use of deepdiff, I need to be able to return a diffId in the to conform to the protocol DiffAware.

The problem arises that my sql objects have composite primary keys, meaning that it requires more than just one element to compare each object's uniqueness. It is easy to do checks in the compareContent function, but I am very puzzled to how one would go about declaring the diffId to ensure that these types can return a hash, and that being a string has since all of my attributes are composed of strings.

An example object is instantiated like Object(place: String, date: String, time: String, reason: String). Where the primary key is composed of the place, date and time values. How would one go about setting the diffId for this object?

I hope this example makes sense.

Thank you.

Hi, i am trying to implement a text-base diff viewer, my code looks like the following:

let originalLines = originalSource.split(separator: "\n", omittingEmptySubsequences: false).map{String($0)}


let diffLines = diffSource.split(separator: "\n", omittingEmptySubsequences: false).map{String($0)}
            
            
let algorithmStart = CACurrentMediaTime()
let diffchecker = WagnerFischer<String>(reduceMove: false)
let changes = diffchecker.diff(old: originalLines, new: diffLines)
DC_LOG_INFO("DiffVC, diff algorithm cost \(CACurrentMediaTime() - algorithmStart)")

my sample files are 2 objc source files with 650+lines, and only 1 line is different , and the log prints out: DiffVC, diff algorithm cost 6.890240641998389

Any idea of why this is so slow?

In my situation, I make diffing between two different classes packaged by the same enum. As: enum PackagingEnum: DiffAware { case a(ClassA) case b(ClassB)

var diffId: Int {
    switch self {
    case a(let classA):
        return classA.hashValue
    case b(let classB)
        return classB.hashValue
    }
}

} in this case, I want to make diffing [ClassA] to [ClassB] via DeepDiff.

but when I get the changes by 'diff(old: [Enum-B], new: [Enum-A])'

I traverse the changes, and invoke 'insert/remove/move' in [Enum-B](the old), I get crashed because of 'Out of Range'

invalidManifestFormat("/var/folders/6q/wgy6jtp12w5gzgm9lzcglpqw0000gn/T/TemporaryFile.rCB6P4.swift:11:19: error: 'v6' is unavailable\n .watchOS(.v6)\n ^~\nPackageDescription.SupportedPlatform:45:27: note: 'v6' was introduced in PackageDescription 5.1\n public static var v6: PackageDescription.SupportedPlatform.WatchOSVersion\n ^", diagnosticFile: Optional(AbsolutePath:"/Users/vagrant/Library/Developer/Xcode/DerivedData/Harper-cxngxloxijxbllfwrovkiaxoqvem/SourcePackages/ManifestLoading/deepdiff.dia")) in https://github.com/onmyway133/DeepDiff

Introduced in 2.3.2.

Caused by this change: https://github.com/onmyway133/DeepDiff/commit/86d6b51b47804e380801f4eba45297cb07788b18#diff-f913940c58e8744a2af1c68b909bb6383e49007e6c5a12fb03104a9006ae677eR11

I'm not getting this on all versions of Xcode. For example, it's working on Xcode 12.5 RC on my machine. But it fails consistently on Bitrise with Xcode 12.4 and 12.5.

Hello,

Should I implement diifId If object is already conforming Hashable? I am using RealmSwift and my class conforms Object protocol which also conforms Hashable. My problem is that I have an unique string as primary key and that value is used as hashValue. (I don't know how Realm handles it). Therefore, I believe It generates unique int from that string which is used on hash function. When I add below code, I can't be sure If id is unique every time. Therefore, I don't wanna add it.

    var diffId: Int {
        return identifier.hashValue
    }

We should encourage users to hook into the willSet parameter as the tableview / collection view are finicky and will crash when the underlying data is not atomically set.

Hi, Thanks for the great work done on this. I'm running into an issue adding a new section that did not exist in the first place. Is there any way to handle a diff such that it creates a new section altoegther and then inserts the diff row ?

Error is below. Invalid update: invalid number of sections. The number of sections contained in the collection view after the update (2) must be equal to the number of sections contained in the collection view before the update (1), plus or minus the number of sections inserted or deleted (0 inserted, 0 deleted).