[Renaming] ComputeNixEnv -> ComputeDevboxEnv; ensurePackagesAreInstalled -> ensureProjectStateIsCurrent

Author: savil

internal/impl/devbox.go

@@ -260,7 +260,7 @@ func (d *Devbox) Install(ctx context.Context) error {
 	ctx, task := trace.NewTask(ctx, "devboxInstall")
 	defer task.End()
 
-	return d.ensurePackagesAreInstalled(ctx, ensure)
+	return d.ensureProjectStateIsCurrent(ctx, ensure)
 }
 
 func (d *Devbox) ListScripts() []string {
@@ -295,7 +295,7 @@ func (d *Devbox) NixEnv(ctx context.Context, opts devopt.NixEnvOpts) (string, er
 			)
 		}
 
-		envs, err = d.computeNixEnv(ctx, true /*usePrintDevEnvCache*/)
+		envs, err = d.computeDevboxEnv(ctx, true /*usePrintDevEnvCache*/)
 	} else {
 		envs, err = d.ensurePackagesAreInstalledAndComputeEnv(ctx)
 	}
@@ -482,7 +482,7 @@ func (d *Devbox) GenerateEnvrcFile(ctx context.Context, force bool, envFlags dev
 	}
 
 	// generate all shell files to ensure we can refer to them in the .envrc script
-	if err := d.ensurePackagesAreInstalled(ctx, ensure); err != nil {
+	if err := d.ensureProjectStateIsCurrent(ctx, ensure); err != nil {
 		return err
 	}
 
@@ -754,7 +754,7 @@ func (d *Devbox) StartProcessManager(
 	)
 }
 
-// computeNixEnv computes the set of environment variables that define a Devbox
+// computeDevboxEnv computes the set of environment variables that define a Devbox
 // environment. The "devbox run" and "devbox shell" commands source these
 // variables into a shell before executing a command or showing an interactive
 // prompt.
@@ -778,11 +778,10 @@ func (d *Devbox) StartProcessManager(
 // programs.
 //
 // Note that the shellrc.tmpl template (which sources this environment) does
-// some additional processing. The computeNixEnv environment won't necessarily
+// some additional processing. The computeDevboxEnv environment won't necessarily
 // represent the final "devbox run" or "devbox shell" environments.
-// TODO: Rename to computeDevboxEnv?
-func (d *Devbox) computeNixEnv(ctx context.Context, usePrintDevEnvCache bool) (map[string]string, error) {
-	defer trace.StartRegion(ctx, "computeNixEnv").End()
+func (d *Devbox) computeDevboxEnv(ctx context.Context, usePrintDevEnvCache bool) (map[string]string, error) {
+	defer trace.StartRegion(ctx, "computeDevboxEnv").End()
 
 	// Append variables from current env if --pure is not passed
 	currentEnv := os.Environ()
@@ -966,17 +965,17 @@ func (d *Devbox) ensurePackagesAreInstalledAndComputeEnv(
 
 	// When ensurePackagesAreInstalled is called with ensure=true, it always
 	// returns early if the lockfile is up to date. So we don't need to check here
-	if err := d.ensurePackagesAreInstalled(ctx, ensure); err != nil && !strings.Contains(err.Error(), "no such host") {
+	if err := d.ensureProjectStateIsCurrent(ctx, ensure); err != nil && !strings.Contains(err.Error(), "no such host") {
 		return nil, err
 	} else if err != nil {
 		ux.Fwarning(d.stderr, "Error connecting to the internet. Will attempt to use cached environment.\n")
 	}
 
-	// Since ensurePackagesAreInstalled calls computeNixEnv when not up do date,
+	// Since ensurePackagesAreInstalled calls computeDevboxEnv when not up do date,
 	// it's ok to use usePrintDevEnvCache=true here always. This does end up
 	// doing some non-nix work twice if lockfile is not up to date.
 	// TODO: Improve this to avoid extra work.
-	return d.computeNixEnv(ctx, true /*usePrintDevEnvCache*/)
+	return d.computeDevboxEnv(ctx, true /*usePrintDevEnvCache*/)
 }
 
 func (d *Devbox) nixPrintDevEnvCachePath() string {

internal/impl/devbox_test.go

@@ -67,21 +67,21 @@ func (n *testNix) PrintDevEnv(ctx context.Context, args *nix.PrintDevEnvArgs) (*
 	}, nil
 }
 
-func TestComputeNixEnv(t *testing.T) {
+func TestComputeDevboxEnv(t *testing.T) {
 	d := devboxForTesting(t)
 	d.nix = &testNix{}
 	ctx := context.Background()
-	env, err := d.computeNixEnv(ctx, false /*use cache*/)
-	require.NoError(t, err, "computeNixEnv should not fail")
-	assert.NotNil(t, env, "computeNixEnv should return a valid env")
+	env, err := d.computeDevboxEnv(ctx, false /*use cache*/)
+	require.NoError(t, err, "computeDevboxEnv should not fail")
+	assert.NotNil(t, env, "computeDevboxEnv should return a valid env")
 }
 
-func TestComputeNixPathIsIdempotent(t *testing.T) {
+func TestComputeDevboxPathIsIdempotent(t *testing.T) {
 	devbox := devboxForTesting(t)
 	devbox.nix = &testNix{"/tmp/my/path"}
 	ctx := context.Background()
-	env, err := devbox.computeNixEnv(ctx, false /*use cache*/)
-	require.NoError(t, err, "computeNixEnv should not fail")
+	env, err := devbox.computeDevboxEnv(ctx, false /*use cache*/)
+	require.NoError(t, err, "computeDevboxEnv should not fail")
 	path := env["PATH"]
 	assert.NotEmpty(t, path, "path should not be nil")
 
@@ -90,19 +90,19 @@ func TestComputeNixPathIsIdempotent(t *testing.T) {
 	t.Setenv(envpath.PathStackEnv, env[envpath.PathStackEnv])
 	t.Setenv(envpath.Key(devbox.projectDirHash()), env[envpath.Key(devbox.projectDirHash())])
 
-	env, err = devbox.computeNixEnv(ctx, false /*use cache*/)
-	require.NoError(t, err, "computeNixEnv should not fail")
+	env, err = devbox.computeDevboxEnv(ctx, false /*use cache*/)
+	require.NoError(t, err, "computeDevboxEnv should not fail")
 	path2 := env["PATH"]
 
 	assert.Equal(t, path, path2, "path should be the same")
 }
 
-func TestComputeNixPathWhenRemoving(t *testing.T) {
+func TestComputeDevboxPathWhenRemoving(t *testing.T) {
 	devbox := devboxForTesting(t)
 	devbox.nix = &testNix{"/tmp/my/path"}
 	ctx := context.Background()
-	env, err := devbox.computeNixEnv(ctx, false /*use cache*/)
-	require.NoError(t, err, "computeNixEnv should not fail")
+	env, err := devbox.computeDevboxEnv(ctx, false /*use cache*/)
+	require.NoError(t, err, "computeDevboxEnv should not fail")
 	path := env["PATH"]
 	assert.NotEmpty(t, path, "path should not be nil")
 	assert.Contains(t, path, "/tmp/my/path", "path should contain /tmp/my/path")
@@ -113,8 +113,8 @@ func TestComputeNixPathWhenRemoving(t *testing.T) {
 	t.Setenv(envpath.Key(devbox.projectDirHash()), env[envpath.Key(devbox.projectDirHash())])
 
 	devbox.nix.(*testNix).path = ""
-	env, err = devbox.computeNixEnv(ctx, false /*use cache*/)
-	require.NoError(t, err, "computeNixEnv should not fail")
+	env, err = devbox.computeDevboxEnv(ctx, false /*use cache*/)
+	require.NoError(t, err, "computeDevboxEnv should not fail")
 	path2 := env["PATH"]
 	assert.NotContains(t, path2, "/tmp/my/path", "path should not contain /tmp/my/path")
 

internal/impl/packages.go

@@ -98,12 +98,12 @@ func (d *Devbox) Add(ctx context.Context, pkgsNames []string, opts devopt.AddOpt
 		addedPackageNames = append(addedPackageNames, packageNameForConfig)
 	}
 
-	// Options must be set before ensurePackagesAreInstalled. See comment in function
+	// Options must be set before ensureProjectStateIsCurrent. See comment in function
 	if err := d.setPackageOptions(addedPackageNames, opts); err != nil {
 		return err
 	}
 
-	if err := d.ensurePackagesAreInstalled(ctx, install); err != nil {
+	if err := d.ensureProjectStateIsCurrent(ctx, install); err != nil {
 		return usererr.WithUserMessage(err, "There was an error installing nix packages")
 	}
 
@@ -135,7 +135,7 @@ func (d *Devbox) setPackageOptions(pkgs []string, opts devopt.AddOpts) error {
 		}
 	}
 
-	// Resolving here ensures we allow insecure before running ensurePackagesAreInstalled
+	// Resolving here ensures we allow insecure before running ensureProjectStateIsCurrent
 	// which will call print-dev-env. Resolving does not save the lockfile, we
 	// save at the end when everything has succeeded.
 	if opts.AllowInsecure {
@@ -218,14 +218,14 @@ func (d *Devbox) Remove(ctx context.Context, pkgs ...string) error {
 	}
 
 	// this will clean up the now-extra package from nix profile and the lockfile
-	if err := d.ensurePackagesAreInstalled(ctx, uninstall); err != nil {
+	if err := d.ensureProjectStateIsCurrent(ctx, uninstall); err != nil {
 		return err
 	}
 
 	return d.saveCfg()
 }
 
-// installMode is an enum for helping with ensurePackagesAreInstalled implementation
+// installMode is an enum for helping with ensureProjectStateIsCurrent implementation
 type installMode string
 
 const (
@@ -236,19 +236,18 @@ const (
 	ensure installMode = "ensure"
 )
 
-// ensurePackagesAreInstalled ensures:
+// ensureProjectStateIsCurrent ensures:
 //  1. Packages are installed, in nix-profile or runx.
 //     Extraneous packages are removed (references purged, not uninstalled).
-//  2. Files for devbox shellenv are generated
-//  3. Env-vars for shellenv are computed
+//  2. Plugins are installed
+//  3. Files for devbox shellenv are generated
 //  4. Lockfile is synced
 //
 // The `mode` is used for:
 // 1. Skipping certain operations that may not apply.
 // 2. User messaging to explain what operations are happening, because this function may take time to execute.
-// TODO: Rename method since it does more than just ensure packages are installed.
-func (d *Devbox) ensurePackagesAreInstalled(ctx context.Context, mode installMode) error {
-	defer trace.StartRegion(ctx, "ensurePackages").End()
+func (d *Devbox) ensureProjectStateIsCurrent(ctx context.Context, mode installMode) error {
+	defer trace.StartRegion(ctx, "ensureProjectStateIsCurrent").End()
 	defer debug.FunctionTimer().End()
 
 	// if mode is install or uninstall, then we need to update the nix-profile
@@ -292,7 +291,7 @@ func (d *Devbox) ensurePackagesAreInstalled(ctx context.Context, mode installMod
 	// Use the printDevEnvCache if we are adding or removing or updating any package,
 	// AND we are not in the shellenv-enabled environment of the current devbox-project.
 	usePrintDevEnvCache := mode != ensure && !d.IsEnvEnabled()
-	if _, err := d.computeNixEnv(ctx, usePrintDevEnvCache); err != nil {
+	if _, err := d.computeDevboxEnv(ctx, usePrintDevEnvCache); err != nil {
 		return err
 	}
 

internal/impl/update.go

@@ -65,7 +65,7 @@ func (d *Devbox) Update(ctx context.Context, opts devopt.UpdateOpts) error {
 		}
 	}
 
-	if err := d.ensurePackagesAreInstalled(ctx, update); err != nil {
+	if err := d.ensureProjectStateIsCurrent(ctx, update); err != nil {
 		return err
 	}