How to ignore files changed by another branch merged as the part of updating to latest main

[ewypych]

Hello! I need to track the changes being made to the specific list of files inside the repository, let's name them:

FileA
FileB
FileC

The workflow should run when they are changed (in theory it could run always, but when there are no changed files it's better to not run it), and then do something with them. Here's the fragment of the workflow (a bit anonymised):

on:
  pull_request:
    branches:
      - main
    paths:
      - '**/FileA'
      - '**/FileB'
      - '**/FileC'
jobs:
  my-job:
    name: My job
    runs-on: ubuntu
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 2
          ref: ${{ github.event.pull_request.head.sha }}
      - name: Get changed files
        id: get-changed-files
        uses: tj-actions/[email protected]
        with:
          json: true
          write_output_files: true
          since_last_remote_commit: true
          files: |
            **/FileA
            **/FileB
            **/FileC
      - name: Print all changed and modified files from JSON
        run: cat .github/outputs/all_changed_and_modified_files.json
<THE REST OF THE WORKFLOW>

It works perfectly as long as somebody didn't change one of these files as a part of the another branch work, then merge those changes to main, and the branch will be updated with the newest main to keep it up to date. Here's the problematic scenario step by step:

1. The branch feature/1 is created.
2. The changes has been made to FileA.
3. Pull Request feature/1 -> main is created, workflows detects the change in FileA (NO MERGING!).
4. The new branch feature/2 is created off main.
5. The file FileB is changed in `feature/2.
6. Pull Request feature/2 -> main is created, workflows detects the change in FileB.
7. PR feature/2 -> main is merged.
8. The feature branch feature/1 is updated to latest main.
9. Some changes are made to feature/1 and pushed along with the merging commit to already opened PR.
10. The workflow in PR feature/1 -> main detect change in FileB coming from the completely different change.

I'd like to avoid detecting files NOT modified directly by changes made to the branch by Developer. I noticed that no matter what combination of checkout action I use (fetch-deep set to 0, 1, 2, ref like in the code above, or empty) the changed-files action tries to compare the latest commit with the commit BEFORE the merging main into the branch, like here:

some commit messages          d9e6784
Merge main into feature       4e90dc32
another commit                67ac78a

In that case the changed files action will compare:

Retrieving changes between d9e6784 (feature/1) → 67ac78a (feature1)

and takes all files changed as a part of 4e90dc32. Of course it's the merging commit, made by git merge main or GitHub UI/IDE equivalent.

Right now it works also perfectly fine with more than 2 commits, as long as they're a part of normal work with branch.

How to avoid that? What am doing wrong? Unfortunately I can't provide links to full runs, but if you need some more information or should I do some tests, please let me know.

[jackton1]

Hi @ewypych , to prevent this you can change your merge strategy to rebase feature/1 with the latest changes in main or set since_last_remote_commit: false

[ewypych]

Thanks @jackton1 for your answer! And apologise for such a delay in sending my message.

Unfortunately the strategy change is not an option, as Developers merge the base branch to their feature branches locally, with their own git settings so for sure there will be a situation where somebody just forgets to change the default strategy or something like this, so I need to deal with the merge-commit as the default one (and to be quite honest I need to deal with all possible strategies 😅 ).

Although I tested since_last_remote_commit: false and it seems to be the solution. Just to make sure that I fully understand how does it work and what are the consequences:

1. It's gonna gather all changed files from entire Pull Request (including the old ones, already commited and detected by the workflow ran for some old commit), but will ignore anything pushed as the branch update?
2. Will it work the same way regardless the merging strategy used by Developer to update their feature branch with the latest base branch?

Example for the first point:

1. One of the files (X.js)that needs to be detected is pushed to feature/1 branch PR is created.
2. The workflows starts and detects that X.js has been changed.
3. The base branch is merged (in literally any startegy), in the base branch somebody changed Y.js file, detected in another PR.
4. In the featute/1 branch another file Z.js is changed, and it should be detected.
5. The changes are pushed to the remote repository.
6. The workflows starts and detects X.js AND Z.js as changed (it omits the Y.js), so both files are visible.
7. Now if the author of the feature/1 pushes changes made to more files marked to be detected, the workflow will show three changed files.