.github/workflows/test.yml

@@ -36,28 +36,7 @@ jobs:
           concurrent_skipping: 'never'
           skip_after_successful_duplicate: 'true'
           paths_ignore: '["**/README.md", "**/docs/**"]'
-
-      - name: Print outputs
-        run: |
-          echo '::group::should_skip'
-          echo '${{ steps.skip_check.outputs.should_skip }}'
-          echo '::endgroup::'
-
-          echo '::group::reason'
-          echo '${{ steps.skip_check.outputs.reason }}'
-          echo '::endgroup::'
-
-          echo '::group::skipped_by'
-          echo '${{ toJSON(fromJSON(steps.skip_check.outputs.skipped_by)) }}'
-          echo '::endgroup::'
-
-          echo '::group::paths_result'
-          echo '${{ toJSON(fromJSON(steps.skip_check.outputs.paths_result)) }}'
-          echo '::endgroup::'
-
-          echo '::group::changed_files'
-          echo '${{ toJSON(fromJSON(steps.skip_check.outputs.changed_files)) }}'
-          echo '::endgroup::'
+          skip_summary: 'true'
 
   main_job:
     needs: pre_job

LICENSE

@@ -1,3 +1,8 @@
+We take a clear stand against imperialistic regimes that are trying to re-build a "Reich".
+We seek to defend the rule of law against the rule of tyranny.
+We seek to defend democracy against fascism.
+Russian users are encouraged to act against the lies that have been used to justify the war.
+
 MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

README.md

@@ -103,12 +103,12 @@ A YAML-string with named [`paths_ignore`](#paths_ignore) / [`paths`](#paths) pat
 ```yaml
 frontend:
   paths_ignore:
-    - 'frontend/docs/**/*'
+    - 'frontend/docs/**'
   paths:
-    - 'frontend/**/*'
+    - 'frontend/**'
 backend:
   paths:
-    - 'backend/**/*'
+    - 'backend/**'
   ### Here you can optionally control/limit backtracking
   # Boolean or number (default: true)
   # 'false' means disable backtracking completely
@@ -135,9 +135,9 @@ If true, skip if an already finished duplicate run can be found.
 
 A JSON-array with triggers that should never be skipped.
 
-Possible values are `pull_request`, `push`, `workflow_dispatch`, `schedule`.
+Possible values are `pull_request`, `push`, `workflow_dispatch`, `schedule`, `release`, `merge_group`.
 
-**Default:** `'["workflow_dispatch", "schedule"]'`
+**Default:** `'["workflow_dispatch", "schedule", "merge_group"]'`
 
 ### `concurrent_skipping`
 
@@ -235,6 +235,7 @@ To minimize changes to existing jobs, it is often easier to skip entire jobs.
 >
 > - You may need to use [`fromJSON`](https://docs.github.com/en/actions/learn-github-actions/expressions#fromjson) to access properties of object outputs. For example, for `skipped_by.id`, you can use the expression: `${{ fromJSON(steps.skip_check.outputs.skipped_by).id }}`.
 > - For GitHub repositories where [default permissions](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#setting-the-permissions-of-the-github_token-for-your-repository) for `GITHUB_TOKEN` has been set to "permissive (read-only)", the following lines must be included in the workflow (see [permissions syntax](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions)):
+>
 >   ```yaml
 >   # Minimum permissions required by skip-duplicate-actions
 >   permissions:
@@ -257,7 +258,7 @@ jobs:
       should_skip: ${{ steps.skip_check.outputs.should_skip }}
     steps:
       - id: skip_check
-        uses: fkirc/skip-duplicate-actions@v4
+        uses: fkirc/skip-duplicate-actions@v5
         with:
           # All of these options are optional, so you can remove them if you are happy with the defaults
           concurrent_skipping: 'never'
@@ -267,7 +268,7 @@ jobs:
 
   main_job:
     needs: pre_job
-    if: ${{ needs.pre_job.outputs.should_skip != 'true' }}
+    if: needs.pre_job.outputs.should_skip != 'true'
     runs-on: ubuntu-latest
     steps:
       - run: echo "Running slow tests..." && sleep 30
@@ -284,18 +285,22 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - id: skip_check
-        uses: fkirc/skip-duplicate-actions@v4
+        uses: fkirc/skip-duplicate-actions@v5
         with:
           cancel_others: 'false'
           paths: '["src/**", "dist/**"]'
-      - if: ${{ steps.skip_check.outputs.should_skip != 'true' }}
+      - if: steps.skip_check.outputs.should_skip != 'true'
         run: |
           echo "Run only if src/ or dist/ changed..." && sleep 30
           echo "Do other stuff..."
 ```
 
 ### Example 3: Skip using `paths_filter`
 
+> [!WARNING]  
+> If the paths_filter option is not working correctly, then you could copy the “example 1" multiple times according to your needs (see <https://github.com/fkirc/skip-duplicate-actions/issues/326> for details).
+
+
 The `paths_filter` option can be used if you have multiple jobs in a workflow and want to skip them based on different [`paths_ignore`](#paths_ignore) / [`paths`](#paths) patterns. When defining such filters, the action returns corresponding information in the [`paths_result`](#paths_result) output.
 For example in a monorepo, you might want to run jobs related to the "frontend" only if some files in the corresponding "frontend/" folder have changed and the same for "backend". This can be achieved with the following configuration:
 
@@ -308,17 +313,17 @@ jobs:
       paths_result: ${{ steps.skip_check.outputs.paths_result }}
     steps:
       - id: skip_check
-        uses: fkirc/skip-duplicate-actions@v4
+        uses: fkirc/skip-duplicate-actions@v5
         with:
           paths_filter: |
             frontend:
               paths_ignore:
-                - 'frontend/docs/**/*'
+                - 'frontend/docs/**'
               paths:
-                - 'frontend/**/*'
+                - 'frontend/**'
             backend:
               paths:
-                - 'backend/**/*'
+                - 'backend/**'
           # Can be mixed with the "global" 'paths_ignore' / 'paths' options, for example:
           # paths_ignore: '["**/README.md"]'
 
@@ -327,11 +332,11 @@ jobs:
     # If 'skip-duplicate-actions' terminates before the paths checks are performed (for example, when a successful duplicate run has
     # been found) 'paths_result' outputs an empty object ('{}'). This can be easily intercepted in the if condition of a job
     # by checking the result of the "global" 'should_skip' output first.
-    if: needs.pre_job.outputs.should_skip != 'true' || !fromJSON(needs.pre_job.outputs.paths_result).frontend.should_skip
-    ...
+    if: needs.pre_job.outputs.should_skip != 'true' && !fromJSON(needs.pre_job.outputs.paths_result).frontend.should_skip
+    # ...
 
   backend:
-    ...
+    # ...
 ```
 
 ## How does it work?
@@ -346,25 +351,93 @@ After querying such workflow runs, it will compare them with the current workflo
 ## How does path-skipping work?
 
 As mentioned above, `skip-duplicate-actions` provides a path-skipping functionality that is somewhat similar to GitHub's native `paths` and `paths_ignore` functionality.
-However, path-skipping is not entirely trivial because there exist multiple options on how to do path-skipping.
-Depending on your project, you might want to choose one of the following options:
+However, path-skipping is not entirely trivial because there exist multiple options on how to do path-skipping:
 
 ### Option 1: Only look at the "current" commit
 
-This is the thing that GitHub is currently doing, and I consider it as insufficient because it doesn't work for "required" checks.
-Another problem is that the outcomes can be heavily dependent on which commits were pushed at which time, instead of the actual content that was pushed.
+This is the thing that GitHub is currently doing, and we consider it as insufficient because it does not work for "required" checks.
+Another problem is that the outcomes can be heavily dependent on the pushing-sequence of commits.
 
 ### Option 2: Look at Pull-Request-diffs
 
-This option is probably implemented by https://github.com/dorny/paths-filter.
-PR-diffs are simple to understand, but not everyone is using PRs for everything, so this is not an option for everyone.
+PR-diffs are simple to understand, but they only work after opening a PR, not immediately after pushing a feature-branch.
 
 ### Option 3: Look for successful checks of previous commits
 
-This is my personal favorite option and this is implemented by `skip-duplicate-actions`.
-An advantage is that this works regardless of whether you are using PRs or feature-branches, and of course it also works for "required" checks.
+This option is implemented by `skip-duplicate-actions`.
+An advantage is that this works regardless of whether you are using PRs or raw feature-branches, and of course it also works for "required" checks.
 Internally, `skip-duplicate-actions` uses the [Repos Commit API](https://docs.github.com/en/rest/reference/repos#get-a-commit) to perform an efficient backtracking-algorithm for paths-skipping-detection.
 
+This is how the algorithm works approximately:
+
+```mermaid
+stateDiagram-v2
+    Check_Commit: Check Commit
+    [*] --> Check_Commit: Current commit
+
+    state Path_Ignored <<choice>>
+    Check_Commit --> Path_Ignored: Do all changed files match against "paths_ignore"?
+    Ignored_Yes: Yes
+    Ignored_No: No
+    Path_Ignored --> Ignored_Yes
+    Path_Ignored --> Ignored_No
+
+    state Path_Skipped <<choice>>
+    Ignored_No --> Path_Skipped: Do none of the changed files match against "paths"?
+    Skipped_Yes: Yes
+    Skipped_No: No
+    Path_Skipped --> Skipped_Yes: No matches
+    Path_Skipped --> Skipped_No: Some matches
+
+    Parent_Commit: Fetch Parent Commit
+    Ignored_Yes --> Parent_Commit
+    Skipped_Yes --> Parent_Commit
+
+    state Successful_Run <<choice>>
+    Parent_Commit --> Successful_Run: Is there a successful run for this commit?
+    Run_Yes: Yes
+    Run_No: No
+    Successful_Run --> Run_Yes
+    Successful_Run --> Run_No
+
+    Run_No --> Check_Commit: Parent commit
+
+    Skip: Skip!
+    Run_Yes --> Skip: (Because all changes since this run are in ignored or skipped paths)
+
+    Dont_Skip: Don't Skip!
+    Skipped_No --> Dont_Skip: (Because changed files needs to be "tested")
+```
+
+## Frequently Asked Questions
+
+### How to Use Skip Check With Required Matrix Jobs?
+
+Discussed in <https://github.com/fkirc/skip-duplicate-actions/issues/44>.
+
+If you have matrix jobs that are registered as required status checks and the matrix runs conditionally based on the skip check, you might run into the problem that the pull request remains in a unmergable state forever because the jobs are not executed at all and thus not reported as skipped (`Expected - Waiting for status to be reported`).
+
+There are several approaches to circumvent this problem:
+
+- Define the condition (`if`) in each step in the matrix job instead of a single condition on the job level: <https://github.com/fkirc/skip-duplicate-actions/issues/44>
+- If you want the check to be considered successful only if all jobs in the matrix were successful, you can add a subsequent job whose only task is to report the final status of the matrix. Then you can register this final job as a required status check:
+
+  ```yaml
+  result:
+    name: Result
+    if: needs.pre_job.outputs.should_skip != 'true' && always()
+    runs-on: ubuntu-latest
+    needs:
+      - pre_job
+      - example-matrix-job
+    steps:
+      - name: Mark result as failed
+        if: needs.example-matrix-job.result != 'success'
+        run: exit 1
+  ```
+
+- Define an opposite workflow, as offically suggested by GitHub: [Handling skipped but required checks](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/defining-the-mergeability-of-pull-requests/troubleshooting-required-status-checks#handling-skipped-but-required-checks)
+
 ## Maintainers
 
 - [@paescuj](https://github.com/paescuj)

action.yml

@@ -31,11 +31,15 @@ inputs:
   do_not_skip:
     description: 'A JSON-array with triggers that should never be skipped'
     required: false
-    default: '["workflow_dispatch", "schedule"]'
+    default: '["workflow_dispatch", "schedule", "merge_group"]'
   concurrent_skipping:
     description: 'One of never, same_content, same_content_newer, outdated_runs, always'
     required: true
     default: 'never'
+  skip_summary:
+    description: 'If true, make the workflow logs shorter'
+    required: false
+    default: 'false'
 outputs:
   should_skip:
     description: 'Returns true if the current run should be skipped according to your configured rules'
@@ -48,5 +52,5 @@ outputs:
   paths_result:
     description: 'Returns information for each configured filter in paths_filter'
 runs:
-  using: 'node16'
+  using: 'node20'
   main: 'dist/index.js'