This looks like it could be an OptionSet.

Brilliant. Didn't know about optionset. Thanks. Partially doing this to get better at swift, definitely appreciate the feedback.

I think you could just declare the rawValue to be UInt32.

Makes sense. Can't remember why I wrote it this way but I'll clean it up.

I don't think we need to put Git in the type names. It's a bit redundant. ☺️

I think this could just be declared as UInt32.

I think we can name this diff(for commit: Commit).

This code doesn't look any different than the code in getDiffDeltasWithOneParent, so I think that function can be removed. This function can be used instead and the loop will do the right thing.

I think we can call this status().

The return code for this function should be checked.

The code here is duplicated with the code in the previous if. Can you add a function that creates a GitDiffDelta from a git_diff_delta? Probably adding an init to GitDiffDelta is the best way to do this.

This should be an init on GitStatus instead of a method here.

This should be an init on GitDiffFile.

This should be a DiffFlag.

I think this should have a plural name. DiffFlags

What do you think of adding a Diff type that holds the deltas and then nesting these types inside of it?

public struct Diff {
   public struct File { … }

   public struct Flag: OptionSet { ... }

   public struct Delta {
     public var status: Status
     public var flags: DiffFlag
     public var oldFile: File
     public var newFile: File
   }

   let deltas: [Delta]
}

The only caveat with this is that to create an array of a nested struct defined that way, you apparently need to typealias it like so typealias Delta = Diff.Delta; var returnDict = [Delta](), but otherwise i like the organization it provides

Why are these all optional?

you're right, only the files need to be optional as libgit2 will return nil depending on the delta

This probably shouldn't be optional?

git_diff_tree_to_tree, git_commit_lookup, and git_commit_tree are all used multiple times, but they're quite a bit of code. It seems like we could create helper functions for these? That should really improve readability here.

Can we make the StatusEntry.init take the git_status_entry and do this work?

This name needs to be updated

This test (and the following ones) are testing diff, so they should be in a separate describe.

No that these are nicely abstracted, we can use flatMap to propagate errors automatically.

return self
    .commit(with: commit.oid)
    .flatMap { baseCommit in
        return self.tree(from: baseCommit)
    }
    .flatMap { baseTree in
        guard !commit.parents.isEmpty else {
            // Initial commit in a repository
            return self.diff(withOldTree: nil, andNewTree: baseTree.value)
        }

        var mergeDiff: Result<OpaquePointer?, NSError> = .success(nil)
        for parent in commit.parents {
            mergeDiff = mergeDiff
                .flatMap { mergeDiff in
                    return self
                        .parentCommit(from: parent)
                        .flatMap { commit in
                            return self.tree(from: commit)
                        }
                        .flatMap { tree in
                            return self.diff(withOldTree: tree, andNewTree: baseTree)
                        }
                        .flatMap { diff in
                            guard let mergeDiff = mergeDiff else { return .success(diff) }
                            let merge = git_diff_merge(mergeDiff, diff)
                            guard mergeResult == gIT_OK.rawValue else {
                                // return return error
                            }
                            return .success(merge)
                        }
                }
        }
    }
    .flatMap { diffResult in
        return self.processDiffDeltas(diffResult)
    }

interesting. I've seen flatmap before but not like this. I'll put this in

Wait, is flatMap supposed to be implemented on Repository? I see it implemented in Result but I'm not sure how to use this sample code.

Oops! There was a line missing. I've updated the code sample above.

It'd be nice to test the results a bit more fully.

You don't need to specify _: here; I didn't even know you could do that. Diff.Delta(itow.pointee) is sufficient.

nice catch

This is incorrect. git_diff_free is called on git_diffs; delta is a git_diff_delta.

Good catch. According to the docs The git_diff_delta pointer points to internal data and you do not have to release it when you are done with it. It will go away when the * git_diff (or any associated git_patch) goes away.

I don't think it's safe to use unwrapBaseCommit here after freeing unsafeBaseCommit. I think this should switch to use the same callback style as the remoteLookup method.

I was working on this when I discovered the already existing withGitObject… what do you think about replacing e.g. .commit(with: parent.oid) with .withGitObject(parent.oid, type: GIT_OBJ_COMMIT) and killing the commit(with:) altogether? The tests still pass.

Yeah, that sounds good! 👍 You can tell it's been a while since I've really worked with this code. 😅

No worries. There's actually a handful of helpers I never noticed before, so I'll convert things to use those.

Same here about it being unsafe, except this is missing a git_diff_free.

Same here about it being unsafe.

Might as well do s!.pointee here instead of (s?.pointee)!.

👍

These could use map instead of for loops

let oldFilePaths = deltas.map { $0.oldFile!.path }

nice 👍

I'm unsure of this triple branch of logic. I was hoping to find a "swifty" way of identifying which tree was (or whether both trees were) supplied, without needing three if else branches but couldn't get it. I'm particularly interested if something pops out, I tried several different things and none were as satisfying to me as just doing the branch.

I think we could just do git_object_free(diff) here instead of keeping a list of diffs. That would reduce memory consumption and should also make the code a little clearer.

nice catch 👍

I think we need to free mergeDiff. Putting a defer { git_object_free(mergeDiff) } before this line should work.

👍

Maybe follow this line with defer { git_object_free(oldTree) } (and same with newTree below).

The locality of that is nice, but it should also help us free memory if we return an error.