446 mob start --discard-uncommitted-changes

Author: hollesse

configuration/configuration.go

@@ -28,6 +28,7 @@ type Configuration struct {
 	NotifyCommand                  string // override with MOB_NOTIFY_COMMAND
 	NotifyMessage                  string // override with MOB_NOTIFY_MESSAGE
 	NextStay                       bool   // override with MOB_NEXT_STAY
+	StartDiscardUncommittedChanges bool
 	StartIncludeUncommittedChanges bool
 	StartCreate                    bool // override with MOB_START_CREATE variable
 	StartJoin                      bool
@@ -118,6 +119,8 @@ func ParseArgs(args []string, configuration Configuration) (command string, para
 	for i := 1; i < len(args); i++ {
 		arg := args[i]
 		switch arg {
+		case "--discard-uncommitted-changes", "-d":
+			newConfiguration.StartDiscardUncommittedChanges = true
 		case "--include-uncommitted-changes", "-i":
 			newConfiguration.StartIncludeUncommittedChanges = true
 		case "--debug":
@@ -193,6 +196,7 @@ func GetDefaultConfiguration() Configuration {
 		NotifyMessage:                  "mob next",
 		NextStay:                       true,
 		RequireCommitMessage:           false,
+		StartDiscardUncommittedChanges: false,
 		StartIncludeUncommittedChanges: false,
 		StartCreate:                    false,
 		WipBranchQualifier:             "",

configuration/configuration_test.go

@@ -103,6 +103,46 @@ func TestParseArgsStartRoom(t *testing.T) {
 	test.Equals(t, "testroom", configuration.TimerRoom)
 }
 
+func TestParseArgsIncludeUncommitedChanges(t *testing.T) {
+	configuration := GetDefaultConfiguration()
+
+	command, parameters, configuration := ParseArgs([]string{"mob", "start", "--include-uncommitted-changes"}, configuration)
+
+	test.Equals(t, "start", command)
+	test.Equals(t, 0, len(parameters))
+	test.Equals(t, true, configuration.StartIncludeUncommittedChanges)
+}
+
+func TestParseArgsIncludeUncommitedChangesShort(t *testing.T) {
+	configuration := GetDefaultConfiguration()
+
+	command, parameters, configuration := ParseArgs([]string{"mob", "start", "-i"}, configuration)
+
+	test.Equals(t, "start", command)
+	test.Equals(t, 0, len(parameters))
+	test.Equals(t, true, configuration.StartIncludeUncommittedChanges)
+}
+
+func TestParseArgsDiscardUncommitedChanges(t *testing.T) {
+	configuration := GetDefaultConfiguration()
+
+	command, parameters, configuration := ParseArgs([]string{"mob", "start", "--discard-uncommitted-changes"}, configuration)
+
+	test.Equals(t, "start", command)
+	test.Equals(t, 0, len(parameters))
+	test.Equals(t, true, configuration.StartDiscardUncommittedChanges)
+}
+
+func TestParseArgsDiscardUncommitedChangesShort(t *testing.T) {
+	configuration := GetDefaultConfiguration()
+
+	command, parameters, configuration := ParseArgs([]string{"mob", "start", "-d"}, configuration)
+
+	test.Equals(t, "start", command)
+	test.Equals(t, 0, len(parameters))
+	test.Equals(t, true, configuration.StartDiscardUncommittedChanges)
+}
+
 func TestParseArgsTimerRoom(t *testing.T) {
 	configuration := GetDefaultConfiguration()
 	test.Equals(t, configuration.WipBranchQualifier, "")

mob.go

@@ -527,7 +527,7 @@ func deleteRemoteWipBranch(configuration config.Configuration) {
 
 func start(configuration config.Configuration) error {
 	uncommittedChanges := hasUncommittedChanges()
-	if uncommittedChanges && !configuration.StartIncludeUncommittedChanges {
+	if uncommittedChanges && !configuration.StartIncludeUncommittedChanges && !configuration.StartDiscardUncommittedChanges {
 		say.Info("cannot start; clean working tree required")
 		sayUnstagedChangesInfo()
 		sayUntrackedFilesInfo()
@@ -557,13 +557,22 @@ func start(configuration config.Configuration) error {
 		return errors.New("cannot start; unpushed changes on base branch must be pushed upstream")
 	}
 
-	if uncommittedChanges && silentgit("ls-tree", "-r", "HEAD", "--full-name", "--name-only", ".") == "" {
+	if uncommittedChanges && configuration.StartIncludeUncommittedChanges && configuration.StartDiscardUncommittedChanges {
+		errorMessage := "The options '--include-uncommitted-changes' (-i) and '--discard-uncommitted-changes' (-d) cannot be used together as they are mutually exclusive. Please choose either to include or discard uncommitted changes, but not both."
+		say.Error(errorMessage)
+		return errors.New(errorMessage)
+	}
+	if uncommittedChanges && configuration.StartDiscardUncommittedChanges {
+		git("reset", "--hard")
+	}
+
+	if uncommittedChanges && configuration.StartIncludeUncommittedChanges && silentgit("ls-tree", "-r", "HEAD", "--full-name", "--name-only", ".") == "" {
 		say.Error("cannot start; current working dir is an uncommitted subdir")
 		say.Fix("to fix this, go to the parent directory and try again", "cd ..")
 		return errors.New("cannot start; current working dir is an uncommitted subdir")
 	}
 
-	if uncommittedChanges {
+	if uncommittedChanges && configuration.StartIncludeUncommittedChanges {
 		git("stash", "push", "--include-untracked", "--message", configuration.StashName)
 		say.Info("uncommitted changes were stashed. If an error occurs later on, you can recover them with 'git stash pop'.")
 	}
@@ -595,16 +604,22 @@ func start(configuration config.Configuration) error {
 }
 
 func sayFixUncommittedChanges(configuration config.Configuration) {
-	var instruction string
+	var instructionInclude string
+	var instructionDiscard string
 	if configuration.StartCreate {
-		instruction = "To start, including uncommitted changes and create the remote branch, use"
+		instructionInclude = "To start, including uncommitted changes and create the remote branch, use"
+		instructionDiscard = "To start, discarding uncommitted changes and create the remote branch, use"
 	} else {
-		instruction = "To start, including uncommitted changes, use"
+		instructionInclude = "To start, including uncommitted changes, use"
+		instructionDiscard = "To start, discarding uncommitted changes, use"
 	}
 
-	fixCommand := configuration.CliName + " start" + createFix(configuration) + branchFix(configuration) + " --include-uncommitted-changes"
+	fixCommandStart := configuration.CliName + " start" + createFix(configuration) + branchFix(configuration)
+	fixCommandInclude := fixCommandStart + " --include-uncommitted-changes"
+	fixCommandDiscard := fixCommandStart + " --discard-uncommitted-changes"
 
-	say.Fix(instruction, fixCommand)
+	say.Fix(instructionInclude, fixCommandInclude)
+	say.Fix(instructionDiscard, fixCommandDiscard)
 }
 
 func createFix(configuration config.Configuration) string {

mob_test.go

@@ -540,6 +540,7 @@ func TestStartUnstagedChanges(t *testing.T) {
 	assertOnBranch(t, "master")
 	assertNoMobSessionBranches(t, configuration, "mob-session")
 	assertOutputContains(t, output, "mob start --include-uncommitted-changes")
+	assertOutputContains(t, output, "mob start --discard-uncommitted-changes")
 }
 
 func TestStartIncludeUnstagedChanges(t *testing.T) {
@@ -553,6 +554,18 @@ func TestStartIncludeUnstagedChanges(t *testing.T) {
 	assertMobSessionBranches(t, configuration, "mob-session")
 }
 
+func TestStartDiscardUnstagedChanges(t *testing.T) {
+	_, configuration := setup(t)
+	configuration.StartDiscardUncommittedChanges = true
+	createFile(t, "test.txt", "contentIrrelevant")
+
+	start(configuration)
+
+	assertOnBranch(t, "mob-session")
+	assertMobSessionBranches(t, configuration, "mob-session")
+	assertCleanGitStatus(t)
+}
+
 func TestStartIncludeUnstagedChangesInNewWorkingDirectory(t *testing.T) {
 	output, configuration := setup(t)
 	configuration.StartIncludeUncommittedChanges = true
@@ -625,6 +638,7 @@ func TestStartOnUnpushedFeatureBranchWithUncommitedChanges(t *testing.T) {
 
 	assertOnBranch(t, "feature1")
 	assertOutputContains(t, output, "mob start --include-uncommitted-changes")
+	assertOutputContains(t, output, "mob start --discard-uncommitted-changes")
 }
 
 func TestStartCreateOnUnpushedFeatureBranch(t *testing.T) {
@@ -660,6 +674,7 @@ func TestStartCreateOnUnpushedFeatureBranchWithUncommitedChanges(t *testing.T) {
 
 	assertOutputContains(t, output, "To start, including uncommitted changes and create the remote branch, use")
 	assertOutputContains(t, output, "mob start --create --include-uncommitted-changes")
+	assertOutputContains(t, output, "mob start --create --discard-uncommitted-changes")
 }
 
 func TestStartCreateIncludeUncommitedChangesOnUnpushedFeatureBranchWithUncommitedChanges(t *testing.T) {
@@ -1521,6 +1536,7 @@ func TestStartBranchWithUncommitedChangesFixWithBranch(t *testing.T) {
 	runMob(t, tempDir+"/local", "start", "-b", "green")
 
 	assertOutputContains(t, output, "mob start --branch green --include-uncommitted-changes")
+	assertOutputContains(t, output, "mob start --branch green --discard-uncommitted-changes")
 	resetExit()
 }
 
@@ -1534,6 +1550,7 @@ func TestStartBranchEnvWithUncommitedChangesFixWithoutBranch(t *testing.T) {
 	runMob(t, tempDir+"/local", "start")
 
 	assertOutputContains(t, output, "mob start --include-uncommitted-changes")
+	assertOutputContains(t, output, "mob start --discard-uncommitted-changes")
 	resetExit()
 }
 
@@ -1548,6 +1565,7 @@ func TestStartCreateBranchWithUncommitedChangesFixWithBranch(t *testing.T) {
 	runMob(t, tempDir+"/local", "start", "--create", "-b", "green")
 
 	assertOutputContains(t, output, "mob start --create --branch green --include-uncommitted-changes")
+	assertOutputContains(t, output, "mob start --create --branch green --discard-uncommitted-changes")
 	resetExit()
 }
 
@@ -1563,6 +1581,7 @@ func TestStartCreateBranchEnvWithUncommitedChangesFixWithoutBranch(t *testing.T)
 
 	os.Unsetenv("MOB_WIP_BRANCH_QUALIFIER")
 	assertOutputContains(t, output, "mob start --create --include-uncommitted-changes")
+	assertOutputContains(t, output, "mob start --create --discard-uncommitted-changes")
 	resetExit()
 }