devpkg: better flake installable parsing

Add a `ParseFlakeInstallable` to parse Nix flake installables. An
installable is a superset of a flake reference. It allows an attribute
path and/or outputs to be specified using the `flake#attrpath^outputs`
syntax.

Author: gcurtis

internal/devpkg/flakeref.go

@@ -259,3 +259,98 @@ func isArchive(path string) bool {
 		strings.HasSuffix(path, ".tar.bz2") ||
 		strings.HasSuffix(path, ".zip")
 }
+
+// FlakeInstallable is a Nix command line argument that specifies how to install
+// a flake. It can be a plain flake reference, or a flake reference with an
+// attribute path and/or output specification.
+//
+// Some examples are:
+//
+//   - "." installs the default attribute from the flake in the current
+//     directory.
+//   - ".#hello" installs the hello attribute from the flake in the current
+//     directory.
+//   - "nixpkgs#hello" installs the hello attribute from the nixpkgs flake.
+//   - "github:NixOS/nixpkgs/unstable#curl^lib" installs the the lib output of
+//     curl attribute from the flake on the nixpkgs unstable branch.
+//
+// The flake installable syntax is only valid in Nix command line arguments, not
+// in Nix expressions. See FlakeRef and the [Nix manual for details on the
+// differences between flake references and installables.
+//
+// [Nix manual]: https://nixos.org/manual/nix/unstable/command-ref/new-cli/nix#installables
+type FlakeInstallable struct {
+	Ref      FlakeRef
+	AttrPath string
+	Outputs  []string
+
+	raw string
+}
+
+// ParseFlakeInstallable parses a flake installable. The string s must contain a
+// valid flake reference parsable by ParseFlakeRef, optionally followed by an
+// #attrpath and/or an ^output.
+func ParseFlakeInstallable(raw string) (FlakeInstallable, error) {
+	if raw == "" {
+		return FlakeInstallable{}, redact.Errorf("empty flake installable")
+	}
+
+	// The output spec must be parsed and removed first, otherwise it will
+	// be parsed as part of the flakeref's URL fragment.
+	install := FlakeInstallable{raw: raw}
+	before, after := splitOutputSpec(raw)
+	if after != "" {
+		install.Outputs = strings.Split(after, ",")
+	}
+	raw = before
+
+	// Interpret installables with path-style flakerefs as URLs to extract
+	// the attribute path (fragment). This means that path-style flakerefs
+	// cannot point to files with a '#' or '?' in their name, since those
+	// would be parsed as the URL fragment or query string. This mimic's
+	// Nix's CLI behavior.
+	prefix := ""
+	if raw[0] == '.' || raw[0] == '/' {
+		prefix = "path:"
+		raw = prefix + raw
+	}
+
+	var err error
+	install.Ref, install.AttrPath, err = parseFlakeURLRef(raw)
+	if err != nil {
+		return FlakeInstallable{}, err
+	}
+	// Make sure to reset the raw flakeref to the original string
+	// after parsing.
+	install.Ref.raw = raw[len(prefix):]
+	return install, nil
+}
+
+// AllOutputs returns true if the installable specifies all outputs with the
+// "^*" syntax.
+func (f FlakeInstallable) AllOutputs() bool {
+	for _, out := range f.Outputs {
+		if out == "*" {
+			return true
+		}
+	}
+	return false
+}
+
+// DefaultOutputs returns true if the installable does not specify any outputs.
+func (f FlakeInstallable) DefaultOutputs() bool {
+	return len(f.Outputs) == 0
+}
+
+// String returns the raw installable string as given to ParseFlakeInstallable.
+func (f FlakeInstallable) String() string {
+	return f.raw
+}
+
+// splitOutputSpec cuts a flake installable around the last instance of ^.
+func splitOutputSpec(s string) (before, after string) {
+	if i := strings.LastIndexByte(s, '^'); i >= 0 {
+		return s[:i], s[i+1:]
+	}
+	return s, ""
+}

internal/devpkg/flakeref_test.go

@@ -164,3 +164,92 @@ func TestParseFlakeRef(t *testing.T) {
 		})
 	}
 }
+
+func TestParseFlakeInstallable(t *testing.T) {
+	cases := map[string]FlakeInstallable{
+		// Empty string is not a valid installable.
+		"": {},
+
+		// Not a path and not a valid URL.
+		"://bad/url": {},
+
+		".":             {Ref: FlakeRef{Type: "path", Path: "."}},
+		".#app":         {AttrPath: "app", Ref: FlakeRef{Type: "path", Path: "."}},
+		".#app^out":     {AttrPath: "app", Outputs: []string{"out"}, Ref: FlakeRef{Type: "path", Path: "."}},
+		".#app^out,lib": {AttrPath: "app", Outputs: []string{"out", "lib"}, Ref: FlakeRef{Type: "path", Path: "."}},
+		".#app^*":       {AttrPath: "app", Outputs: []string{"*"}, Ref: FlakeRef{Type: "path", Path: "."}},
+		".^*":           {Outputs: []string{"*"}, Ref: FlakeRef{Type: "path", Path: "."}},
+
+		"./flake":             {Ref: FlakeRef{Type: "path", Path: "./flake"}},
+		"./flake#app":         {AttrPath: "app", Ref: FlakeRef{Type: "path", Path: "./flake"}},
+		"./flake#app^out":     {AttrPath: "app", Outputs: []string{"out"}, Ref: FlakeRef{Type: "path", Path: "./flake"}},
+		"./flake#app^out,lib": {AttrPath: "app", Outputs: []string{"out", "lib"}, Ref: FlakeRef{Type: "path", Path: "./flake"}},
+		"./flake^out":         {Outputs: []string{"out"}, Ref: FlakeRef{Type: "path", Path: "./flake"}},
+
+		"indirect":            {Ref: FlakeRef{Type: "indirect", ID: "indirect"}},
+		"nixpkgs#app":         {AttrPath: "app", Ref: FlakeRef{Type: "indirect", ID: "nixpkgs"}},
+		"nixpkgs#app^out":     {AttrPath: "app", Outputs: []string{"out"}, Ref: FlakeRef{Type: "indirect", ID: "nixpkgs"}},
+		"nixpkgs#app^out,lib": {AttrPath: "app", Outputs: []string{"out", "lib"}, Ref: FlakeRef{Type: "indirect", ID: "nixpkgs"}},
+		"nixpkgs^out":         {Outputs: []string{"out"}, Ref: FlakeRef{Type: "indirect", ID: "nixpkgs"}},
+
+		"%23#app":                        {AttrPath: "app", Ref: FlakeRef{Type: "indirect", ID: "#"}},
+		"./%23#app":                      {AttrPath: "app", Ref: FlakeRef{Type: "path", Path: "./#"}},
+		"/%23#app":                       {AttrPath: "app", Ref: FlakeRef{Type: "path", Path: "/#"}},
+		"path:/%23#app":                  {AttrPath: "app", Ref: FlakeRef{Type: "path", Path: "/#"}},
+		"http://example.com/%23.tar#app": {AttrPath: "app", Ref: FlakeRef{Type: "tarball", URL: "http://example.com/%23.tar#app"}},
+	}
+
+	for installable, want := range cases {
+		t.Run(installable, func(t *testing.T) {
+			got, err := ParseFlakeInstallable(installable)
+			if diff := cmp.Diff(want, got, cmpopts.IgnoreUnexported(FlakeRef{}, FlakeInstallable{})); diff != "" {
+				if err != nil {
+					t.Errorf("got error: %s", err)
+				}
+				t.Errorf("wrong installable (-want +got):\n%s", diff)
+			}
+			if err != nil {
+				return
+			}
+			if installable != got.String() {
+				t.Errorf("got.String() = %q != %q", got, installable)
+			}
+		})
+	}
+}
+
+func TestFlakeInstallableDefaultOutputs(t *testing.T) {
+	install := FlakeInstallable{Outputs: nil}
+	if !install.DefaultOutputs() {
+		t.Errorf("DefaultOutputs() = false for nil outputs slice, want true")
+	}
+
+	install = FlakeInstallable{Outputs: []string{}}
+	if !install.DefaultOutputs() {
+		t.Errorf("DefaultOutputs() = false for empty outputs slice, want true")
+	}
+
+	install = FlakeInstallable{Outputs: []string{"out"}}
+	if install.DefaultOutputs() {
+		t.Errorf("DefaultOutputs() = true for %v, want false", install.Outputs)
+	}
+}
+
+func TestFlakeInstallableAllOutputs(t *testing.T) {
+	install := FlakeInstallable{Outputs: []string{"*"}}
+	if !install.AllOutputs() {
+		t.Errorf("AllOutputs() = false for %v, want true", install.Outputs)
+	}
+	install = FlakeInstallable{Outputs: []string{"out", "*"}}
+	if !install.AllOutputs() {
+		t.Errorf("AllOutputs() = false for %v, want true", install.Outputs)
+	}
+	install = FlakeInstallable{Outputs: nil}
+	if install.AllOutputs() {
+		t.Errorf("AllOutputs() = true for nil outputs slice, want false")
+	}
+	install = FlakeInstallable{Outputs: []string{}}
+	if install.AllOutputs() {
+		t.Errorf("AllOutputs() = true for empty outputs slice, want false")
+	}
+}