How To Sync Forked Repo With Original

In this article, we shall briefly look at how we can submit work and contributions to a GitHub team projection. This article assumes that you accept a GitHub account. Check these instructions on how to create a GitHub user account. Earlier nosotros get started, y'all need to understand the following terms, as you volition constantly come across them in daily GitHub workflow.

Getting started

• Fork is a copy of a repository of someone's else project. Forks allows you lot accept to have a repository of a project that you do not own on your GitHub account then that you lot can make some changes without affecting the original repository. Once the changes on your forked repository are validated, y'all can submit these changes as contributions to the original project. Forks allows you to make your contributions to a squad project.
• Remote a repository on GitHub account exists every bit a remote repository.
• Clone is downloading a copy of the remote repository to local estimator.
• Commits are changes fabricated to a repository. Committing saves edits/changes to our GitHub repository. With GitHub, every commit you lot make has a specific signature/ID the keeps the record of the changes you have made. If yous happen to make a incorrect change, you can revert the commit and your remote repository will be as information technology was before y'all fabricated the changes. A commit has a commit bulletin that allows you to accept a brief description of the changes you are making.
• Push is used to transfer commits made on a local repository to a GitHub remote repository. To push to GitHub you make a push asking to update your local commits to your remote repository.
• Branch a feature branch or base co-operative. A characteristic branch typically helps you to isolate your changes from the other squad as you brand and test these changes. The base of operations co-operative consists of merged feature branches.
• Pull request is to notify the project team of the changes you have made from a pushed branch in your GitHub repository or basically requesting the possessor of the repository to pull changes you fabricated, thus called a pull request. A collaborator can exist assigned to review your pull and propose any potential changes you need to make. Review changes are washed with commits. Once changes and reviews are complete a team contributor or you (with access), can merge your branch to the base of operations branch of the original repository.
• Merge is merging two branches and integrating them into a single branch. A merge conflict tin can happen if the 2 branches you are attempting to merge have both modified the aforementioned role of the same file. In such a case, Git will not exist able to automatically cull which version to employ.

How to fork

Now that you know, what a fork is, permit's see how you can fork a repository to outset working on your changes and contribute to a team projection. Forking a project on GitHub is really easy, you just demand to hit the fork button. On your GitHub business relationship, go to the repository you want to fork. In this case, we are referring to https://github.com/department-io/engineering-education. To the upper left corner, click on the fork button and you will have successfully forked the repository.

Now you have a re-create of the original repository on your GitHub account.

To start pushing, committing, and pulling, yous need clone the repository you lot have forked (on your GitHub account) and a have copy on your computer to starting time working on your contributions.

How to clone

Cloning using GitHub desktop

If y'all are using the GitHub desktop app, cloning a repository is as easy every bit pie. To get started, download GitHub desktop and install it into your computer and authenticate and configure information technology with your GitHub account.

To make GitHub desktop work easier, make sure you configure GitHub desktop with a text editor such as Visual Studio Code.

Once that is done, your GitHub account volition load on the GitHub desktop. To start cloning, navigate to File so clone repository.

A clone window will pop up, you volition be able to see the repositories in your account, and choose the repository you lot want to clone.

Alternatively, you lot may use the URL from GitHub remote repository, paste on the clone box of GitHub desktop, and initiate cloning, select your preferred location of the cloned repository to your local computer and you are washed.

Cloning using Git Bash

Git uses protocols to transfer data from a remote server to your local automobile. The main used URL protocols include:

• SSH (Secure Crush) is an authenticated network protocol that needs credentials (a countersign) before making a connection to the hosting server. This is how a SSH link looks similar:

            git://host.xz[:port]/path/to/repository.git                      

Example

            git@github.com:section-io/applied science-educational activity.git                      

• HTTP/HTTPS (Hyper text transfer protocol). The protocol of the spider web, most commonly used for transferring web page HTML data over the Internet. Git can be configured to communicate over HTTPS with encoded information manual.

            http[s]://host.xz[:port]/path/to/repository.git/                      

In this article, we shall use SSH URL protocol using Git Fustigate to execute git commands. However, to get started with Git Fustigate, you lot need to exercise the following authentication.

Outset, download and install git, launch Git Bash and sign in to your GitHub account using the following commands.

Note: retrieve to press enter afterward any of the following

            git config --global user.name              "your github account username"                      

            git config --global user.e-mail              "your github account e-mail"                      

Run

            git config --global user.proper name                      

to ostend username and

            git config --global user.email                      

to confirm email. To connect to your GitHub account yous need to generate an SSH key. Run

            ssh-keygen -t rsa -C              "your github email"                      

Utilise the same electronic mail equally your GitHub account email. Later pressing enter on this command, you lot will be required to enter a password twice (this is non your GitHub countersign), enter any countersign of your pick, and when asked for confirmation renter the countersign again. An SSH lawmaking volition be generated and you need it to authenticate the protocol. To open the file created, run

            notepad ~/.ssh/id_rsa.pub                      

The file contains the SSH lawmaking, copy the cardinal, and follow these instructions.

• On your GitHub account, go to settings
• Go to SSH and GPG keys
• Then new SSH fundamental
• Enter the championship "your cardinal"
• Paste the copied SSH fundamental in the big box
• Run command ssh -T git@github.com to check if the configuration is ok

This should requite yous the following bulletin Hi username! You lot've successfully authenticated, just GitHub does not provide beat out access. Now you lot are adept to go with SSH protocol

To start our clone run git clone (SSH URL)

Example

            git clone git@github.com:kimkimani/engineering-pedagogy.git                      

Output

            Cloning into              'engineering-education'... Enter passphrase              for              key              '/c/Users/kim/.ssh/id_rsa': remote: Enumerating objects: 20,              done. remote: Counting objects: 100%              (20/20),              done. remote: Compressing objects: 100%              (16/sixteen),              done. remote: Total              9676              (delta 8), reused              fourteen              (delta iv), pack-reused              9656              Receiving objects: 100%              (9676/9676), 108.32 MiB | 116.00 KiB/due south,              done. Resolving deltas: 100%              (5361/5361),              done. Updating files: 100%              (785/785),              done.                      

Annotation: make sure the link you copy is SSH. And remember to use the password y'all used when generating the SSH primal to make authentication for passphrase for key '/c/Users/you/.ssh/id_rsa\': If yous practise not enter the SSH password, yous will run into the post-obit output Please make sure you have the correct access rights and the repository exists.

A copy of the remote is now available on your local reckoner on the location you entered on the Git Fustigate control with the folder name the aforementioned equally the name of the repository in the remote repository. In instance you want to have a different project folder utilise the clone command followed by the name of your preferred folder.

            git clone git@github.com:department-io/engineering science-didactics.git folder-name                      

When using a forked repo, the original repository will regularly be updated with commits. These commits are not directly updated to your repository, thus you need to regularly update your fork to proceed information technology up to date with the original repository.

Updating a fork using GitHub web UI

The process is simple and articulate. Go to your forked repository in your GitHub account, you will see the number of commits that the original repository has, and have and not been updated to your forked repository.

Click compare.

Employ switch to base link.

If the switch to base of operations is non bachelor, use the dropdown to manually select the repositories to compare. When the comparing selections are correctly selected, you will be able to see the commits that are not updated to your fork.

Continue to the dark-green button and create a pull asking.

Enter a championship "updating my fork", comment as well, and proceed to create a pull request.

Whorl to merge request.

Confirm merge.

And you are done, your fork is at present updated successfully. The fork is updated on the remote and you now need to update the changes to your local repository. Go to your GitHub desktop and make certain your current repository you are working with is selected.

You will able to meet a "pull origin". What this does is it pulls the remote changes to your local repository.

Click "pull origin" and your local repository volition be updated and the same every bit the remote repository.

Summary

Updating a fork using Git Bash.

Yous take successfully forked your interested repository. Still, you lot occasionally need to proceed it upwardly to date with the original repository. The original repository is commonly referred to upstream by Git Fustigate command.

To update your fork with the upstream, you demand to get the remote to your local repository and then that you can fetch bachelor changes made in the original repository and push button the changes to your local repository.

To get started navigate to your cloned repository (already on your local computer) and open up the project folder with Git Bash or open Git Bash and modify the directory to point the cloned repository on your local storage. i.e.

            cd ~/Documents/GitHub/engineering science-pedagogy                      

By default, your local repository is not straight linked to the original repository. Configure the remote upstream to be available locally.

OUTPUT

            origin  git@github.com:kimkimani/engineering science-education.git              (fetch)              origin  git@github.com:kimkimani/engineering science-education.git              (push button)                      

At this point, only the original repository is linked (The remote repository that yous forked from the original). Link your repository with the remote or the original repository.

            git remote add upstream <ssh url from the original repository> git remote add upstream git@github.com:section-io/engineering-education.git                      

Run

To confirm if your remote upstream is bachelor on your local repository origin.
Output

            git@github.com:kimkimani/engineering-educational activity.git              (fetch)              origin  git@github.com:kimkimani/engineering-didactics.git              (push)              upstream        git@github.com:section-io/applied science-education.git              (fetch)              upstream        git@github.com:section-io/applied science-instruction.git              (push)                      

What you demand now is to fetch the changes/commits from the upstream

Output

            Enter passphrase              for              key              '/c/Users/kim/.ssh/id_rsa': remote: Enumerating objects: 139,              done. remote: Counting objects: 100%              (139/139),              done. remote: Compressing objects: 100%              (66/66),              done. remote: Total              131              (delta 88), reused              105              (delta 65), pack-reused              0              Receiving objects: 100%              (131/131), 696.24 KiB | 11.00 KiB/south,              done. Resolving deltas: 100%              (88/88), completed with              8              local objects.  *              [new branch]              EngEd-template-idea-class -> upstream/EngEd-template-idea-form  *              [new branch]              add-section-home       -> upstream/add-department-abode  *              [new branch]              address-resolution-protocol -> upstream/accost-resolution-protocol  *              [new branch]              authors-link           -> upstream/authors-link  *              [new co-operative]              clustering-algorithms  -> upstream/clustering-algorithms  *              [new co-operative]              documentation          -> upstream/documentation  *              [new branch]              fix-topic-capitalization -> upstream/fix-topic-capitalization  *              [new branch]              fixing-blank-writer-pages -> upstream/fixing-bare-writer-pages  *              [new branch]              quaternary                 -> upstream/fourth  *              [new co-operative]              introduction-web-associates -> upstream/introduction-spider web-assembly  *              [new co-operative]              knapsack               -> upstream/knapsack  *              [new branch]              make-author-pages-piece of work -> upstream/brand-author-pages-work  *              [new branch]              man-in-the-eye-attack -> upstream/man-in-the-eye-attack  *              [new branch]              principal                 -> upstream/master  *              [new branch]              matplotlib-visualization-python -> upstream/matplotlib-visualization-python  *              [new co-operative]              nodejs-backend-frontend -> upstream/nodejs-backend-frontend  *              [new branch]              nodejs-cta-blocks      -> upstream/nodejs-cta-blocks  *              [new branch]              pr/54                  -> upstream/pr/54  *              [new branch]              individual-cake-concatenation    -> upstream/individual-block-chain  *              [new branch]              quality-checker-action -> upstream/quality-checker-action  *              [new branch]              remove-manufactures        -> upstream/remove-articles  *              [new co-operative]              remove-unused-topic-pages -> upstream/remove-unused-topic-pages  *              [new co-operative]              site-mapping           -> upstream/site-mapping  *              [new co-operative]              supervised-machine-learning -> upstream/supervised-auto-learning  *              [new co-operative]              testing-writer-page-blank -> upstream/testing-writer-page-blank  *              [new branch]              vlan-trunking          -> upstream/vlan-trunking  *              [new branch]              vm-vs-containers       -> upstream/vm-vs-containers                      

Y'all have fetched the changes, commits, and branches that you need to merge to the head branch. Earlier doing the merge, make sure you are updating this changes on your chief.

            git checkout upstream/master                      

Output

            Notation: switching to              'upstream/primary'. You are in              'detached HEAD'              state. Y'all can look around, make experimental changes and commit them, and yous can discard whatever commits you lot make in this land without impacting any branches by switching dorsum to a co-operative. If you want to create a new branch to retain commits you create, you may              do              so              (now or afterwards)              by using -c with the switch command.  Example:   git switch -c <new-branch-proper name>  Or disengage this functioning with:   git switch -  Plow off this communication by setting config variable advice.detachedHead to false HEAD is now at              1335657              Merge pull request              #272 from kimkimani/near-useful-NodeJs-packages                      

OUTPUT bash Previous Caput position was 1335657 Merge pull request #272 from kimkimani/virtually-useful-NodeJs-packages Switched to branch 'main' Your branch is upwardly to date with 'origin/master

This points to the branch y'all are already on, in one case on the main branch, merge it with the upstream.

Output

            Updating d9acac5..646cb27 Fast-forrad  articles/huffman-coding-in-python/hero.jpg         | Bin              0              ->              27160              bytes  articles/huffman-coding-in-python/Code_Output.jpg  | Bin              0              ->              16932              bytes  articles/huffman-coding-in-python/index.md         |              185              ++++++++++++++  articles/huffman-coding-in-python/optimaltree.jpg  | Bin              0              ->              48468              bytes  .../stripe-integration-react/api_test_keys.jpg     | Bin              0              ->              160402              bytes  articles/stripe-integration-react/dashboard.jpg    | Bin              0              ->              147132              bytes  manufactures/stripe-integration-react/final_output.jpg | Bin              0              ->              90318              bytes  manufactures/stripe-integration-react/hero.jpg         | Bin              0              ->              30446              bytes  manufactures/stripe-integration-react/index.md         |              281              +++++++++++++++++++++  manufactures/stripe-integration-react/paymentflow.jpg  | Bin              0              ->              71723              bytes  articles/stripe-integration-react/paywithcard.jpg  | Bin              0              ->              65169              bytes              xi              files changed,              466              insertions(+)              create fashion              100644              articles/huffman-coding-in-python/Code_Output.jpg  create manner              100644              articles/huffman-coding-in-python/hero.jpg  create mode              100644              articles/huffman-coding-in-python/alphabetize.md  create mode              100644              articles/huffman-coding-in-python/optimaltree.jpg  create mode              100644              articles/stripe-integration-react/api_test_keys.jpg  create mode              100644              manufactures/stripe-integration-react/dashboard.jpg  create style              100644              articles/stripe-integration-react/final_output.jpg  create mode              100644              articles/stripe-integration-react/hero.jpg  create mode              100644              articles/stripe-integration-react/index.md  create mode              100644              articles/stripe-integration-react/paymentflow.jpg  create mode              100644              articles/stripe-integration-react/paywithcard.jpg                      

If the upstream and master have no changes to merge , Already upward to date. message volition exist printed on your Git Bash. These changes are committed to your local repository,

Output

            Switched to branch              'master'              Your branch is ahead of              'origin/master'              by              25              commits.              (use              "git push"              to publish your local commits)                      

Button these commits to publish them to your remote repository.

And you are done. Refresh your remote repository, it will exist up to date with the upstream.

We have forked, cloned, our repository is up to engagement, plus we are ready to work on our contributions. Before you submit your contributions, make sure you lot work on your changes and your content is well formatted ready to make a pull request.

Submit contributions using GitHub desktop

For convenience, open up GitHub and open the repository with your preferred text editor.

If you are using Visual Studio Code, your cloned folder should look similar to this

Since nosotros are trying to make our contributions to Section, navigate to the articles folder.

Create a folder to work with.

Add your contributions (i.e. index.md, hero prototype, and other media where necessary).

When you lot are done adding all your content, yous now demand to commit the changes to your remote GitHub repository. Launch your GitHub desktop and you lot will exist able to run across the changes y'all take added.

It is at present simple from here, create a co-operative that volition have your changes.

Since we take our changes ready, we need to merge these changes to the branch we take created. i.e. "the changes on your folder and your piece of work in progress volition follow to the new co-operative" and click switch to branch.

Publish the branch to your remote GitHub account and make sure y'all add a commit message as the summary.

Your branch content is on your remote GitHub repository, and you demand to create a pull request to the origin repository to contribute your changes.

The create a pull request button will redirect you to your GitHub business relationship where y'all at present need to create a pull request. Make sure your title is relevant to the content yous want to publish. Write a annotate in the comment box with brief details of your content.

In one case the pull request push button is striking, you are done, you have submitted your contributions successfully.

Wait for your content to be reviewed and if whatever farther changes are needed, a comment will be left past the reviewer suggesting possible changes yous should make under your pull. Make your edits on your text editor and make a commit to update the changes and remember to take a summary of the commit you are making for better referencing.

Submit contributions using Git bash.

Since you have a clone available on your local reckoner, start working on you lot contributions using a text editor. Format your content co-ordinate to the guidelines of the original repository.

Once yous are done and set up to publish the content, it is advisable to push your changes nether a co-operative and non to the master repository. This will assistance you to piece of work and contribute changes under different topics without co-operative or merge conflicts.

When the content (topic) is ready, create a branch and make certain you checkout on the branch as it volition hold all your changes yous are working on. Open GitHub local directory on Git Bash.

If you run

OUTPUT

All the branches y'all accept created will be printed, in this case we take main branch, which is the current checkout. Create a new co-operative, with the proper noun relevant to the topic or the content you want to push.

            git co-operative <branch name> git branch my-outset-contributions                      

The new branch has been created. To ostend if the new branch was really created, run

OUTPUT

            * master   my-commencement-contributions                      

Checkout the new branch y'all have created

            git checkout <branch name> git checkout my-first-contributions                      

OUTPUT

            Switched to branch              'my-first-contributions'                      

All the available changes that you have made will be directed to the branch on the checkout. To check the changes you have created/modified run

OUTPUT

            On branch my-outset-contributions Untracked files:              (use              "git add together <file>..."              to include in what volition be committed)              articles/new-folder-name/ nil added to commit but untracked files present              (utilise              "git add"              to rails)                      

These changes are available on the local repository, and you need to make them gear up to be pushed to your remote. To practise this, run

            git add .              (make sure the fullstop afterwards git add is included)                      

Run to confirm the changes are ready.

git status

            On co-operative my-kickoff-contributions Changes to be committed:              (apply              "git restore --staged <file>..."              to unstage)              new file:   articles/new-binder-name/hero.jpg         new file:   articles/new-folder-proper noun/index.dr.                      

Your file changes will be highlighted greenish, pregnant gear up to be published to remote. These changes are ready to be committed

            git commit -m              "my start contribution"                      

                          [my-beginning-contributions 6b5e391]              my get-go contribution              2              files inverse,              1              insertion(+)              create mode              100644              articles/new-folder-proper name/hero.jpg  create mode              100644              manufactures/new-folder-proper name/index.                      

Push to the branch

            git push origin my-first-contributions                      

Your content is now on your remote forked repository. To share your contributions to the team, y'all demand to make a pull request. Get to your GitHub account, nether your forked repository.

Click the compare and pull request push button.

And you are done. Wait for your content to be reviewed, make changes where necessary and your pull request will be merged to the team project.

Note: every fourth dimension you are making new contributions, ensure your remote fork and the local repository are up to date.

Determination

The outputs highlighted on this commodity may not straight match to what volition exist printed to your Git Fustigate every bit that depend on the commits already published when making a clone or updating a clone likewise as the file changes y'all take made.

References

GitHub with SSH

GitHub authentifications

How to clone GitHub repository

Using Git

Bug and pull requests

Troubleshoot SSH

GitHub workflow management

GitHub desktop

All-time Text Editors

---

Peer Review Contributions by: Nadiv Gold Edelstein

Source: https://www.section.io/engineering-education/how-to-sync-and-update-a-forked-repo/

Share this post