What happens if I try to rebase a commit that is already pushed to a development branch

Question

The use case is following

I pull from the development branch then I make some code changes and push then

After few days I come back and do to a git status, this shows that I am ahead of the master branch by 1 commit, obviously I haven't pulled from the master for a couple of days

Now before I make my changes I decide to do a git pull with rebase , git pull --rebase origin master

The question is: will the commit that I had in my local repo branch go on top of the master or since I had already pushed it I will simply get to the tip of the global master/remote branch?

I am new to concept of rebasing so please help explain this.

Answer 1

Let's consider the following.

          D---E---F origin/master
         /
A---B---C---X master
        ^
        origin/master in your repository

A few days ago your local master and origin/master were both in sync and each had commits A, B and C. At some point you committed X in your local master. And concurrently others pushed commits D, E and F to origin/master.

At this point if you run git pull --rebase origin master, will pull all commits from the origin/master as is and the commit X will be replayed over top of F and a new commit id will be generated X'.

The new commit graph will look like:

                     origin/master
                    /
A---B---C---D---E---F---X' master
                    ^
                    origin/master in your repository

So yes, the old commit X will be rebased at the top of your local master as commit X'.

EDIT:

the question in this use case what if I had pushed X and then D,E,F were made, how will my local branch look asfter i execute the pull with rebase now?

In this case, after pushing your commit X, both your local repository and origin/master will be in sync.

             origin/master
            /
A---B---C---X master
            ^
            origin/master in your repository

After few days the commits D, E and F are pushed by others to the origin/master. The commit graph will then look like this:

             D---E---F origin/master
            /
A---B---C---X master
            ^
            origin/master in your repository

Now if you run git pull --rebase origin master it will give identical results to the git pull origin master command, because there is nothing to rebase from. You do not have have any commits ahead of origin/master. At the end of this command your graph will look like this:

                          origin/master
                         /
A---B---C---X---D---E---F master
                        ^
                        origin/master in your repository

Since your commit X was already in origin/master, it will not be replayed on top of D, E and F.

Answer 2

The question is: will the commit that I had in my local repo branch go on top of the master or since I had already pushed it I will simply get to the tip of the global master/remote branch?

If by "global" you mean "remote", then yes, your local branch is going to be rebased on top of origin/master. See below for a longer explanation.

---

Based on your question, your repository started out looking like this:

o---o--------------o
    ^              ^   
    master         development
    origin/master  origin/development
    

Your local master branch was in sync with the remote origin/master branch; also, you had a local development branch with 1 commit, which you pushed to the remote repository thus creating origin/development.

Now, assuming your current branch is development, if you run

git pull --rebase origin master

Git is going to fetch any new objects from the origin remote and update your remote tracking branch origin/master:

                  origin/master
                  ⌄
          o---o---o
         /
    o---o--------------o
        ^              ^   
        master         development
                       origin/development

Then, it's going to rebase your current branch (in this case development) on top of the updated origin/master branch:

                  origin/master  development
                  ⌄              ⌄
          o---o---o--------------o'
         /         
    o---o--------------o
        ^              ^   
        master         origin/development

Note that your local master branch is still pointing to the same commit it did before—that's because the second part of git pull (merge or rebase) always operates on the current branch, in your case development.

Now, if you were to push your local development branch after the pull operation is complete, you would update the origin/development remote tracking branch to point to the rebase commit:

                                 origin/development
                  origin/master  development
                  ⌄              ⌄
          o---o---o--------------o'
         /         
    o---o
        ^                 
        master

Again, your local master is unchanged until you do:

git checkout master && git merge origin/master

The git pull command is a complex beast, since it does wildly different things based on which branch you're on when you invoke it and which arguments you pass to it.

Here's what the documentation has to say about the form with three arguments:

Merge into the current branch the remote branch next:

$ git pull origin next

This leaves a copy of next temporarily in FETCH_HEAD, and updates the remote-tracking branch origin/next.

I also suggest reading this answer for a more detailed explanation of how git pull behaves in different scenarios.