Skip to main content
SimilarExport ZIP
100%

How to make git repo to be another's repo subfolder preserving history

✓ Published0🌍 Public
RRestuta
Last edited Jan 8, 2015
Created on Jan 7, 2015

This example shows a multi-step Git workflow for relocating an existing repository (`Proto`) into a subfolder of another repository (`Main`) while preserving full commit history. It demonstrates the use of `git checkout --orphan`, `git rebase`, and the history-rewriting command `git filter-branch --tree-filter` to move all files into `SRC/proto` across every prior commit. The process also addresses hidden files (like `.editorconfig`) and explains how to merge the two repositories via `git remote add` and a final `git rebase`. The source is a plain-text markdown guide with shell commands.

AI-generated description

Similar vizzes

Loading thumbnail…

8 steps to using someone's "seed / boilerplate" repo as the basis for another project / repo.

This example outlines an eight-step procedure for reusing a seed or boilerplate repository as the foundation for a new project. It demonstrates the workflow through a plain-text gist, showing how to clone the original repo, remove its git remote or history, create a fresh GitHub repository, and establish a new remote origin. The steps conclude with committing the starter code and pushing it to the new remote. No external visualization libraries or APIs are used; the content relies solely on command-line git operations.

GGRamirez2
65% match
Loading thumbnail…

Gist 2aa1cc8e6a4bd43cc1b184cd303e5225

This visualization is a technical note, presented as a simple text document, that explains how to use a Git rebase to edit, rename, or delete specific commits, whether they are local or remote. The example does not render any graphical data; instead, it shows a code snippet and a text explanation in Spanish, directly referencing an Atlassian Confluence page for further details. The entire piece is a static text block, with no interactive or dynamic elements, serving solely as a reference guide.

MMistyBlunch
62% match
Loading thumbnail…

Complete remove of git submoule

This example shows a shell script that completely removes a Git submodule from a repository, handling both the working tree and internal Git metadata. The script takes a submodule path as input, then sequentially executes `git submodule deinit`, `git rm`, and edits configuration files via `git config`, before manually deleting the submodule’s directory and its stored Git data. It relies on standard Git command-line APIs and Bash utilities like `sed`, `grep`, and `rm`, and includes verbose error checking and explanatory output. The code demonstrates a rigorous cleanup workflow beyond a plain `git rm`, ensuring all traces are purged.

GGerHobbelt
61% match
Loading thumbnail…

Gist 619560

This visualization loads a map using Polymaps and merges it with a local fork via a shell script. The code demonstrates a version-control workflow rather than a graphical output, as it logs git commands piping the `mbostock/master` branch into the local tree. The primary rendering relies on Polymaps’ tile-based mapping, while the surrounding repository management shows how to integrate external contributions. The example pairs a geographic data display with a practical Git merge, highlighting maintenance of a live mapping project through `git remote`, `fetch`, and `merge` operations.

Mmbostock
59% match
Loading thumbnail…

The Gist to Clone All Gists

This example demonstrates a practical workflow for backing up or synchronizing a GitHub user’s public gists. It first clones every gist from a specified GitHub account over SSH, using a paginated API fetch to retrieve the list of gists and the Node.js `https` module to authenticate via an OAuth token. It then shows a complementary bash script that iterates through local directories, committing any changes with an empty message and pushing them back to their remote origins. The visualization highlights the interplay between the GitHub REST API and command-line Git operations for batch repository management.

Mmbostock
59% match
Loading thumbnail…

Gist 96829331ffd980ee6a4f3ab1196708f1

This visualization presents a structured Git cheat sheet, organizing commands into clear categories like configuration, local and remote branch management, and advanced operations. It demonstrates a comprehensive set of command-line workflows, including branching, merging, stashing, and comparing changes, each paired with practical usage examples. The rendering relies on standard Markdown code blocks and inline formatting to distinguish commands, comments, and options, providing a reference-style layout rather than a data-driven graphic.

JJaxonDvl
59% match
Loading thumbnail…

rename master to main

This example shows a step-by-step command-line sequence for renaming a Git repository’s default branch from `master` to `main` and updating the remote. The visualization presents the two-line `rename.bat` script, followed by comments explaining the need to change the default branch in GitHub’s settings before the final delete command can succeed. It uses the Git command-line interface (via `git branch`, `git push`, and `git push origin --delete`) to illustrate the workflow. The data source is the script itself, rendered as plain text without any graphical or programmatic visualization libraries.

HHerbCaudill
59% match
Loading thumbnail…

Gist 1a9660527e35cdeba43b

This example visualizes a Git branching and merging workflow as a sequence of command blocks, showing each step from checkout through commit and merge. The code uses d3’s selection and transition methods to animate the blocks appearing in sequence, with text labels for branch names and commit messages. It renders as a simple timeline of styled HTML divs, where the data—the list of shell commands—is embedded directly in the markup and driven by d3’s data join. The visualization emphasizes the order and syntax of typical Git operations without simulating actual repository behavior.

LLayne Smith
58% match