Commited | first repo to have over 3,000,000 commits | REST library

The main issue here is that you have a belongs_to :product association in your GroceryList model.

Both are factually correct. The summary copied from the confluent blog is being misunderstood.

Please note that the text you copied is under the section Reading Transactional Messages. The text is trying to explain that when the data is being read by transactional or read_committed consumers:

• messages from aborted transactions are filtered out
• messages from open transactions are withheld (they will eventually be given to application if transaction is committed or will be filtered out if transaction is aborted)

On the files comparison of a PR, it does not only compare the file changes between the source branch and target branch. It will compare the commit history between them.

It is a correct behavior if you use the squash merge multiple times to merge changes from a branch to another one. Because instead of each commit on the topic branch being added to the history of the default branch, a squash merge takes all the file changes and adds them to a single new commit on the default branch.

This means that when you use squash merge to merge a PR, only the file changes on the source branch (feature in your case) will be merged and generate a new commit on the target branch (develop in your case). The commit history for these file changes on the source branch will not be merged to the target branch.

Generally, when completing the squash merge, you should delete the source branch. And in the next time if you still want to use the squash merge, you can create a new source branch (you can still use the same branch name feature) based on the target branch. Then make changes on the new source branch, merge changes to the target branch using squash merge, delete the source branch.

If you do not delete the source branch when using the squash merge, and in the next time you continue making and merging changes from this source branch to the target branch, you may get some conflicts and extra changes just like the problem you are facing.

At this time, if there are conflicts, resolve the conflicts then you can complete the merge as usual. If no conflicts, you can directly complete the merge as usual. When completing the merge, do not forget to delete the source branch.

To view more details, you can see "Squash merge pull requests".

PR should be updated automatically. If that doesn't happen try changing the target branch to something else and changing it back to main.

I've solved this by making a wrapper function that ends with a commit, and calling the wrapper function instead of the standard function.

You can inject TransactionManager

The closest thing you have for this is menu command named "Restore after commit". This command will save the file as it was when you issued the command. Then you can change the file and remove the previously added line (so you manually revert any changes that you don't want committed in the next commit). Then you commit. After the commit Tortoise will overwrite the file with what it had saved, and in effect restore the line.

After some digging, I found the root of the problem, and it lies inside Apple's code. At a minimum, I'd call that an "undocumented feature", some might say it's a bug.

When a snapshot is applied, the behavior of the UICollectionViewDiffableDataSource differs, whether the ItemIdentifierType is a value-type or a reference-type.

Of course, your ItemIdentifierType must conform to Hashable, but when calling apply(snapshot, animatingDifferences: true):

• If ItemIdentifierType is a value-type (struct), then, its ==and hash functions are called, in order to compare the items of the newly received snapshot to the items of the currently shown snapshot, which allows to find the diff, animate differenes, and keep the selection if any (which was the original problem I asked help for).
• If ItemIdentifierType is a reference-type (class), then, its ==and hash function are not called, which means that the items of the new snapshot and the currently shown snapshot are compare with bare reference equality (are pointers equal). As a consequence, if you have built your items "from scratch" with new instances having the same hash, then the comparison is always false, and you don't get the animations, and you loose the selection.

One easy work-around in this situation is to encapsulate your reference-type into a struct, which will forward == and hash to the class ones, and use this struct as the ItemIdentifierType

To summarize:

• A git rebase starts with resetting the current branch is to , or if the --onto option was supplied. This has the exact same effect as git reset --hard (or ).
  ORIG_HEAD is set to point at the tip of the branch before the reset.
• any private file would therefore be gone, which is why git config --global rebase.autostash true should always be set.
• any file added to the index (but not committed), might still be present in Git internal database.
• Linux Mint might have saved something in TimeShift
• If not, don't forget to check the JetBrain Android Studio local history.: you might be able to restore deleted files (this is for PyCharm, but might also apply to android Studio).