colocation: rename from "colocated repo" to "colocated workspace"

Colocation is about sharing the working copy between jj and git. It's
less important where the repo is stored. I therefore think we should
not call it "colocated repo". I considered renaming it to "colocated
working copy" but that sounded awkward in many places because we often
talk about the whole workspace (repo + working copy), so "In colocated
workspaces with a very large number of branches or other refs" sounds
better than "In colocated working copies with a very large number of
branches or other refs".

Once we support colocate workspaces in non-main Git worktrees, I think
this rename will be even more relevant because then all those
workspaces share the same repo but only some of them may be colocated.

Author: martinvonz

README.md

@@ -227,7 +227,7 @@ Here is how you can explore a GitHub repository with `jj`.
 <img src="demos/git_compat.png" />
 
 You can even have a [colocated local
-repository](https://jj-vcs.github.io/jj/latest/git-compatibility#colocated-jujutsugit-repos)
+workspace](https://jj-vcs.github.io/jj/latest/git-compatibility#colocated-jujutsugit-repos)
 where you can use both `jj` and `git` commands interchangeably.
 
 ### The working copy is automatically committed

cli/build.rs

@@ -24,7 +24,7 @@ fn main() {
     println!("cargo:rerun-if-env-changed=NIX_JJ_GIT_HASH");
     let git_hash = get_git_hash_from_nix().or_else(|| {
         if Path::new(GIT_HEAD_PATH).exists() {
-            // In colocated repo, .git/HEAD should reflect the working-copy parent.
+            // In colocated workspace, .git/HEAD should reflect the working-copy parent.
             println!("cargo:rerun-if-changed={GIT_HEAD_PATH}");
         } else if Path::new(JJ_OP_HEADS_PATH).exists() {
             // op_heads changes when working-copy files are mutated, which is way more

cli/src/commands/file/untrack.rs

@@ -36,7 +36,7 @@ pub(crate) struct FileUntrackArgs {
     /// Paths to untrack. They must already be ignored.
     ///
     /// The paths could be ignored via a .gitignore or .git/info/exclude (in
-    /// colocated repos).
+    /// colocated workspaces).
     #[arg(
         required = true,
         value_name = "FILESETS",

cli/src/commands/git/clone.rs

@@ -81,7 +81,8 @@ pub struct GitCloneArgs {
     /// operating on the repo. The Git repository that stores most of the repo
     /// data will be hidden inside a sub-directory of the `.jj` directory.
     ///
-    /// See [colocation docs] for some minor advantages of non-colocated repos.
+    /// See [colocation docs] for some minor advantages of non-colocated
+    /// workspaces.
     ///
     /// [colocation docs]:
     ///     https://jj-vcs.github.io/jj/latest/git-compatibility/#colocated-jujutsugit-repos

cli/src/commands/git/colocation.rs

@@ -72,7 +72,7 @@ pub fn cmd_git_colocation(
 /// Check that the repository supports colocation commands
 /// which means that the repo is backed by git, is not
 /// already colocated, and is a main workspace
-fn repo_supports_git_colocation_commands(
+fn workspace_supports_git_colocation_commands(
     workspace_command: &crate::cli_util::WorkspaceCommandHelper,
 ) -> Result<(), CommandError> {
     // Check if backend is Git (will show an error otherwise)
@@ -95,22 +95,22 @@ fn cmd_git_colocation_status(
 ) -> Result<(), CommandError> {
     let workspace_command = command.workspace_helper(ui)?;
 
-    // Make sure that the repository supports git colocation commands
-    repo_supports_git_colocation_commands(&workspace_command)?;
+    // Make sure that the workspace supports git colocation commands
+    workspace_supports_git_colocation_commands(&workspace_command)?;
 
     let is_colocated =
         is_colocated_git_workspace(workspace_command.workspace(), workspace_command.repo());
 
     if is_colocated {
-        writeln!(ui.stdout(), "Repository is currently colocated with Git.")?;
+        writeln!(ui.stdout(), "Workspace is currently colocated with Git.")?;
         writeln!(
             ui.hint_default(),
             "To disable colocation, run: `jj git colocation disable`"
         )?;
     } else {
         writeln!(
             ui.stdout(),
-            "Repository is currently not colocated with Git."
+            "Workspace is currently not colocated with Git."
         )?;
         writeln!(
             ui.hint_default(),
@@ -128,12 +128,12 @@ fn cmd_git_colocation_enable(
 ) -> Result<(), CommandError> {
     let workspace_command = command.workspace_helper(ui)?;
 
-    // Make sure that the repository supports git colocation commands
-    repo_supports_git_colocation_commands(&workspace_command)?;
+    // Make sure that the workspace supports git colocation commands
+    workspace_supports_git_colocation_commands(&workspace_command)?;
 
-    // Then ensure that the repo is not already colocated before proceeding
+    // Then ensure that the workspace is not already colocated before proceeding
     if is_colocated_git_workspace(workspace_command.workspace(), workspace_command.repo()) {
-        writeln!(ui.status(), "Repository is already colocated with Git.")?;
+        writeln!(ui.status(), "Workspace is already colocated with Git.")?;
         return Ok(());
     }
 
@@ -156,7 +156,7 @@ fn cmd_git_colocation_enable(
             user_error("A .git directory already exists in the workspace root. Cannot colocate.")
         }
         _ => user_error_with_message(
-            "Failed to move Git repository from .jj/repo/store/git to repository root directory.",
+            "Failed to move Git repository from .jj/repo/store/git to workspace root directory.",
             err,
         ),
     })?;
@@ -181,7 +181,7 @@ fn cmd_git_colocation_enable(
 
     writeln!(
         ui.status(),
-        "Repository successfully converted into a colocated Jujutsu/Git repository."
+        "Workspace successfully converted into a colocated Jujutsu/Git workspace."
     )?;
 
     Ok(())
@@ -195,11 +195,11 @@ fn cmd_git_colocation_disable(
     let workspace_command = command.workspace_helper(ui)?;
 
     // Make sure that the repository supports git colocation commands
-    repo_supports_git_colocation_commands(&workspace_command)?;
+    workspace_supports_git_colocation_commands(&workspace_command)?;
 
     // Then ensure that the repo is colocated before proceeding
     if !is_colocated_git_workspace(workspace_command.workspace(), workspace_command.repo()) {
-        writeln!(ui.status(), "Repository is already not colocated with Git.")?;
+        writeln!(ui.status(), "Workspace is already not colocated with Git.")?;
         return Ok(());
     }
 
@@ -236,7 +236,7 @@ fn cmd_git_colocation_disable(
 
     writeln!(
         ui.status(),
-        "Repository successfully converted into a non-colocated Jujutsu/Git repository."
+        "Workspace successfully converted into a non-colocated Jujutsu/Git workspace."
     )?;
 
     Ok(())

cli/src/commands/git/export.rs

@@ -21,8 +21,8 @@ use crate::ui::Ui;
 
 /// Update the underlying Git repo with changes made in the repo
 ///
-/// There is no need to run this command if you're in colocated repo because the
-/// export happens automatically there.
+/// There is no need to run this command if you're in colocated workspace
+/// because the export happens automatically there.
 #[derive(clap::Args, Clone, Debug)]
 pub struct GitExportArgs {}
 

cli/src/commands/git/import.rs

@@ -24,8 +24,8 @@ use crate::ui::Ui;
 /// If a working-copy commit gets abandoned, it will be given a new, empty
 /// commit. This is true in general; it is not specific to this command.
 ///
-/// There is no need to run this command if you're in colocated repo because the
-/// import happens automatically there.
+/// There is no need to run this command if you're in colocated workspace
+/// because the import happens automatically there.
 #[derive(clap::Args, Clone, Debug)]
 pub struct GitImportArgs {}
 
@@ -37,7 +37,7 @@ pub fn cmd_git_import(
     let mut workspace_command = command.workspace_helper(ui)?;
     let git_settings = workspace_command.settings().git_settings()?;
     let mut tx = workspace_command.start_transaction();
-    // In non-colocated repo, Git HEAD will never be moved internally by jj.
+    // In non-colocated workspace, Git HEAD will never be moved internally by jj.
     // That's why cmd_git_export() doesn't export the HEAD ref.
     git::import_head(tx.repo_mut())?;
     let stats = git::import_refs(tx.repo_mut(), &git_settings)?;

cli/src/commands/git/init.rs

@@ -80,7 +80,8 @@ pub struct GitInitArgs {
     /// operating on the repo. The Git repository that stores most of the repo
     /// data will be hidden inside a sub-directory of the `.jj` directory.
     ///
-    /// See [colocation docs] for some minor advantages of non-colocated repos.
+    /// See [colocation docs] for some minor advantages of non-colocated
+    /// workspaces.
     ///
     /// [colocation docs]:
     ///     https://jj-vcs.github.io/jj/latest/git-compatibility/#colocated-jujutsugit-repos
@@ -93,7 +94,7 @@ pub struct GitInitArgs {
     /// If the specified `--git-repo` path happens to be the same as
     /// the `jj` repo path (both .jj and .git directories are in the
     /// same working directory), then both `jj` and `git` commands
-    /// will work on the same repo. This is called a colocated repo.
+    /// will work on the same repo. This is called a colocated workspace.
     ///
     /// This option is mutually exclusive with `--colocate`.
     #[arg(long, conflicts_with = "colocate", value_hint = clap::ValueHint::DirPath)]

cli/tests/[email protected]

@@ -1156,7 +1156,7 @@ Stop tracking specified paths in the working copy
 
 * `<FILESETS>` — Paths to untrack. They must already be ignored.
 
-   The paths could be ignored via a .gitignore or .git/info/exclude (in colocated repos).
+   The paths could be ignored via a .gitignore or .git/info/exclude (in colocated workspaces).
 
 
 
@@ -1331,7 +1331,7 @@ Create a new repo backed by a clone of a Git repo
 
    Prevent Git tools that are unaware of `jj` and regular Git commands from operating on the repo. The Git repository that stores most of the repo data will be hidden inside a sub-directory of the `.jj` directory.
 
-   See [colocation docs] for some minor advantages of non-colocated repos.
+   See [colocation docs] for some minor advantages of non-colocated workspaces.
 
    [colocation docs]: https://jj-vcs.github.io/jj/latest/git-compatibility/#colocated-jujutsugit-repos
 * `--depth <DEPTH>` — Create a shallow clone of the given depth
@@ -1401,7 +1401,7 @@ Show the current colocation status
 
 Update the underlying Git repo with changes made in the repo
 
-There is no need to run this command if you're in colocated repo because the export happens automatically there.
+There is no need to run this command if you're in colocated workspace because the export happens automatically there.
 
 **Usage:** `jj git export`
 
@@ -1440,7 +1440,7 @@ Update repo with changes made in the underlying Git repo
 
 If a working-copy commit gets abandoned, it will be given a new, empty commit. This is true in general; it is not specific to this command.
 
-There is no need to run this command if you're in colocated repo because the import happens automatically there.
+There is no need to run this command if you're in colocated workspace because the import happens automatically there.
 
 **Usage:** `jj git import`
 
@@ -1477,12 +1477,12 @@ Create a new Git backed repo
 
    Prevent Git tools that are unaware of `jj` and regular Git commands from operating on the repo. The Git repository that stores most of the repo data will be hidden inside a sub-directory of the `.jj` directory.
 
-   See [colocation docs] for some minor advantages of non-colocated repos.
+   See [colocation docs] for some minor advantages of non-colocated workspaces.
 
    [colocation docs]: https://jj-vcs.github.io/jj/latest/git-compatibility/#colocated-jujutsugit-repos
 * `--git-repo <GIT_REPO>` — Specifies a path to an **existing** git repository to be used as the backing git repo for the newly created `jj` repo.
 
-   If the specified `--git-repo` path happens to be the same as the `jj` repo path (both .jj and .git directories are in the same working directory), then both `jj` and `git` commands will work on the same repo. This is called a colocated repo.
+   If the specified `--git-repo` path happens to be the same as the `jj` repo path (both .jj and .git directories are in the same working directory), then both `jj` and `git` commands will work on the same repo. This is called a colocated workspace.
 
    This option is mutually exclusive with `--colocate`.
 

cli/tests/common/test_environment.rs

@@ -63,7 +63,7 @@ impl Default for TestEnvironment {
             command_number: RefCell::new(0),
         };
         // Use absolute timestamps in the operation log to make tests independent of the
-        // current time. Use non-colocated repos by default for simplicity.
+        // current time. Use non-colocated workspaces by default for simplicity.
         env.add_config(
             r#"
 [template-aliases]