This iteration is currently too slow, need to build a refcounter on hunks / lines and implement convenient line.

Having difficulties tracking down where exactly the content pointer exists in libgit2 (the pointer that lines keep to the diff text). Instead, since this is a convenience wrapper, I am going to remove that pointer to the diff text in favor of the actual content of the line. This will make tidying up after the convenience wrapper a lot easier.

This looks great! Could we get a summary of the API changes involved in this?

Minor changes to API:

• ConvenientPatch does not have a patch or a delta property associated with it, if you were using the delta, please just use prototype methods oldFIle, newFile, and Status, which are stripped directly from the delta.
• ConvenientPatch.prototype.hunks returns a promise with an array of ConvenientHunks.
• ConvenientPatch
• ConvenientHunk does not have an exposed diffHunk associated with it, but does have the same members as diffHunk:
  • size() : number of lines in the hunk
  • oldStart() : old starting position
  • oldLines() : number of lines in old file
  • newStart() : new starting position
  • newLines() : number of lines in new file
  • headerLen() : length of header
  • header() : returns the header of the hunk
  • lines() : returns a promise containing DiffLines, not ConvenientLines.
• DiffLine now contains the members rawContent() and content().
  • rawContent() contains the unformatted content of the line. This is no longer a string from the line to the end of the file.
  • content() contains the utf8 formatted content of the line.

⭐

@tbranyen thoughts before I merge this in?

@implausible how's the performance looking now? Just did a brief scan of the code and the change looks fine to me, but I think the move to C++ might make the convenient api's a bit harder to maintain.

It will make it a bit harder to follow for sure. The performance is comparable to before. Unsure if faster or slower because it's pretty close. One thing that is nice is that this completely removes the locking issues we had with the git_patch_from_diff issue.

@implausible there was no perf increase?

@johnhaley81: Unsure if there is a perf 'increase', but there is a certain stability increase. There is definitely a positive perf gain over alternative systems to fix this issue. I can run some tests vs the old system. What i know for sure is there is 0 perf decrease. I think this will be as fast as the system can transfer data between git_patch and git_hunks and git_lines. It still runs asynchronously while the system does transfer of data.

👍

I'm @johnhaley81. You just pinged some random guy. Sorry @johnh.

Could we get a delta before we merge? I'd like to include that in the changelog.

slack habits lol

If none of the interfaces have changed, we could probably just mention that they are more stable now and moved to C++

👍 I'm good with this. @tbranyen I'm going to do a release to 0.10.0 after this is merged.

Wow. I am wrong. There is a HUGE perf improvement. @tbranyen @johnhaley81 @srajko

Result before move to C++ convenience wrapper:
Time to generate patches: 254
number of patches: 927
Time to generate hunks: 34
Number of hunks: 890
Time to generate lines: 3465
Number of lines: 105705

Result after move:
Time to generate patches: 417
number of patches: 927
Time to generate hunks: 33
Number of hunks: 890
Time to generate lines: 127
Number of lines: 105705

🌟 💯 🌟

Time to calc patches is up but that's because we're copying a lot of stuff into memory from the old patch structure. Overall an order of magnitude perf increase. Nice job!