internal/frontend: redirect to module/directory view on exact search match

When a user searches for a path that exactly matches a package, module
or directory, it will redirect to one of those views in that order.

See golang/go#36803 for context.

Change-Id: Ib0630b8357643b17dc834977a38db3cae52c0c1e
Reviewed-on: https://team-review.git.corp.google.com/c/golang/discovery/+/650122
CI-Result: Cloud Build <[email protected]>
Reviewed-by: Jonathan Amsterdam <[email protected]>

Author: julieqiu

internal/frontend/search.go

@@ -110,14 +110,9 @@ func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if strings.Contains(query, "/") {
-		pkg, err := s.ds.GetPackage(ctx, path.Clean(query), internal.UnknownModulePath, internal.LatestVersion)
-		if err == nil {
-			http.Redirect(w, r, fmt.Sprintf("/%s", pkg.Path), http.StatusFound)
-			return
-		} else if !errors.Is(err, derrors.NotFound) {
-			log.Errorf(ctx, "error getting package for %s: %v", path.Clean(query), err)
-		}
+	if path := searchRequestRedirectPath(ctx, s.ds, query); path != "" {
+		http.Redirect(w, r, path, http.StatusFound)
+		return
 	}
 
 	page, err := fetchSearchPage(ctx, s.ds, query, newPaginationParams(r, defaultSearchLimit))
@@ -130,6 +125,41 @@ func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
 	s.servePage(ctx, w, "search.tmpl", page)
 }
 
+// searchRequestRedirectPath returns the path that a search request should be
+// redirected to, or the empty string if there is no such path.  Standard
+// library packages that only contain one element (such as fmt, errors, etc.)
+// will not redirect to allow users to search by those terms.
+func searchRequestRedirectPath(ctx context.Context, ds internal.DataSource, query string) string {
+	requestedPath := path.Clean(query)
+	if !strings.Contains(requestedPath, "/") {
+		return ""
+	}
+	pkg, err := ds.GetPackage(ctx, requestedPath, internal.UnknownModulePath, internal.LatestVersion)
+	if err == nil {
+		return fmt.Sprintf("/%s", pkg.Path)
+	} else if !errors.Is(err, derrors.NotFound) {
+		log.Errorf(ctx, "error getting package for %s: %v", requestedPath, err)
+		return ""
+	}
+
+	vi, err := ds.GetVersionInfo(ctx, requestedPath, internal.LatestVersion)
+	if err == nil {
+		return fmt.Sprintf("/mod/%s", vi.ModulePath)
+	} else if !errors.Is(err, derrors.NotFound) {
+		log.Errorf(ctx, "error getting module for %s: %v", requestedPath, err)
+		return ""
+	}
+
+	dir, err := ds.GetDirectory(ctx, requestedPath, internal.UnknownModulePath, internal.LatestVersion, internal.AllFields)
+	if err == nil {
+		return fmt.Sprintf("/%s", dir.Path)
+	} else if !errors.Is(err, derrors.NotFound) {
+		log.Errorf(ctx, "error getting directory for %s: %v", requestedPath, err)
+		return ""
+	}
+	return ""
+}
+
 // searchQuery extracts a search query from the request.
 func searchQuery(r *http.Request) string {
 	return strings.TrimSpace(r.FormValue("q"))

internal/frontend/search_test.go

@@ -173,3 +173,50 @@ func TestApproximateNumber(t *testing.T) {
 		}
 	}
 }
+
+func TestSearchRequestRedirectPath(t *testing.T) {
+	ctx := context.Background()
+
+	golangTools := sample.Version()
+	golangTools.ModulePath = "golang.org/x/tools"
+	lspPkg := sample.Package()
+	lspPkg.Path = "golang.org/x/tools/internal/lsp"
+	golangTools.Packages = []*internal.Package{lspPkg}
+
+	std := sample.Version()
+	std.ModulePath = "std"
+	var stdlibPackages []*internal.Package
+	for _, path := range []string{"cmd/go", "cmd/go/internal/auth", "fmt"} {
+		pkg := sample.Package()
+		pkg.Path = path
+		stdlibPackages = append(stdlibPackages, pkg)
+	}
+	std.Packages = stdlibPackages
+	versions := []*internal.Version{golangTools, std}
+
+	for _, v := range versions {
+		if err := testDB.InsertVersion(ctx, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, tc := range []struct {
+		name  string
+		query string
+		want  string
+	}{
+		{"module", "golang.org/x/tools", "/mod/golang.org/x/tools"},
+		{"directory", "golang.org/x/tools/internal", "/golang.org/x/tools/internal"},
+		{"package", "golang.org/x/tools/internal/lsp", "/golang.org/x/tools/internal/lsp"},
+		{"stdlib package does not redirect", "errors", ""},
+		{"stdlib package does redirect", "cmd/go", "/cmd/go"},
+		{"stdlib directory does redirect", "cmd/go/internal", "/cmd/go/internal"},
+		{"std does not redirect", "std", ""},
+		{"non-existent path does not redirect", "github.com/non-existent", ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := searchRequestRedirectPath(ctx, testDB, tc.query); got != tc.want {
+				t.Errorf("searchRequestRedirectPath(ctx, %q) = %q; want = %q", tc.query, got, tc.want)
+			}
+		})
+	}
+}