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

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 3

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 4

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 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.