generate devpkg.Package from Config

Author: savil

internal/devconfig/packages.go

@@ -36,11 +36,7 @@ type Packages struct {
 func (pkgs *Packages) VersionedNames() []string {
 	result := make([]string, 0, len(pkgs.Collection))
 	for _, p := range pkgs.Collection {
-		name := p.name
-		if p.Version != "" {
-			name += "@" + p.Version
-		}
-		result = append(result, name)
+		result = append(result, p.VersionedName())
 	}
 	return result
 }
@@ -159,6 +155,19 @@ func NewPackage(name string, values map[string]any) Package {
 	}
 }
 
+func (p *Package) VersionedName() string {
+	name := p.name
+	if p.Version != "" {
+		name += "@" + p.Version
+	}
+	return name
+}
+
+func (p *Package) IsEnabledOnPlatform() (bool, error) {
+	// TODO savil. Next PR will update this implementation
+	return true, nil
+}
+
 func (p *Package) UnmarshalJSON(data []byte) error {
 	// First, attempt to unmarshal as a version-only string
 	var version string

internal/devpkg/package.go

@@ -18,6 +18,7 @@ import (
 	"go.jetpack.io/devbox/internal/boxcli/featureflag"
 	"go.jetpack.io/devbox/internal/boxcli/usererr"
 	"go.jetpack.io/devbox/internal/cuecfg"
+	"go.jetpack.io/devbox/internal/devconfig"
 	"go.jetpack.io/devbox/internal/lock"
 	"go.jetpack.io/devbox/internal/nix"
 	"go.jetpack.io/devbox/internal/vercheck"
@@ -46,6 +47,9 @@ type Package struct {
 	//    example: github:nixos/nixpkgs/5233fd2ba76a3accb5aaa999c00509a11fd0793c#hello
 	Raw string
 
+	// isInstallable is true if the package is may be enabled on the current platform.
+	isInstallable bool
+
 	normalizedPackageAttributePathCache string // memoized value from normalizedPackageAttributePath()
 }
 
@@ -59,9 +63,26 @@ func PackageFromStrings(rawNames []string, l lock.Locker) []*Package {
 	return packages
 }
 
+func PackagesFromConfig(config *devconfig.Config, l lock.Locker) ([]*Package, error) {
+	result := []*Package{}
+	for _, pkg := range config.Packages.Collection {
+		isInstallable, err := pkg.IsEnabledOnPlatform()
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, newPackage(pkg.VersionedName(), isInstallable, l))
+	}
+	return result, nil
+}
+
 // PackageFromString constructs Package from the raw name provided.
 // The raw name corresponds to a devbox package from the devbox.json config.
 func PackageFromString(raw string, locker lock.Locker) *Package {
+	// For now, assume packages are installable by default
+	return newPackage(raw, true /*isInstallable*/, locker)
+}
+
+func newPackage(raw string, isInstallable bool, locker lock.Locker) *Package {
 	// TODO: We should handle this error
 	// TODO: URL might not be best representation since most packages are not urls
 	pkgURL, _ := url.Parse(raw)
@@ -79,7 +100,7 @@ func PackageFromString(raw string, locker lock.Locker) *Package {
 		pkgURL, _ = url.Parse(normalizedURL)
 	}
 
-	return &Package{URL: *pkgURL, lockfile: locker, Raw: raw}
+	return &Package{URL: *pkgURL, lockfile: locker, Raw: raw, isInstallable: isInstallable}
 }
 
 // isLocal specifies whether this package is a local flake.
@@ -146,6 +167,12 @@ func (p *Package) URLForFlakeInput() string {
 	return p.urlWithoutFragment()
 }
 
+// IsInstallable returns whether this package is installable. Not to be confused
+// with the Installable() method which returns the corresponding nix concept.
+func (p *Package) IsInstallable() bool {
+	return p.isInstallable
+}
+
 // Installable for this package. Installable is a nix concept defined here:
 // https://nixos.org/manual/nix/stable/command-ref/new-cli/nix.html#installables
 func (p *Package) Installable() (string, error) {

internal/impl/devbox.go

@@ -110,9 +110,14 @@ func Open(opts *devopt.Opts) (*Devbox, error) {
 	)
 	box.lockfile = lock
 
+	hasDeprecated, err := box.HasDeprecatedPackages()
+	if err != nil {
+		return nil, err
+	}
+
 	if !opts.IgnoreWarnings &&
 		!legacyPackagesWarningHasBeenShown &&
-		box.HasDeprecatedPackages() {
+		hasDeprecated {
 		legacyPackagesWarningHasBeenShown = true
 		globalPath, err := GlobalDataPath()
 		if err != nil {
@@ -138,7 +143,11 @@ func (d *Devbox) Config() *devconfig.Config {
 }
 
 func (d *Devbox) ConfigHash() (string, error) {
-	pkgHashes := lo.Map(d.ConfigPackages(), func(i *devpkg.Package, _ int) string { return i.Hash() })
+	pkgs, err := d.ConfigPackages()
+	if err != nil {
+		return "", err
+	}
+	pkgHashes := lo.Map(pkgs, func(i *devpkg.Package, _ int) string { return i.Hash() })
 	includeHashes := lo.Map(d.Includes(), func(i plugin.Includable, _ int) string { return i.Hash() })
 	h, err := d.cfg.Hash()
 	if err != nil {
@@ -934,28 +943,35 @@ func (d *Devbox) nixFlakesFilePath() string {
 
 // ConfigPackageNames returns the package names as defined in devbox.json
 func (d *Devbox) ConfigPackageNames() []string {
+	// TODO savil: centralize implementation by calling d.ConfigPackages and getting pkg.Raw
 	return d.cfg.Packages.VersionedNames()
 }
 
 // InstallablePackageNames returns the names of packages that are to be installed
 func (d *Devbox) InstallablePackageNames() ([]string, error) {
-	// TODO: next PR replaces this implementation
+	// TODO savil. centralize implementation by calling d.InstallablePackages and getting pkg.Raw
 	return d.cfg.Packages.VersionedNamesForPlatform()
 }
 
 // ConfigPackages returns the packages that are defined in devbox.json
 // NOTE: the return type is different from devconfig.Packages
-func (d *Devbox) ConfigPackages() []*devpkg.Package {
-	return devpkg.PackageFromStrings(d.ConfigPackageNames(), d.lockfile)
+func (d *Devbox) ConfigPackages() ([]*devpkg.Package, error) {
+	pkgs, err := devpkg.PackagesFromConfig(d.cfg, d.lockfile)
+	if err != nil {
+		return nil, err
+	}
+	return pkgs, nil
 }
 
 // InstallablePackages returns the packages that are to be installed
 func (d *Devbox) InstallablePackages() ([]*devpkg.Package, error) {
-	names, err := d.InstallablePackageNames()
+	pkgs, err := d.ConfigPackages()
 	if err != nil {
 		return nil, err
 	}
-	return devpkg.PackageFromStrings(names, d.lockfile), nil
+	return lo.Filter(pkgs, func(pkg *devpkg.Package, _ int) bool {
+		return pkg.IsInstallable()
+	}), nil
 }
 
 func (d *Devbox) Includes() []plugin.Includable {
@@ -968,21 +984,28 @@ func (d *Devbox) Includes() []plugin.Includable {
 	return includes
 }
 
-func (d *Devbox) HasDeprecatedPackages() bool {
-	for _, pkg := range d.ConfigPackages() {
+func (d *Devbox) HasDeprecatedPackages() (bool, error) {
+	pkgs, err := d.ConfigPackages()
+	if err != nil {
+		return false, err
+	}
+	for _, pkg := range pkgs {
 		if pkg.IsLegacy() {
-			return true
+			return true, nil
 		}
 	}
-	return false
+	return false, nil
 }
 
 func (d *Devbox) findPackageByName(name string) (string, error) {
+	pkgs, err := d.ConfigPackages()
+	if err != nil {
+		return "", err
+	}
 	results := map[string]bool{}
-	for _, pkg := range d.ConfigPackageNames() {
-		i := devpkg.PackageFromString(pkg, d.lockfile)
-		if i.String() == name || i.CanonicalName() == name {
-			results[i.String()] = true
+	for _, pkg := range pkgs {
+		if pkg.String() == name || pkg.CanonicalName() == name {
+			results[pkg.String()] = true
 		}
 	}
 	if len(results) > 1 {