how to automate the "commit-and-push" process? (git)

Question

I have a git repo. And after each major change, that I make in the codebase, what I do is that I go to the terminal and execute a set of commands.

git add .
git commit -m 'some message'
git push origin master

These are the same each day and the process is quite boring. Can anyone suggest a way to somehow automate this process?

I am running a Linux Mint 14 OS.

Answer 1

You can very easily automate this using Bash scripting.

git add .

echo 'Enter the commit message:'
read commitMessage

git commit -m "$commitMessage"

echo 'Enter the name of the branch:'
read branch

git push origin $branch

read

store the above code as a .sh file(say gitpush.sh)

And since you have to make this sh file an executable you need to run the following command in the terminal once:

chmod +x gitpush.sh

And now run this .sh file.

Each time you run it, It will ask you for the commit message and the name of the branch. In case the branch does not exist or the push destination is not defined then git will generate an error. TO read this error, I have added the last read statement. If there are no errors, then git generates the pushed successfully type-of message.

Answer 2

You could use alias and shell function together, in $HOME/.gitconfig or .git/config

[alias]
        newalias = "!f(){ git add . && git commit -m \"$1\"; git push origin master; };f"

and call it as

$ git newalias "message ..."

Answer 3

Commiting your work once a day as a big chunk is not an effective use of version control. It's far better to make small, regular, atomic commits that reflect steps in the development of the code base (or whatever else is being tracked in the repository)

Using a shell script is perhaps overkill - most people use aliases to automate git commands, either as shell aliases or git aliases.

In my case I use shell aliases - a couple of which are:

alias gp='git push'
alias gc='git commit'
alias gca='git commit -a'
alias gcm='git commit -m'
alias gcam='git commit -am'

so for me to do what you're asking would be:

gcam "My commit message";gp

This isn't a lot of typing and is hardly boring, I do this and similar git operations literally dozens of times a day (I know - because I check my shell history).

The reason for using small aliases rather than a script is so that I have the flexibility to use different ways of committing, If I used a script I would lose that flexibility.

Answer 4

That is not a lot of typing to do but the process can be simplified by the usage of aliases.

edit $HOME/.gitconfig to add some shortcuts, e.g. to use git p as an alias for git push origin master, use:

[alias]
        p = push origin master

If you're on a descent shell like bash, you can use the history feature. Everything you need to know is in the man page for bash.

Read more about aliases here

On a side-note, git add . is probably not the best approach since it adds every file in the folder to the staging area. Better to use git add -u to only add those files already in the index.

Answer 5

The best solution for windows: 1) create a text file anywhere on you system and insert the following code into it after changing the fields according to your need

git add .

git commit -m "commitMessage"

git push url master

exit

2) save and exit file.

3) change the file name to push.sh.

4) navigate to file directory on your system using git powershell then use the following command chmod +x push.sh to make your file runnable.

5) click windows start and search for Task Scheduler and press create a new task.

6) click on the action and browse to your push.sh file press okay.

7) navigate to triggers and modify scheduling time.

Now you have a script which is automated as you wish.

Answer 6

For my workflow, git "adds" and git "commits" are targeted and atomic, so rolling those into a single bulk command isn't useful. However, each day, I push to a number of different branches across a number of different repositories, and that usually follows the pattern of "git push origin {branchname}". That can be automated in a shell script:

parse_git_branch() {
  git symbolic-ref HEAD 2>/dev/null | cut -d"/" -f 3
}
git push origin $(parse_git_branch)

You could then add a bash alias (e.g., "git-push") to call this script, which would effectively run "git push origin {currently checked out branch}" on whichever repository you're located in.

Answer 7

My bash script will pick your current branch you're on and also pull to avoid conflicts from the same branch and then push. This script gets really helpful in case you're going to work between/across many branches.

git add .
read -p "Enter commit message: " commit_message
git commit -m "$commit_message"
BRANCH=$(git describe --contains --all HEAD)
git pull --rebase origin "$BRANCH"
git push origin "$BRANCH"

Way to use:

• Put this script in a bash or shell file with name of your choice.
• Run the script for eg: sh pdg.sh
• Add your commit message & done. Code is pushed.

Answer 8

Here's a simple bash script

#!/bin/bash
git add .
echo "Insert your commit message >"
read -r commit
git commit -m "$commit"
echo "Pull, Push, or Switch Branch >"
read -r answer
if [[ $answer == "pull" ]];
then
    git pull
    echo "Done with pulling, would you like to push your files (y/n)?"
    read -r pushing
    if [[ $pushing == "y" ]];
    then
        git push
    else
        exit;
    fi
elif [[ $answer == "push" ]];
then
    git push
elif [[ $answer == "switch branch" ]];
then
    echo "Enter the new branch name >"
    read -r branch
    git checkout "$branch"
fi

save this as a .sh extension then +x for execution permission

Answer 9

If you are using Zsh on macOS, you can create functions in your ~/.zshrc file to automate the repetitive Git commands you mentioned.

To get started, open your terminal and execute the following command to open the ~/.zshrc file in a text editor:

open ~/.zshrc

This will open the ~/.zshrc file in the default text editor configured on your system.

Add the following functions to the file:

function gitinit() {
    git init
    git add .
    git commit -m "$1"
    git branch -M main
    git remote add origin $2
    git push -u origin main
}

function gitcommit() {
    git add .
    git commit -m "$1"
}

function gitpush() {
    git add .
    git commit -m "$1"
    git push origin main
}

Save the file and exit the text editor.

To apply the changes and make the functions available in your current terminal session, you can either restart your terminal or run the following command:

source ~/.zshrc

Afterward, you can simply use these functions to automate your Git workflow. For example:

gitinit "Initial commit" git@github.com:your-username/your-repo.git
gitcommit "Added new feature"
gitpush "Pushing latest changes"

These functions will execute the corresponding Git commands with the provided arguments.

---

Make sure to replace your-username and your-repo in the gitinit function call with your actual GitHub username and repository name.