GitHub - Pull changes from a template repository

Question

I have created a Template Repository in GitHub and then created some repositories based on the template. Since they were created, there have been updates to the template that I want to pull into those repositories.

Is this possible?

Answer 1

This issue can be solved efficiently using a GitHub Action named actions-template-sync. The action is designed to synchronize git repositories in an automated way, and it supports different git providers such as GitHub (enterprise), GitLab, etc. It was primarily developed to help keep repositories created from a template up-to-date with changes in the template repository.

Here are some of its key features:

• It can sync with other public or private repositories (e.g., template repositories) with the current repository.
• It supports ignoring files and folders from syncing using a .templatesyncignore file.
• It provides many configuration options.
• It supports different lifecycle hooks, opening the possibility to inject custom code into the workflow with a yaml definition file.
• It supports different git providers like GitLab, Gitea, etc., as sources (with ssh).

One great thing about this action is that it doesn't necessarily require the source and target repositories to have the same base history. This means you can merge two totally different repositories with the help of this action.

Here is a simple example of how to use it:

1. First, add the action to your GitHub workflows. Create a .github/workflows/sync.yml file in your repository and add the following content:

name: Sync with template

on:
  push:
    branches:
      - main

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Template Sync
        uses: BernhardStrauss/actions-template-sync@v0.8.0
        with:
          source_repo: "https://github.com/source_owner/source_repo.git"
          source_branch: "main"
          github_token: ${{ secrets.GITHUB_TOKEN }}

Replace "https://github.com/source_owner/source_repo.git" with the URL of your template repository and "main" with the branch you want to sync from. secrets.GITHUB_TOKEN is a built-in GitHub secret that is automatically created for your repository.

2. Push this file to your repository:

git add .github/workflows/sync.yml
git commit -m "Add template sync workflow"
git push

3. Now, every time you push to the main branch of your repository, the workflow will run and synchronize your repository with the template.

Remember to replace the source_repo and source_branch with your actual template repository and branch. The github_token should be your personal access token.

You can find more detailed usage instructions and options in the official documentation.

Answer 2

I prefer to just squash the remote template branches commit history:

This keeps it clean and simple. Remember to add remote and fetch first.

git merge template/master --strategy-option ours --squash

Answer 3

On the other repositories you have to add this template repository as a remote.

git remote add template [URL of the template repo]

Then run git fetch to update the changes

git fetch --all

Then is possible to merge another branch from the new remote to your current one.

git merge template/[branch to merge] --allow-unrelated-histories

https://help.github.com/en/articles/adding-a-remote

Answer 4

This works too:

git remote add template git@github.com:org/template-repo.git
git fetch --all
git merge template/main --allow-unrelated-histories

Answer 5

I ran into this same issue. I have 10+ projects all created from the same template project (react-kindling) and using git alone wasn't sufficient, as it would pull in changes to the template that I didn't want in my child projects.

I ended up creating an npm utility for updating child projects from template starter projects. You can check it out here:

LockBlocks

It's been a real life saver. Pulling changes from the template is a heck of a lot easier now.

Answer 6

Another option is to create a patch from the necessary commits and move the patch to a new project

git format-patch -1 HEAD

Insert a patch

git am < file.patch

details are here

Answer 7

If you want to merge changes from a template into your project, you're going to need to fetch all of the missing commits from the template, and apply them to your own repo.

To do this, you're going to need to know the exact commit ID that you templated from, and you're going to need to know the commit ID of your first commit.

ORIGINAL_COMMIT_ID=<commit id from original repo you templated from>
YOUR_FIRST_COMMIT=<first commit id in your repo>
YOUR_BRANCH=master

Next you're going to need add the template as a remote, and fetch it.

git remote add upstream git@github.com:whatever/foo.git
git fetch upstream

And finally, you need to rebase all of the commits you're missing onto your branch

git rebase --onto ORIGINAL_COMMIT_ID YOUR_FIRST_COMMIT YOUR_BRANCH

What this is doing it basically creating a branch off of ORIGINAL_COMMIT_ID, then manually applying all of the commits on your original branch, onto this new branch.

This leaves you with what you would have had, if you had forked.

From here, you can git merge upstream/master just as if you had forked.

Once you've completed your merge, you'll need to use git push --force to push all of the changes up to the remote. If you're working with a team, you'll need to coordinate with everyone when doing this, as you're changing the history of the repo.

Note: It's important to note that this is only going to apply to one branch. If you have multiple feature branches, you'll need to perform the same steps to each one.

Answer 8

@daniel's answer also did not work for me because of the unrelated histories problem mentioned in @dima's answer. I achieved the desired functionality by doing the following:

1. Copy the URL for the template repository you wish to use to create a new repository. (ex: https://github.com/<username>/my-template.git)

2. Use GitHub Importer to make a new repository based on the template repository.

   This solves the unrelated histories problem because it preserves the entire commit history of the template repository.

   You need to use the Importer because you cannot fork your own repository. If you want to use someone else's template repository, you can just fork theirs.

3. Then, add the template repository as a remote.

   git remote add template https://github.com/<username>/my-template.git
   

4. After you make new commits to the template repository, you can fetch those changes.

   git fetch template
   

5. Then, merge or rebase. I recommend to merge on public repos and rebase on private repos.

   To merge

   git checkout <branch-to-merge-to>
   git merge template/<branch-to-merge>
   

   To rebase

   git checkout <branch-to-merge-to>
   git rebase upstream/<branch-to-merge>
   

   NOTE: When rebasing, you must

   git push origin <branch-name> --force
   

   in order to override your old commits on your remote branch. This is why I recommend to rebase only on private repos.

Answer 9

I approached this differently as fetch & merge was not ideal as lot of files diverge across template and downstream projects. I only needed the common elements to sync.

lets says we have the below folder structure locally:

repos
├── template_repo
└── downstream_repo

1. Now create a git patch from the parent folder (repos):

git diff --no-index --diff-filter=d --output=upstream_changes.patch -- downstream_repo/some_common_path template_repo/some_common_path

NOTE - the order of the paths matters!, downstream_repo comes first! (interpret this as "what are the changes we need to make to downstream_repo to make it same as template_repo"; look at the --name-status output, it will hopefully make sense.)

--no-index option generates git diff based on filesystem paths. Path can be a single file or a folder.

--diff-filter=d will ignore any files that are in the downstream_repo but not in the template_repo. This only applies when diffing folder paths.

You can use --stat, --name-status to see what the patch will contain. Review the generated patch.

2. Change to downstream_repo folder and apply the patch

git apply -p2 ../upstream_changes.patch

explanation for -p<n> option from the official doc:

Remove leading path components (separated by slashes) from traditional diff paths. E.g., with -p2, a patch against a/dir/file will be applied directly to file. The default is 1.

Using -p2 will drop a/downstream_repo and b/template_repo from the diff paths allowing the patch to apply.

This is the reason for starting with above illustrated folder structure. Once the patch is applied, rest of the process should be familiar.

All of these options are clearly explained in git diff and git apply official docs.

Answer 10

I will link to the same location as HRK44 but my answer is very different.

https://help.github.com/en/articles/creating-a-repository-from-a-template

Although forks and templates are mentioned in the same section, they are very different.

One of the differences mentioned in the link is:

A new fork includes the entire commit history of the parent repository, while a repository created from a template starts with a single commit.

This basicly means that you will not be able to pull new changes from the template as your git histories are very different and are not based on the same thing.

If you do use the method mentioned in the accepted answer, you will have very hard manual merges that will result in changes to all of the files received from the template, even if they werent changed since the first time you created that repo from that template.

In short, creating a repo from a template (using only master branch) is the same process as:

git clone template
cd folder
rm -rf .git
git init
git remote add origin <new repo url>
git add . 
git commit -m "Initial Commit"
git push -u origin master

A few other things that are not (surprisingly) copied when creating a repo from a template: (Unless github fix this at a later point)

1. Repo configurations (allowed merge types, permissions etc)
2. branch rules

So when using this at your organization, make sure to set all repo configurations on the newly created repo.