commit b0cfc9769a0845c7506351fa7147a82495cfc95f · pyrox.dev/nixpkgs

.git-blame-ignore-revs

···

       1
        
       # This file contains a list of commits that are not likely what you

     

       2
        
       # are looking for in a blame, such as mass reformatting or renaming.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3
        
       # You can set this file as a default ignore file for blame by running

     

       4
        
       # the following command.

     

       5
        
       #

···

       1
        
       # This file contains a list of commits that are not likely what you

     

       2
        
       # are looking for in a blame, such as mass reformatting or renaming.

     

       3
       +
       #

     

       4
       +
       # If a commit's line ends with `# !autorebase <command>`,

     

       5
       +
       # where <command> is an idempotent bash command that reapplies the changes from the commit,

     

       6
       +
       # the `maintainers/scripts/auto-rebase/run.sh` script can be used to rebase

     

       7
       +
       # across that commit while automatically resolving merge conflicts caused by the commit.

     

       8
       +
       #

     

       9
        
       # You can set this file as a default ignore file for blame by running

     

       10
        
       # the following command.

     

       11
        
       #

+16

maintainers/scripts/auto-rebase/README.md

···

       1
       +
       # Auto rebase script

     

       2
       +
       

     

       3
       +
       The [`./run.sh` script](./run.sh) in this directory rebases the current branch onto a target branch,

     

       4
       +
       while automatically resolving merge conflicts caused by marked commits in [`.git-blame-ignore-revs`](../../../.git-blame-ignore-revs).

     

       5
       +
       See the header comment of that file to understand how to mark commits.

     

       6
       +
       

     

       7
       +
       This is convenient for resolving merge conflicts for pull requests after e.g. treewide reformats.

     

       8
       +
       

     

       9
       +
       ## Testing

     

       10
       +
       

     

       11
       +
       To run the tests in the [test directory](./test):

     

       12
       +
       ```

     

       13
       +
       $ cd test

     

       14
       +
       $ nix-shell

     

       15
       +
       nix-shell> ./run.sh

     

       16
       +
       ```

+61

maintainers/scripts/auto-rebase/run.sh

···

       1
       +
       #!/usr/bin/env bash

     

       2
       +
       set -euo pipefail

     

       3
       +
       

     

       4
       +
       if (( $# < 1 )); then

     

       5
       +
           echo "Usage: $0 TARGET_BRANCH"

     

       6
       +
           echo ""

     

       7
       +
           echo "TARGET_BRANCH: Branch to rebase the current branch onto, e.g. master or release-24.11"

     

       8
       +
           exit 1

     

       9
       +
       fi

     

       10
       +
       

     

       11
       +
       targetBranch=$1

     

       12
       +
       

     

       13
       +
       # Loop through all autorebase-able commits in .git-blame-ignore-revs on the base branch

     

       14
       +
       readarray -t autoLines < <(

     

       15
       +
         git show "$targetBranch":.git-blame-ignore-revs \

     

       16
       +
             | sed -n 's/^\([0-9a-f]\+\).*!autorebase \(.*\)$/\1 \2/p'

     

       17
       +
       )

     

       18
       +
       for line in "${autoLines[@]}"; do

     

       19
       +
           read -r autoCommit autoCmd <<< "$line"

     

       20
       +
       

     

       21
       +
           if ! git cat-file -e "$autoCommit"; then

     

       22
       +
               echo "Not a valid commit: $autoCommit"

     

       23
       +
               exit 1

     

       24
       +
           elif git merge-base --is-ancestor "$autoCommit" HEAD; then

     

       25
       +
               # Skip commits that we have already

     

       26
       +
               continue

     

       27
       +
           fi

     

       28
       +
       

     

       29
       +
           echo -e "\e[32mAuto-rebasing commit $autoCommit with command '$autoCmd'\e[0m"

     

       30
       +
       

     

       31
       +
           # The commit before the commit

     

       32
       +
           parent=$(git rev-parse "$autoCommit"~)

     

       33
       +
       

     

       34
       +
           echo "Rebasing on top of the previous commit, might need to manually resolve conflicts"

     

       35
       +
           if ! git rebase --onto "$parent" "$(git merge-base "$targetBranch" HEAD)"; then

     

       36
       +
             echo -e "\e[33m\e[1mRestart this script after resolving the merge conflict as described above\e[0m"

     

       37
       +
             exit 1

     

       38
       +
           fi

     

       39
       +
       

     

       40
       +
           echo "Reapplying the commit on each commit of our branch"

     

       41
       +
           # This does two things:

     

       42
       +
           # - The parent filter inserts the auto commit between its parent and

     

       43
       +
           #   and our first commit. By itself, this causes our first commit to

     

       44
       +
           #   effectively "undo" the auto commit, since the tree of our first

     

       45
       +
           #   commit is unchanged. This is why the following is also necessary:

     

       46
       +
           # - The tree filter runs the command on each of our own commits,

     

       47
       +
           #   effectively reapplying it.

     

       48
       +
           FILTER_BRANCH_SQUELCH_WARNING=1 git filter-branch \

     

       49
       +
               --parent-filter "sed 's/$parent/$autoCommit/'" \

     

       50
       +
               --tree-filter "$autoCmd" \

     

       51
       +
               "$autoCommit"..HEAD

     

       52
       +
       

     

       53
       +
           # A tempting alternative is something along the lines of

     

       54
       +
           #   git rebase --strategy-option=theirs --onto "$rev" "$parent" \

     

       55
       +
           #     --exec '$autoCmd && git commit --all --amend --no-edit' \

     

       56
       +
           # but this causes problems because merges are not guaranteed to maintain the formatting.

     

       57
       +
           # The ./test.sh exercises such a case.

     

       58
       +
       done

     

       59
       +
       

     

       60
       +
       echo "Rebasing on top of the latest target branch commit"

     

       61
       +
       git rebase --onto "$targetBranch" "$(git merge-base "$targetBranch" HEAD)"

+46

maintainers/scripts/auto-rebase/test/default.nix

···

       1
       +
       let

     

       2
       +
         pkgs = import ../../../.. {

     

       3
       +
           config = { };

     

       4
       +
           overlays = [ ];

     

       5
       +
         };

     

       6
       +
       

     

       7
       +
         inherit (pkgs)

     

       8
       +
           lib

     

       9
       +
           stdenvNoCC

     

       10
       +
           gitMinimal

     

       11
       +
           treefmt

     

       12
       +
           nixfmt-rfc-style

     

       13
       +
           ;

     

       14
       +
       in

     

       15
       +
       

     

       16
       +
       stdenvNoCC.mkDerivation {

     

       17
       +
         name = "test";

     

       18
       +
         src = lib.fileset.toSource {

     

       19
       +
           root = ./..;

     

       20
       +
           fileset = lib.fileset.unions [

     

       21
       +
             ../run.sh

     

       22
       +
             ./run.sh

     

       23
       +
             ./first.diff

     

       24
       +
             ./second.diff

     

       25
       +
           ];

     

       26
       +
         };

     

       27
       +
         nativeBuildInputs = [

     

       28
       +
           gitMinimal

     

       29
       +
           treefmt

     

       30
       +
           nixfmt-rfc-style

     

       31
       +
         ];

     

       32
       +
         patchPhase = ''

     

       33
       +
           patchShebangs .

     

       34
       +
         '';

     

       35
       +
       

     

       36
       +
         buildPhase = ''

     

       37
       +
           export HOME=$(mktemp -d)

     

       38
       +
           export PAGER=true

     

       39
       +
           git config --global user.email "Your Name"

     

       40
       +
           git config --global user.name "your.name@example.com"

     

       41
       +
           ./test/run.sh

     

       42
       +
         '';

     

       43
       +
         installPhase = ''

     

       44
       +
           touch $out

     

       45
       +
         '';

     

       46
       +
       }

+11

maintainers/scripts/auto-rebase/test/first.diff

···

       1
       +
       diff --git a/b.nix b/b.nix

     

       2
       +
       index 9d18f25..67b0466 100644

     

       3
       +
       --- a/b.nix

     

       4
       +
       +++ b/b.nix

     

       5
       +
       @@ -1,5 +1,5 @@

     

       6
       +
        {

     

       7
       +
          this = "is";

     

       8
       +
        

     

       9
       +
       -  some = "set";

     

       10
       +
       +  some = "value";

     

       11
       +
        }

+112

maintainers/scripts/auto-rebase/test/run.sh

···

       1
       +
       #!/usr/bin/env bash

     

       2
       +
       

     

       3
       +
       set -euo pipefail

     

       4
       +
       

     

       5
       +
       # https://stackoverflow.com/a/246128/6605742

     

       6
       +
       SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )

     

       7
       +
       

     

       8
       +
       # Allows using a local directory for temporary files,

     

       9
       +
       # which can then be inspected after the run

     

       10
       +
       if (( $# > 0 )); then

     

       11
       +
           tmp=$(realpath "$1/tmp")

     

       12
       +
           if [[ -e "$tmp" ]]; then

     

       13
       +
               rm -rf "$tmp"

     

       14
       +
           fi

     

       15
       +
           mkdir -p "$tmp"

     

       16
       +
       else

     

       17
       +
           tmp=$(mktemp -d)

     

       18
       +
           trap 'rm -rf "$tmp"' exit

     

       19
       +
       fi

     

       20
       +
       

     

       21
       +
       # Tests a scenario where two poorly formatted files were modified on both the

     

       22
       +
       # main branch and the feature branch, while the main branch also did a treewide

     

       23
       +
       # format.

     

       24
       +
       

     

       25
       +
       git init "$tmp/repo"

     

       26
       +
       cd "$tmp/repo" || exit

     

       27
       +
       git branch -m main

     

       28
       +
       

     

       29
       +
       # Some initial poorly-formatted files

     

       30
       +
       cat > a.nix <<EOF

     

       31
       +
       { x

     

       32
       +
       , y

     

       33
       +
       

     

       34
       +
       , z

     

       35
       +
       }:

     

       36
       +
       null

     

       37
       +
       EOF

     

       38
       +
       

     

       39
       +
       cat > b.nix <<EOF

     

       40
       +
       {

     

       41
       +
         this = "is";

     

       42
       +
       

     

       43
       +
       

     

       44
       +
         some="set" ;

     

       45
       +
        }

     

       46
       +
       EOF

     

       47
       +
       

     

       48
       +
       git add -A

     

       49
       +
       git commit -m "init"

     

       50
       +
       

     

       51
       +
       git switch -c feature

     

       52
       +
       

     

       53
       +
       # Some changes

     

       54
       +
       sed 's/set/value/' -i b.nix

     

       55
       +
       git commit -a -m "change b"

     

       56
       +
       sed '/, y/d' -i a.nix

     

       57
       +
       git commit -a -m "change a"

     

       58
       +
       

     

       59
       +
       git switch main

     

       60
       +
       

     

       61
       +
       # A change to cause a merge conflict

     

       62
       +
       sed 's/y/why/' -i a.nix

     

       63
       +
       git commit -a -m "change a"

     

       64
       +
       

     

       65
       +
       cat > treefmt.toml <<EOF

     

       66
       +
       [formatter.nix]

     

       67
       +
       command = "nixfmt"

     

       68
       +
       includes = [ "*.nix" ]

     

       69
       +
       EOF

     

       70
       +
       git add -A

     

       71
       +
       git commit -a -m "introduce treefmt"

     

       72
       +
       

     

       73
       +
       # Treewide reformat

     

       74
       +
       treefmt

     

       75
       +
       git commit -a -m "format"

     

       76
       +
       

     

       77
       +
       echo "$(git rev-parse HEAD) # !autorebase treefmt" > .git-blame-ignore-revs

     

       78
       +
       git add -A

     

       79
       +
       git commit -a -m "update ignored revs"

     

       80
       +
       

     

       81
       +
       git switch feature

     

       82
       +
       

     

       83
       +
       # Setup complete

     

       84
       +
       

     

       85
       +
       git log --graph --oneline feature main

     

       86
       +
       

     

       87
       +
       # This expectedly fails with a merge conflict that has to be manually resolved

     

       88
       +
       "$SCRIPT_DIR"/../run.sh main && exit 1

     

       89
       +
       sed '/<<</,/>>>/d' -i a.nix

     

       90
       +
       git add a.nix

     

       91
       +
       GIT_EDITOR=true git rebase --continue

     

       92
       +
       

     

       93
       +
       "$SCRIPT_DIR"/../run.sh main

     

       94
       +
       

     

       95
       +
       git log --graph --oneline feature main

     

       96
       +
       

     

       97
       +
       checkDiff() {

     

       98
       +
           local ref=$1

     

       99
       +
           local file=$2

     

       100
       +
           expectedDiff=$(cat "$file")

     

       101
       +
           actualDiff=$(git diff "$ref"~ "$ref")

     

       102
       +
           if [[ "$expectedDiff" != "$actualDiff" ]]; then

     

       103
       +
               echo -e "Expected this diff:\n$expectedDiff"

     

       104
       +
               echo -e "But got this diff:\n$actualDiff"

     

       105
       +
               exit 1

     

       106
       +
           fi

     

       107
       +
       }

     

       108
       +
       

     

       109
       +
       checkDiff HEAD~ "$SCRIPT_DIR"/first.diff

     

       110
       +
       checkDiff HEAD "$SCRIPT_DIR"/second.diff

     

       111
       +
       

     

       112
       +
       echo "Success!"

+11

maintainers/scripts/auto-rebase/test/second.diff

···

       1
       +
       diff --git a/a.nix b/a.nix

     

       2
       +
       index 18ba7ce..bcf38bc 100644

     

       3
       +
       --- a/a.nix

     

       4
       +
       +++ b/a.nix

     

       5
       +
       @@ -1,6 +1,5 @@

     

       6
       +
        {

     

       7
       +
          x,

     

       8
       +
       -  why,

     

       9
       +
        

     

       10
       +
          z,

     

       11
       +
        }: