Merge pull request #5943 from dolthub/nicktobey/detached_head

Don't panic when in detached head state.

go/cmd/dolt/commands/branch.go

@@ -138,7 +138,10 @@ func printBranches(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPar
 		return HandleVErrAndExitCode(errhand.BuildDError("error: failed to read refs from db").AddCause(err).Build(), nil)
 	}
 
-	currentBranch := dEnv.RepoStateReader().CWBHeadRef()
+	currentBranch, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.BuildDError("error: failed to read refs from db").AddCause(err).Build(), nil)
+	}
 	sort.Slice(branches, func(i, j int) bool {
 		return branches[i].String() < branches[j].String()
 	})
@@ -172,7 +175,7 @@ func printBranches(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPar
 		}
 
 		if verbose {
-			cm, err := dEnv.DoltDB.Resolve(ctx, cs, dEnv.RepoStateReader().CWBHeadRef())
+			cm, err := dEnv.DoltDB.Resolve(ctx, cs, currentBranch)
 
 			if err == nil {
 				h, err := cm.HashOf()
@@ -195,7 +198,11 @@ func printBranches(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPar
 }
 
 func printCurrentBranch(dEnv *env.DoltEnv) int {
-	cli.Println(dEnv.RepoStateReader().CWBHeadRef().GetPath())
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.BuildDError(err.Error()).Build(), nil)
+	}
+	cli.Println(headRef.GetPath())
 	return 0
 }
 

go/cmd/dolt/commands/checkout.go

@@ -119,7 +119,10 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 		if err != nil {
 			return HandleVErrAndExitCode(errhand.BuildDError(err.Error()).Build(), usagePrt)
 		}
-		headRef := dEnv.RepoStateReader().CWBHeadRef()
+		headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+		if err != nil {
+			return HandleVErrAndExitCode(errhand.BuildDError(err.Error()).Build(), nil)
+		}
 		ws, err := dEnv.WorkingSet(ctx)
 		if err != nil {
 			HandleVErrAndExitCode(errhand.BuildDError(err.Error()).Build(), usagePrt)
@@ -177,9 +180,14 @@ func checkoutNewBranch(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.Ar
 		return verr
 	}
 
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return errhand.BuildDError(err.Error()).Build()
+	}
+
 	// the new branch is checked out at this point
 	if setTrackUpstream {
-		verr = SetRemoteUpstreamForBranchRef(dEnv, remoteName, remoteBranchName, dEnv.RepoStateReader().CWBHeadRef())
+		verr = SetRemoteUpstreamForBranchRef(dEnv, remoteName, remoteBranchName, headRef)
 		if verr != nil {
 			return verr
 		}
@@ -195,7 +203,7 @@ func checkoutNewBranch(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.Ar
 		if !remoteOk {
 			return nil
 		}
-		verr = SetRemoteUpstreamForBranchRef(dEnv, remoteName, remoteBranchName, dEnv.RepoStateReader().CWBHeadRef())
+		verr = SetRemoteUpstreamForBranchRef(dEnv, remoteName, remoteBranchName, headRef)
 		if verr != nil {
 			return verr
 		}
@@ -230,7 +238,11 @@ func checkoutRemoteBranchOrSuggestNew(ctx context.Context, dEnv *env.DoltEnv, na
 		if verr != nil {
 			return verr
 		}
-		return SetRemoteUpstreamForBranchRef(dEnv, remoteRefs[0].GetRemote(), remoteRefs[0].GetBranch(), dEnv.RepoStateReader().CWBHeadRef())
+		headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+		if err != nil {
+			return errhand.BuildDError(err.Error()).Build()
+		}
+		return SetRemoteUpstreamForBranchRef(dEnv, remoteRefs[0].GetRemote(), remoteRefs[0].GetBranch(), headRef)
 	} else {
 		// TODO : add hint of using `dolt checkout --track <remote>/<branch>` when --track flag is supported
 		return errhand.BuildDError("'%s' matched multiple (%v) remote tracking branches", name, len(remoteRefs)).Build()

go/cmd/dolt/commands/cherry-pick.go

@@ -183,7 +183,11 @@ func getCherryPickedRootValue(ctx context.Context, dEnv *env.DoltEnv, workingRoo
 	if err != nil {
 		return nil, "", err
 	}
-	cherryCm, err := dEnv.DoltDB.Resolve(ctx, cherrySpec, dEnv.RepoStateReader().CWBHeadRef())
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return nil, "", err
+	}
+	cherryCm, err := dEnv.DoltDB.Resolve(ctx, cherrySpec, headRef)
 	if err != nil {
 		return nil, "", err
 	}

go/cmd/dolt/commands/commit.go

@@ -221,9 +221,13 @@ func performCommit(ctx context.Context, commandStr string, args []string, dEnv *
 		return handleCommitErr(ctx, dEnv, err, usage)
 	}
 
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return handleCommitErr(ctx, dEnv, err, usage)
+	}
 	_, err = dEnv.DoltDB.CommitWithWorkingSet(
 		ctx,
-		dEnv.RepoStateReader().CWBHeadRef(),
+		headRef,
 		ws.Ref(),
 		pendingCommit,
 		ws.WithStagedRoot(pendingCommit.Roots.Staged).WithWorkingRoot(pendingCommit.Roots.Working).ClearMerge(),
@@ -381,7 +385,10 @@ func buildInitalCommitMsg(ctx context.Context, dEnv *env.DoltEnv, suggestedMsg s
 		return "", err
 	}
 
-	currBranch := dEnv.RepoStateReader().CWBHeadRef()
+	currBranch, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return "", err
+	}
 	initialCommitMessage := fmt.Sprintf("%s\n# Please enter the commit message for your changes. Lines starting"+
 		"\n# with '#' will be ignored, and an empty message aborts the commit."+
 		"\n# On branch %s\n#\n", suggestedMsg, currBranch)

go/cmd/dolt/commands/filter-branch.go

@@ -186,7 +186,12 @@ func getNerf(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgParseResu
 		return nil, err
 	}
 
-	cm, err := dEnv.DoltDB.Resolve(ctx, cs, dEnv.RepoStateReader().CWBHeadRef())
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return nil, err
+	}
+
+	cm, err := dEnv.DoltDB.Resolve(ctx, cs, headRef)
 	if err != nil {
 		return nil, err
 	}

go/cmd/dolt/commands/log.go

@@ -123,7 +123,11 @@ func (cmd LogCmd) logWithLoggerFunc(ctx context.Context, commandStr string, args
 		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
 	}
 	if len(opts.commitSpecs) == 0 {
-		opts.commitSpecs = append(opts.commitSpecs, dEnv.RepoStateReader().CWBHeadSpec())
+		headRef, err := dEnv.RepoStateReader().CWBHeadSpec()
+		if err != nil {
+			return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+		}
+		opts.commitSpecs = append(opts.commitSpecs, headRef)
 	}
 	if len(opts.tableName) > 0 {
 		return handleErrAndExit(logTableCommits(ctx, dEnv, opts))
@@ -245,7 +249,10 @@ func (opts *logOpts) parseRefsAndTable(ctx context.Context, apr *argparser.ArgPa
 
 			opts.excludingCommitSpecs = append(opts.excludingCommitSpecs, notCs)
 		} else {
-			argIsRef := actions.IsValidRef(ctx, arg, dEnv.DoltDB, dEnv.RepoStateReader())
+			argIsRef, err := actions.IsValidRef(ctx, arg, dEnv.DoltDB, dEnv.RepoStateReader())
+			if err != nil {
+				return nil
+			}
 			// <ref>
 			if argIsRef && !seenRefs[arg] {
 				cs, err := getCommitSpec(arg)
@@ -327,8 +334,12 @@ func getHashToRefs(ctx context.Context, dEnv *env.DoltEnv, decorationLevel strin
 func logCommits(ctx context.Context, dEnv *env.DoltEnv, opts *logOpts) int {
 	hashes := make([]hash.Hash, len(opts.commitSpecs))
 
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return handleErrAndExit(err)
+	}
 	for i, cs := range opts.commitSpecs {
-		commit, err := dEnv.DoltDB.Resolve(ctx, cs, dEnv.RepoStateReader().CWBHeadRef())
+		commit, err := dEnv.DoltDB.Resolve(ctx, cs, headRef)
 		if err != nil {
 			cli.PrintErrln(color.HiRedString("Fatal error: cannot get HEAD commit for current branch."))
 			return 1
@@ -360,7 +371,7 @@ func logCommits(ctx context.Context, dEnv *env.DoltEnv, opts *logOpts) int {
 		excludingHashes := make([]hash.Hash, len(opts.excludingCommitSpecs))
 
 		for i, excludingSpec := range opts.excludingCommitSpecs {
-			excludingCommit, err := dEnv.DoltDB.Resolve(ctx, excludingSpec, dEnv.RepoStateReader().CWBHeadRef())
+			excludingCommit, err := dEnv.DoltDB.Resolve(ctx, excludingSpec, headRef)
 			if err != nil {
 				cli.PrintErrln(color.HiRedString("Fatal error: cannot get excluding commit for current branch."))
 				return 1
@@ -383,7 +394,6 @@ func logCommits(ctx context.Context, dEnv *env.DoltEnv, opts *logOpts) int {
 		return 1
 	}
 
-	headRef := dEnv.RepoStateReader().CWBHeadRef()
 	cwbHash, err := dEnv.DoltDB.GetHashForRefStr(ctx, headRef.String())
 
 	if err != nil {
@@ -441,8 +451,13 @@ func tableExists(ctx context.Context, commit *doltdb.Commit, tableName string) (
 func logTableCommits(ctx context.Context, dEnv *env.DoltEnv, opts *logOpts) error {
 	hashes := make([]hash.Hash, len(opts.commitSpecs))
 
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return err
+	}
+
 	for i, cs := range opts.commitSpecs {
-		commit, err := dEnv.DoltDB.Resolve(ctx, cs, dEnv.RepoStateReader().CWBHeadRef())
+		commit, err := dEnv.DoltDB.Resolve(ctx, cs, headRef)
 		if err != nil {
 			return err
 		}

go/cmd/dolt/commands/ls.go

@@ -121,7 +121,12 @@ func getRootForCommitSpecStr(ctx context.Context, csStr string, dEnv *env.DoltEn
 		return "", nil, bdr.AddCause(err).Build()
 	}
 
-	cm, err := dEnv.DoltDB.Resolve(ctx, cs, dEnv.RepoStateReader().CWBHeadRef())
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return "", nil, errhand.VerboseErrorFromError(err)
+	}
+
+	cm, err := dEnv.DoltDB.Resolve(ctx, cs, headRef)
 
 	if err != nil {
 		return "", nil, errhand.BuildDError(`Unable to resolve "%s"`, csStr).AddCause(err).Build()

go/cmd/dolt/commands/merge.go

@@ -159,7 +159,12 @@ func (cmd MergeCmd) Exec(ctx context.Context, commandStr string, args []string,
 				return handleCommitErr(ctx, dEnv, err, usage)
 			}
 
-			suggestedMsg := fmt.Sprintf("Merge branch '%s' into %s", commitSpecStr, dEnv.RepoStateReader().CWBHeadRef().GetPath())
+			headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+			if err != nil {
+				return handleCommitErr(ctx, dEnv, err, usage)
+			}
+
+			suggestedMsg := fmt.Sprintf("Merge branch '%s' into %s", commitSpecStr, headRef.GetPath())
 			msg := ""
 			if m, ok := apr.GetValue(cli.MessageArg); ok {
 				msg = m
@@ -529,10 +534,15 @@ func executeNoFFMergeAndCommit(ctx context.Context, dEnv *env.DoltEnv, spec *mer
 		Email:      spec.Email,
 	})
 
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return tblToStats, err
+	}
+
 	wsHash, err := ws.HashOf()
 	_, err = dEnv.DoltDB.CommitWithWorkingSet(
 		ctx,
-		dEnv.RepoStateReader().CWBHeadRef(),
+		headRef,
 		ws.Ref(),
 		pendingCommit,
 		ws.WithStagedRoot(pendingCommit.Roots.Staged).WithWorkingRoot(pendingCommit.Roots.Working).ClearMerge(),

go/cmd/dolt/commands/merge_base.go

@@ -119,7 +119,12 @@ func ResolveCommitWithVErr(dEnv *env.DoltEnv, cSpecStr string) (*doltdb.Commit,
 		return nil, errhand.BuildDError("'%s' is not a valid commit", cSpecStr).Build()
 	}
 
-	cm, err := dEnv.DoltDB.Resolve(context.TODO(), cs, dEnv.RepoStateReader().CWBHeadRef())
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return nil, errhand.VerboseErrorFromError(err)
+	}
+
+	cm, err := dEnv.DoltDB.Resolve(context.TODO(), cs, headRef)
 	if err != nil {
 		if errors.Is(err, doltdb.ErrInvalidAncestorSpec) {
 			return nil, errhand.BuildDError("'%s' could not resolve ancestor spec", cSpecStr).Build()

go/cmd/dolt/commands/pull.go

@@ -202,7 +202,12 @@ func pullHelper(ctx context.Context, dEnv *env.DoltEnv, pullSpec *env.PullSpec)
 				return err
 			}
 
-			suggestedMsg := fmt.Sprintf("Merge branch '%s' of %s into %s", pullSpec.Branch.GetPath(), pullSpec.Remote.Url, dEnv.RepoStateReader().CWBHeadRef().GetPath())
+			headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+			if err != nil {
+				return err
+			}
+
+			suggestedMsg := fmt.Sprintf("Merge branch '%s' of %s into %s", pullSpec.Branch.GetPath(), pullSpec.Remote.Url, headRef.GetPath())
 			tblStats, err := performMerge(ctx, dEnv, mergeSpec, suggestedMsg)
 			printSuccessStats(tblStats)
 			if err != nil {

go/cmd/dolt/commands/push.go

@@ -96,16 +96,20 @@ func (cmd PushCmd) Exec(ctx context.Context, commandStr string, args []string, d
 		var verr errhand.VerboseError
 		switch err {
 		case env.ErrNoUpstreamForBranch:
-			currentBranch := dEnv.RepoStateReader().CWBHeadRef()
-			remoteName := "<remote>"
-			if defRemote, verr := env.GetDefaultRemote(dEnv.RepoStateReader()); verr == nil {
-				remoteName = defRemote.Name
+			currentBranch, err := dEnv.RepoStateReader().CWBHeadRef()
+			if err != nil {
+				verr = errhand.BuildDError("fatal: The current branch could not be identified").AddCause(err).Build()
+			} else {
+				remoteName := "<remote>"
+				if defRemote, verr := env.GetDefaultRemote(dEnv.RepoStateReader()); verr == nil {
+					remoteName = defRemote.Name
+				}
+				verr = errhand.BuildDError("fatal: The current branch " + currentBranch.GetPath() + " has no upstream branch.\n" +
+					"To push the current branch and set the remote as upstream, use\n" +
+					"\tdolt push --set-upstream " + remoteName + " " + currentBranch.GetPath() + "\n" +
+					"To have this happen automatically for branches without a tracking\n" +
+					"upstream, see 'push.autoSetupRemote' in 'dolt config --help'.").Build()
 			}
-			verr = errhand.BuildDError("fatal: The current branch " + currentBranch.GetPath() + " has no upstream branch.\n" +
-				"To push the current branch and set the remote as upstream, use\n" +
-				"\tdolt push --set-upstream " + remoteName + " " + currentBranch.GetPath() + "\n" +
-				"To have this happen automatically for branches without a tracking\n" +
-				"upstream, see 'push.autoSetupRemote' in 'dolt config --help'.").Build()
 
 		case env.ErrInvalidSetUpstreamArgs:
 			verr = errhand.BuildDError("error: --set-upstream requires <remote> and <refspec> params.").SetPrintUsage().Build()

go/cmd/dolt/commands/reset.go

@@ -103,7 +103,11 @@ func (cmd ResetCmd) Exec(ctx context.Context, commandStr string, args []string,
 	} else {
 		if apr.NArg() == 1 {
 			ref := apr.Arg(0)
-			if actions.IsValidRef(ctx, ref, dEnv.DoltDB, dEnv.RepoStateReader()) {
+			isValidRef, err := actions.IsValidRef(ctx, ref, dEnv.DoltDB, dEnv.RepoStateReader())
+			if err != nil {
+				return handleErrAndExit(err)
+			}
+			if isValidRef {
 				return handleResetSoftToRef(ctx, dEnv, ref, usage)
 			}
 		}
@@ -145,7 +149,10 @@ func handleResetHard(ctx context.Context, apr *argparser.ArgParseResults, usage
 		arg = apr.Arg(0)
 	}
 
-	headRef := dEnv.RepoStateReader().CWBHeadRef()
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	}
 	ws, err := dEnv.WorkingSet(ctx)
 	if err != nil {
 		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)

go/cmd/dolt/commands/show.go

@@ -159,7 +159,11 @@ func parseShowArgs(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPar
 
 func showObjects(ctx context.Context, dEnv *env.DoltEnv, opts *showOpts) error {
 	if len(opts.specRefs) == 0 {
-		return showCommitSpec(ctx, dEnv, opts, dEnv.RepoStateReader().CWBHeadSpec())
+		headRef, err := dEnv.RepoStateReader().CWBHeadSpec()
+		if err != nil {
+			return err
+		}
+		return showCommitSpec(ctx, dEnv, opts, headRef)
 	}
 
 	for _, specRef := range opts.specRefs {
@@ -243,7 +247,12 @@ func showSpecRef(ctx context.Context, dEnv *env.DoltEnv, opts *showOpts, specRef
 
 func showCommitSpec(ctx context.Context, dEnv *env.DoltEnv, opts *showOpts, commitSpec *doltdb.CommitSpec) error {
 
-	commit, err := dEnv.DoltDB.Resolve(ctx, commitSpec, dEnv.RepoStateReader().CWBHeadRef())
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return err
+	}
+
+	commit, err := dEnv.DoltDB.Resolve(ctx, commitSpec, headRef)
 	if err != nil {
 		return err
 	}
@@ -283,7 +292,10 @@ func showCommit(ctx context.Context, dEnv *env.DoltEnv, opts *showOpts, comm *do
 		return err
 	}
 
-	headRef := dEnv.RepoStateReader().CWBHeadRef()
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return err
+	}
 	cwbHash, err := dEnv.DoltDB.GetHashForRefStr(ctx, headRef.String())
 	if err != nil {
 		return err

go/cmd/dolt/commands/stashcmds/pop.go

@@ -133,7 +133,11 @@ func applyStashAtIdx(ctx context.Context, dEnv *env.DoltEnv, curWorkingRoot *dol
 	if err != nil {
 		return false, err
 	}
-	parentCommit, err := dEnv.DoltDB.Resolve(ctx, headCommitSpec, dEnv.RepoStateReader().CWBHeadRef())
+	headRef, err := dEnv.RepoStateReader().CWBHeadRef()
+	if err != nil {
+		return false, err
+	}
+	parentCommit, err := dEnv.DoltDB.Resolve(ctx, headCommitSpec, headRef)
 	if err != nil {
 		return false, err
 	}