Merge pull request #1442 from SierraSoftworks/feature/support_for_forking

feat(fork): implement repository forking functionality in `gt new`

Author: notheotherben

.github/workflows/changelog.yml

@@ -5,12 +5,12 @@ on:
     branches:
       - main
   pull_request:
-    types: [opened, reopened, synchronize]
+    types: [ opened, reopened, synchronize ]
 
 jobs:
   update:
     name: Prepare
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - uses: release-drafter/release-drafter@v6.1.0
         env:

.github/workflows/test.yml

@@ -7,7 +7,7 @@ on:
 jobs:
   code-quality:
     name: Code Quality
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
 
@@ -21,6 +21,11 @@ jobs:
           components: clippy, rustfmt
           override: true
 
+      - name: install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libdbus-1-3 libdbus-1-dev
+
       - name: install protoc
         run: |
           Invoke-WebRequest -OutFile /tmp/protoc.zip -Uri https://github.com/protocolbuffers/protobuf/releases/download/v3.20.2/protoc-3.20.2-linux-x86_64.zip
@@ -218,6 +223,6 @@ jobs:
     needs:
       - test-platforms
       - code-quality
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - run: echo "Tests Complete for All Platforms"

docs/commands/repos.md

@@ -98,6 +98,8 @@ helping you quickly figure out where your repo should be created.
 - `-o`/`--open` <Badge text="v2.1+"/> will open this repository in your default application once it has been created.
   You can make this behaviour the default with the [
   `open_new_repo_in_default_app`](../config/features.md#open-new-repo-in-default-app) feature flag.
+- `-f`/`--fork`/`--from` <Badge text="v3.9+"/> create a fork of an existing remote (on supported services) or a copy of
+  an existing remote repository (on unsupported services)
 
 #### Example
 
@@ -110,6 +112,9 @@ gt n --open gh:notheotherben/demo
 
 # Create a new repository but don't create it remotely
 gt n --no-create-remote gh:notheotherben/demo
+
+# Fork a repository
+gt n gh:notheotherben/demo --fork gh:git-fixtures/basic
 ```
 
 ## list <Badge text="v1.0+"/>

flake.nix

@@ -65,12 +65,12 @@
           # we can block the CI if there are issues here, but not
           # prevent downstream consumers from building our crate by itself.
           git-tool-clippy = craneLib.cargoClippy {
-            inherit cargoArtifacts src buildInputs;
+            inherit cargoArtifacts src nativeBuildInputs buildInputs;
             cargoClippyExtraArgs = "--all-targets -- --deny warnings";
           };
 
           git-tool-doc = craneLib.cargoDoc {
-            inherit cargoArtifacts src;
+            inherit cargoArtifacts src nativeBuildInputs buildInputs;
           };
 
           # Check formatting

src/commands/clone.rs

@@ -50,7 +50,7 @@ impl CommandRunnable for CloneCommand {
                 )
             })?;
 
-            let operation = sequence![GitClone {}];
+            let operation = sequence![GitClone::default()];
 
             for line in file.lines() {
                 if line.trim_start().is_empty() || line.trim_start().starts_with('#') {
@@ -69,7 +69,7 @@ impl CommandRunnable for CloneCommand {
             let repo = core.resolver().get_best_repo(&identifier)?;
 
             if !repo.exists() {
-                match sequence![GitClone {}].apply_repo(core, &repo).await {
+                match sequence![GitClone::default()].apply_repo(core, &repo).await {
                     Ok(()) => {}
                     Err(e) => return Err(e),
                 }

src/commands/new.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::engine::Identifier;
 use crate::{engine::features, tasks::*};
 use clap::Arg;
 use tracing_batteries::prelude::*;
@@ -44,6 +45,21 @@ impl CommandRunnable for NewCommand {
                     .help("don't check whether the repository already exists on the remote service before creating a new local repository")
                     .action(clap::ArgAction::SetTrue),
             )
+            .arg(
+                Arg::new("from")
+                    .long("from")
+                    .alias("fork")
+                    .short('f')
+                    .help("create a fork of an existing remote (on supported services) or a copy of an existing remote repository (on unsupported services)"),
+            )
+
+            .arg(
+                Arg::new("fork-all-branches")
+                    .long("fork-all-branches")
+                    .short('A')
+                    .help("when forking from an existing repository, fork all branches (Default: False - default branch only).")
+                    .action(clap::ArgAction::SetTrue),
+            )
     }
 
     #[tracing::instrument(name = "gt new", err, skip(self, core, matches))]
@@ -64,17 +80,43 @@ impl CommandRunnable for NewCommand {
             return Ok(0);
         }
 
-        let tasks = sequence![
-            EnsureNoRemote {
-                enabled: !matches.get_flag("no-check-exists")
-            },
-            GitInit {},
-            GitRemote { name: "origin" },
-            GitCheckout { branch: "main" },
-            CreateRemote {
-                enabled: !matches.get_flag("no-create-remote")
-            }
-        ];
+        let tasks = if let Some(from_repo) = matches.get_one::<String>("from") {
+            let from_repo_id: Identifier = from_repo.as_str().parse()?;
+            let from_repo = core.resolver().get_best_repo(&from_repo_id)?;
+            let from_service = core.config().get_service(&from_repo.service)?;
+            let from_url = from_service.get_git_url(&from_repo)?;
+
+            let target_service = core.config().get_service(&from_repo.service)?;
+            let target_url = target_service.get_git_url(&repo)?;
+
+            sequence![
+                ForkRemote {
+                    from_repo: from_repo.clone(),
+                    default_branch_only: !matches.get_flag("fork-all-branches"),
+                },
+                GitClone::with_url(&from_url),
+                GitAddRemote {
+                    name: "origin".into(),
+                    url: target_url,
+                },
+                GitAddRemote {
+                    name: "upstream".into(),
+                    url: from_url,
+                }
+            ]
+        } else {
+            sequence![
+                EnsureNoRemote {
+                    enabled: !matches.get_flag("no-check-exists")
+                },
+                GitInit {},
+                GitRemote { name: "origin" },
+                GitCheckout { branch: "main" },
+                CreateRemote {
+                    enabled: !matches.get_flag("no-create-remote")
+                }
+            ]
+        };
 
         tasks.apply_repo(core, &repo).await?;
 
@@ -94,6 +136,8 @@ impl CommandRunnable for NewCommand {
     async fn complete(&self, core: &Core, completer: &Completer, _matches: &ArgMatches) {
         completer.offer("--open");
         completer.offer("--no-create-remote");
+        completer.offer("--from");
+
         if let Ok(repos) = core.resolver().get_repos() {
             let mut namespaces = std::collections::HashSet::new();
             let default_svc = core
@@ -117,9 +161,11 @@ impl CommandRunnable for NewCommand {
 
 #[cfg(test)]
 mod tests {
-    use mockall::predicate::eq;
-
     use super::*;
+    use crate::engine::Repo;
+    use mockall::predicate::eq;
+    use rstest::rstest;
+    use tempfile::tempdir;
 
     #[tokio::test]
     async fn run_partial() {
@@ -189,4 +235,84 @@ mod tests {
 
         assert!(repo.valid());
     }
+
+    #[rstest]
+    #[cfg(feature = "auth")]
+    #[case(
+        "gh:git-fixtures/basic",
+        "git-fixtures/basic",
+        "gh:cedi/basic",
+        "cedi/basic"
+    )]
+    #[case(
+        "gh:git-fixtures/basic",
+        "git-fixtures/basic",
+        "gh:SierraSoftworks/basic",
+        "SierraSoftworks/basic"
+    )]
+    #[tokio::test]
+    #[cfg_attr(feature = "pure-tests", ignore)]
+    async fn fork_repo(
+        #[case] source_repo: &str,
+        #[case] source: &str,
+        #[case] target_repo: &str,
+        #[case] target: &str,
+    ) {
+        let cmd = NewCommand {};
+
+        let args = cmd
+            .app()
+            .get_matches_from(vec!["new", target_repo, "--fork", source_repo]);
+
+        let temp = tempdir().unwrap();
+        let temp_path = temp.path().to_path_buf();
+
+        let core = Core::builder()
+            .with_config_for_dev_directory(temp.path())
+            .with_mock_http_client(crate::online::service::github::mocks::repo_fork(source))
+            .with_mock_keychain(|mock| {
+                mock.expect_get_token()
+                    .with(eq("gh"))
+                    .returning(|_| Ok("test_token".into()));
+            })
+            .with_mock_resolver(|mock| {
+                let source_temp_path = temp_path.clone();
+                let source = source.to_owned();
+                let source_segments = source.split('/');
+                let full_source_path = source_segments
+                    .fold(source_temp_path.clone(), |path, segment| path.join(segment));
+                let source_identifier: Identifier = source_repo.parse().unwrap();
+                mock.expect_get_best_repo()
+                    .with(eq(source_identifier))
+                    .times(1)
+                    .returning(move |_| {
+                        Ok(Repo::new("gh:git-fixtures/basic", full_source_path.clone()))
+                    });
+
+                let target_temp_path = temp_path.clone();
+                let target = target.to_owned();
+                let target_segments = target.split('/');
+                let full_target_path = target_segments
+                    .fold(target_temp_path.clone(), |path, segment| path.join(segment));
+                let target_identifier: Identifier = target_repo.parse().unwrap();
+                mock.expect_get_best_repo()
+                    .with(eq(target_identifier))
+                    .times(2)
+                    .returning(move |_| {
+                        Ok(Repo::new("gh:git-fixtures/empty", full_target_path.clone()))
+                    });
+            })
+            .build();
+
+        let repo = core
+            .resolver()
+            .get_best_repo(&target_repo.parse().unwrap())
+            .unwrap();
+
+        assert!(!repo.valid());
+
+        cmd.assert_run_successful(&core, &args).await;
+
+        assert!(repo.valid());
+    }
 }

src/commands/open.rs

@@ -70,7 +70,7 @@ New applications can be configured either by making changes to your configuratio
         };
 
         if !repo.exists() {
-            match sequence![GitClone {}].apply_repo(core, &repo).await {
+            match sequence![GitClone::default()].apply_repo(core, &repo).await {
                 Ok(()) => {}
                 Err(_) if matches.get_flag("create") => {
                     sequence![

src/completion/completer.rs

@@ -167,7 +167,7 @@ mod tests {
     fn test_offer_apps() {
         let console = console::mock();
         let core = Core::builder()
-            .with_config_for_dev_directory(&get_dev_dir())
+            .with_config_for_dev_directory(get_dev_dir())
             .with_console(console.clone())
             .build();
 
@@ -188,7 +188,7 @@ mod tests {
     fn test_offer_namespaces() {
         let console = console::mock();
         let core = Core::builder()
-            .with_config_for_dev_directory(&get_dev_dir())
+            .with_config_for_dev_directory(get_dev_dir())
             .with_console(console.clone())
             .build();
 
@@ -209,7 +209,7 @@ mod tests {
     fn test_offer_repos() {
         let console = console::mock();
         let core = Core::builder()
-            .with_config_for_dev_directory(&get_dev_dir())
+            .with_config_for_dev_directory(get_dev_dir())
             .with_console(console.clone())
             .build();
 

src/engine/features.rs

@@ -5,6 +5,7 @@ pub const CREATE_REMOTE: &str = "create_remote";
 pub const CREATE_REMOTE_PRIVATE: &str = "create_remote_private";
 pub const CHECK_EXISTS: &str = "check_exists";
 pub const MOVE_REMOTE: &str = "move_remote";
+pub const FORK_REMOTE: &str = "fork_remote";
 
 pub const OPEN_NEW_REPO: &str = "open_new_repo_in_default_app";
 pub const ALWAYS_OPEN_BEST_MATCH: &str = "always_open_best_match";
@@ -18,6 +19,7 @@ lazy_static! {
         CREATE_REMOTE_PRIVATE,
         CHECK_EXISTS,
         MOVE_REMOTE,
+        FORK_REMOTE,
         OPEN_NEW_REPO,
         ALWAYS_OPEN_BEST_MATCH,
         TELEMETRY,
@@ -71,6 +73,7 @@ impl FeaturesBuilder {
         self.with(CREATE_REMOTE, true)
             .with(CREATE_REMOTE_PRIVATE, true)
             .with(MOVE_REMOTE, true)
+            .with(FORK_REMOTE, true)
             .with(TELEMETRY, false)
             .with(CHECK_FOR_UPDATES, true)
             .with(CHECK_EXISTS, true)