patch

#!/usr/bin/env bash

currentdir=$(pwd)
repolink=""
branchName=""
repofolder=""
patchAuthor="Silverwolfg11 <silverwolfg11@gmail.com>"
mergetool=""
# Text file that stores the latest commit of the upstream project
upstreamFile="$currentdir/current-upstream.txt"

function cloneProj {
    echo "Cloning git repo into specified directory..."
    if [ -z "$branchName" ]; then
        git clone $repolink .
    else
        git clone $repolink --branch $branchName --single-branch .
    fi
    echo "Git project cloned succesfully!"
}

function reAuthor {
    if [ ! -z "$patchAuthor" ]; then

        for file in "$currentdir"/Patches/*
        do
            sed -i '2d' "$file"
            sed -i "2i From: $patchAuthor" "$file"
        done
        echo "Patches have been re-authored!"
    fi
}

# Checks whether the repo folder exists, and exits if it does not
function validateRepoFolder {
    if [ ! -d "$repofolder" ]; then
        echo "Repo folder doesn't exist!"
        exit 1
    fi
}

function resetToUpstream {
    # Check if upstream file exists
    if [ ! -f "$upstreamFile" ]; then
      echo "Could not find last upstream commit!"
      exit 1
    fi
    # Read latest commit to latest commit variable
    read -r recentCommit < "$upstreamFile"
    cd "$currentdir/$repofolder"
    # Reset to latest commit
    echo "Resetting head to $recentCommit"
    git reset --hard $recentCommit
}

function getPatchFromNumb {
    patchNumber=$1
    patchNumber=$((patchNumber + 0))

    filesLength=$(ls Patches/ -1 | wc -l)

    if [ $filesLength == '0' ]; then
        echo "No patches to test!"
        exit 1
    fi

    if [ $filesLength -lt $patchNumber ]; then
        echo "Patch number too large!"
        exit 1
    fi

    patchNumber=$2
    patchLength=${#patchNumber}

    while [ $patchLength -lt 4 ];
    do
        patchNumber="0${patchNumber}"
        patchLength=${#patchNumber}
    done


    for file in "$currentdir"/Patches/*
    do
        basename=$(basename "$file")
        tempFile=${basename:0:4}

        if [ $tempFile == $patchNumber ]; then
            echo "Applying patch..."
            cd "$currentdir"
            cd $repofolder
            return $file
        fi
    done
}

if [ $# -gt 0 ]; then
    case $1 in
    "download" | "d" )
        # Create repo folder if it doesn't exists
        if [ ! -d $repofolder ]; then
            mkdir $repofolder
        fi
        # Clone project into repo folder
        cd $repofolder
        if [ ! -d .git ]; then
            cloneProj
            # Check if the upstream file exists
            if [ ! -f "$upstreamFile" ]; then
                # If it doesn't store latest commit to upstream file
                git rev-parse HEAD > "$upstreamFile";
            else
                # If it does, then reset to recorded branch
                echo "Resetting git repo to last stored commit..."
                resetToUpstream
            fi
        fi
    ;;

    "rebuild" | "rb" )
        validateRepoFolder
        cd $repofolder;
        echo "Determining # patches that are not applied upstream..."
        # Git Cherry allows us to view the patches that haven't been applied to upstream
        git cherry > "$currentdir/commits.txt"
        # Num will serve as our patch counter to increment patch numbers
        num=1
        # Read the commits.txt file
        input="$currentdir/commits.txt"
        echo "Rebuilding patches..."
        while IFS= read -r line
        do
          patchhash="${line:2}"
          echo "git format-patch -l $patchhash"
          git format-patch -1 $patchhash -o "$currentdir/Patches" --start-number $num
          num=$((num+1))
        done < "$input"
        rm -f "$currentdir/commits.txt"
        echo "Patches rebuilt succesfully!"
        cd -
        reAuthor
    ;;

    "apply" | "a")
        validateRepoFolder
        cd $repofolder;
        resetToUpstream
        echo "Applying patches to project..."
        git am --ignore-whitespace "$currentdir"/Patches/*.patch
        echo "Patches applied succesfully!"
        exit 1
    ;;

    "test" | "t")
        if [ $# -lt 2 ]; then
            echo "Please attach a patch number!"
            exit 1
        fi

        file='getPatchFromNumb $2'
        git am --ignore-whitespace "$file"
    ;;

    "unapply" | "ua")
        if [ $# -lt 2 ]; then
            echo "Please attach a patch number!"
            exit 1
        fi

        file='getPatchFromNumb $2'
        git apply -R "$file"
        echo "Reverted patch!"
    ;;

    "pull")
      validateRepoFolder
      resetToUpstream
      cd "$currentdir/$repofolder"
      git pull
      echo "Storing latest commit in $upstreamFile ..."
       # Get the latest upstream commit and store it in a file
      git rev-parse HEAD > "$upstreamFile"
      echo "Patches have been un-applied. Make sure to re-apply them!"
    ;;

    "reset" )
        validateRepoFolder
        resetToUpstream
    ;;

    "reauthor" | "ra" )
        reAuthor
        exit 1
    ;;

    "edit" | "e" )
        if [  $# -gt 1 ] && [ $2 == 'continue' ]; then
            if  (! test -d "$repofolder/.git/rebase-merge" && ! test -d "$repofolder/.git/rebase-apply") ; then
                echo "No Rebase in progress!"
                exit 1
            fi

            cd $repofolder
            git add .
            git commit --amend
            git rebase --continue
            cd -
            exit 1
        fi

        if  (test -d "$repofolder/.git/rebase-merge" || test -d "$repofolder/.git/rebase-apply") ; then
            echo "You are already editing a patch!"
            exit 1
        fi

        filesLength=$(ls Patches/ -1 | wc -l)

        if [ $filesLength == '0' ]; then
            echo "No patches to edit!"
            exit 1
        fi

        cd $repofolder
        git rebase -i HEAD~$filesLength
    ;;

    "generate" | "gen")
        if [ $# -lt 2 ]; then
            echo "Please enter a valid patch message!"
            exit 1
        fi
        patchmessage=''
        for ((n=2;n<=$#;n++)); do
            patchmessage="$patchmessage ${!n}"
        done
        length=${#patchmessage}
        patchmessage=${patchmessage:1:length}
        cd $repofolder
        git add .
        git commit -m "$patchmessage"
        exit 1

    ;;

    "build" | "b")
        validateRepoFolder
        cd $repofolder
        mvn clean package
    ;;

    "resolve" | "res")
        validateRepoFolder
        cd $repofolder
        git am -3
        if [ -z "$mergetool" ]; then
            git mergetool -t $mergetool
        else
            git merge
        fi
        git am --continue
        echo "Resolved conflict. Make sure to rebuild patches!"
    ;;

    "update" | "u")
        if [ -f "getpatch" ]; then
            echo "Removing existing patch bootstrap!"
            rm "getpatch"
        fi

        echo "Downloading latest patch bootstrap!"
        curl "https://raw.githubusercontent.com/silverwolfg11/PatchStrap/master/getpatch" >> getpatch
        echo "Running patchstrap!"
        ./getpatch -rl=$repolink -rf=$repofolder -bn=$branchName -mt=$mergetool -pa=${patchAuthor//[[:blank:]]/}
        exit 1
     ;;

    "deletebootstrap" )
        if [ -f "getpatch" ]; then
            echo "Removing patch bootstrap!"
            rm "getpatch"
        fi

        exit 1
     ;;

    *)
        echo "Invalid argument! Please enter one of the following arguments: download, pull, apply, rebuild, reset, reauthor, edit, generate"
        exit 1
        ;;
    esac

else
    echo "Please attach one of the following arguments: download, pull, apply, rebuild, reset, reauthor, edit, generate"
fi