$ git clone https://mshahriarinia:yourpassword@github.com/mshahriarinia/gatordsr.git

clone all remote branches with Git?

First, clone a remote git repository and cd into it:

$ git clone git://example.com/myproject
$ cd myproject

Next, look at the local branches in your repository:

$ git branch
* master

But there are other branches hiding in your repository! You can see these using the -a flag:

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

If you just want to take a quick peek at an upstream branch, you can check it out directly:

$ git checkout origin/experimental

But if you want to work on that branch, you'll need to create a local tracking branch:

$ git checkout -b experimental origin/experimental

Now, if you look at your local branches, this is what you'll see:

$ git branch
* experimental
  master

You can actually track more than one remote repository using git remote.

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

At this point, things are getting pretty crazy, so run gitk to see what's going on:

$ gitk --all &

$ git add changed_file_path

$ git commit -m "commit message put here"

OR $ git commit -am "changed greeting"             //commit filesto the local copy of the repository

-a all files     -m  message

$ git push

Undo to a specific version

How to update GitHub forked repository?

In your local clone of your forked repository, you can add the original GitHub repository as a "remote". ("Remotes" are like nicknames for the URLs of repositories - origin is one, for example.) Then you can fetch all the branches from that upstream repository, and rebase your work to continue working on the upstream version. In terms of commands that might look like:
$ git remote add upstream https://github.com/cegme/gatordsr.git          # Add the remote, call it "upstream":
$ git fetch upstream                    # Fetch all the branches of that remote into remote-tracking branches, such as upstream/master:
         If you see the following, just do: $ git remote rm upstream         then add the upstream as above again.

      fatal: remote error: 

          Repository not found.

$ git checkout master                    # Make sure that you're on your master branch:
$ git rebase upstream/master # Rewrite your master branch (any commits of yours that aren't already in upstream/master are replayed on top of that other branch

If you've rebased your branch onto upstream/master you may need to force the push in order to push it to your own forked repository on GitHub. You'd do that with:

$ git push -f origin master               # You only need to use the -f the first time after you've rebased.

OR $ git merge --no-ff upstream/master              # If you don't want to rewrite the history of your master branch, (for example because other people may have cloned it)

$ git fetch upstream; git checkout master; git rebase upstream/master 

To eclipsify the scala project that uses sbt: $ sbt eclipse

  # Assigns the original repository to a remote called "upstream" . add a remote for the main repo that you forked

Branching allows you to build new features or test out ideas without putting your main project at risk. In git, branch is a sort of bookmark that references the last commit made in the branch. This makes branches very small and easy to work with. Branches are pretty easy to work with and will save you a lot of headaches, especially when working with multiple people. To create a branch and begin working in it, run these commands:

$ git branch mybranch  master          # Creates a new branch called "mybranch" from the latest commit of master.

$ git checkout mybranch  # Makes "mybranch" the active branch

OR $ git checkout -b mybranch master  # Creates a new branch called "mybranch" from the latest commit of master and makes it the active branch

$ git push --all    #save all the branches

To switch between branches

$ git checkout master       # Makes "master" the active branch 

$ git checkout mybranch   # Makes "mybranch" the active branch

Once you're finished working on your branch and are ready to combine it back into the master branch

$ git checkout master            # Makes "master" the active branch 

$ git merge --no-ff  mybranch            # Merges the commits from "mybranch" into "master"  

--no-ff flag causes the merge to always create a new commit object, even if the merge could be performed with a fast-forward.

$ git branch -d mybranch        # Deletes the "mybranch" branch

Good to know: When you switch between branches the files that you work on (the "working copy") are updated to reflect the changes in the new branch. If you have changes you have not committed, git will ensure you do not lose them. Git is also very careful during merges and pulls to ensure you don't lose any changes. When in doubt, commit early and commit often.

Checkout remote branch feat-entityDictionary   

Rebase
The difference between merge and rebase is that merge tries to resolve the changes and create a new commit that blends them. Rebase tries to take your changes since you last diverged from the other branch and replay them from the HEAD of the other branch. However, don’t rebase after you’ve pushed a branch to a remote server – this can cause confusion/problems.