Merge pull request #447 from remotemobprogramming/discard-uncommitted-changes

#446 mob start --discard-uncommitted-changes

Author: hollesse

CHANGELOG.md

@@ -1,3 +1,8 @@
+# 5.3.0
+- Feature: `mob start --discard-uncommitted-changes` allows to discard uncommitted changes and then starting a new mob session
+
+Thank you @stefanscheidt for this feature request
+
 # 5.2.0
 - Feature: `mob done` now pulls when someone else already did `done`
 

configuration/configuration.go

@@ -15,6 +15,12 @@ const (
 	SquashWip = "squash-wip"
 )
 
+const (
+	IncludeChanges = "include-changes"
+	DiscardChanges = "discard-changes"
+	FailWithError  = "fail-with-error"
+)
+
 type Configuration struct {
 	CliName                        string // override with MOB_CLI_NAME
 	RemoteName                     string // override with MOB_REMOTE_NAME
@@ -28,7 +34,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
-	StartIncludeUncommittedChanges bool
+	HandleUncommittedChanges       string
 	StartCreate                    bool // override with MOB_START_CREATE variable
 	StartJoin                      bool
 	StashName                      string // override with MOB_STASH_NAME
@@ -118,8 +124,10 @@ 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.HandleUncommittedChanges = DiscardChanges
 		case "--include-uncommitted-changes", "-i":
-			newConfiguration.StartIncludeUncommittedChanges = true
+			newConfiguration.HandleUncommittedChanges = IncludeChanges
 		case "--debug":
 			// ignore this, already parsed
 		case "--stay", "-s":
@@ -181,32 +189,32 @@ func GetDefaultConfiguration() Configuration {
 
 	}
 	return Configuration{
-		CliName:                        "mob",
-		RemoteName:                     "origin",
-		WipCommitMessage:               "mob next [ci-skip] [ci skip] [skip ci]",
-		StartCommitMessage:             "mob start [ci-skip] [ci skip] [skip ci]",
-		SkipCiPushOptionEnabled:        true,
-		GitHooksEnabled:                false,
-		VoiceCommand:                   voiceCommand,
-		VoiceMessage:                   "mob next",
-		NotifyCommand:                  notifyCommand,
-		NotifyMessage:                  "mob next",
-		NextStay:                       true,
-		RequireCommitMessage:           false,
-		StartIncludeUncommittedChanges: false,
-		StartCreate:                    false,
-		WipBranchQualifier:             "",
-		WipBranchQualifierSeparator:    "-",
-		DoneSquash:                     Squash,
-		OpenCommand:                    "",
-		Timer:                          "",
-		TimerLocal:                     true,
-		TimerRoom:                      "",
-		TimerUser:                      "",
-		TimerUrl:                       "https://timer.mob.sh/",
-		WipBranchPrefix:                "mob/",
-		StashName:                      "mob-stash-name",
-		ResetDeleteRemoteWipBranch:     false,
+		CliName:                     "mob",
+		RemoteName:                  "origin",
+		WipCommitMessage:            "mob next [ci-skip] [ci skip] [skip ci]",
+		StartCommitMessage:          "mob start [ci-skip] [ci skip] [skip ci]",
+		SkipCiPushOptionEnabled:     true,
+		GitHooksEnabled:             false,
+		VoiceCommand:                voiceCommand,
+		VoiceMessage:                "mob next",
+		NotifyCommand:               notifyCommand,
+		NotifyMessage:               "mob next",
+		NextStay:                    true,
+		RequireCommitMessage:        false,
+		HandleUncommittedChanges:    FailWithError,
+		StartCreate:                 false,
+		WipBranchQualifier:          "",
+		WipBranchQualifierSeparator: "-",
+		DoneSquash:                  Squash,
+		OpenCommand:                 "",
+		Timer:                       "",
+		TimerLocal:                  true,
+		TimerRoom:                   "",
+		TimerUser:                   "",
+		TimerUrl:                    "https://timer.mob.sh/",
+		WipBranchPrefix:             "mob/",
+		StashName:                   "mob-stash-name",
+		ResetDeleteRemoteWipBranch:  false,
 	}
 }
 

configuration/configuration_test.go

@@ -103,6 +103,56 @@ func TestParseArgsStartRoom(t *testing.T) {
 	test.Equals(t, "testroom", configuration.TimerRoom)
 }
 
+func TestDefaultConfigurationHandleUncommitedChanges(t *testing.T) {
+	configuration := GetDefaultConfiguration()
+
+	command, parameters, configuration := ParseArgs([]string{"mob", "start"}, configuration)
+
+	test.Equals(t, "start", command)
+	test.Equals(t, 0, len(parameters))
+	test.Equals(t, FailWithError, configuration.HandleUncommittedChanges)
+}
+
+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, IncludeChanges, configuration.HandleUncommittedChanges)
+}
+
+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, IncludeChanges, configuration.HandleUncommittedChanges)
+}
+
+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, DiscardChanges, configuration.HandleUncommittedChanges)
+}
+
+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, DiscardChanges, configuration.HandleUncommittedChanges)
+}
+
 func TestParseArgsTimerRoom(t *testing.T) {
 	configuration := GetDefaultConfiguration()
 	test.Equals(t, configuration.WipBranchQualifier, "")
@@ -188,10 +238,6 @@ func (c Configuration) GetMobDoneSquash() string {
 	return c.DoneSquash
 }
 
-func (c Configuration) GetMobStartIncludeUncommittedChanges() bool {
-	return c.StartIncludeUncommittedChanges
-}
-
 func (c Configuration) GetMobStartCreateRemoteBranch() bool {
 	return c.StartCreate
 }

mob.go

@@ -21,7 +21,7 @@ import (
 )
 
 const (
-	versionNumber     = "5.2.0"
+	versionNumber     = "5.3.0"
 	minimumGitVersion = "2.13.0"
 )
 
@@ -527,7 +527,7 @@ func deleteRemoteWipBranch(configuration config.Configuration) {
 
 func start(configuration config.Configuration) error {
 	uncommittedChanges := hasUncommittedChanges()
-	if uncommittedChanges && !configuration.StartIncludeUncommittedChanges {
+	if uncommittedChanges && configuration.HandleUncommittedChanges == config.FailWithError {
 		say.Info("cannot start; clean working tree required")
 		sayUnstagedChangesInfo()
 		sayUntrackedFilesInfo()
@@ -557,13 +557,16 @@ 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", ".") == "" {
-		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 && configuration.HandleUncommittedChanges == config.DiscardChanges {
+		git("reset", "--hard")
 	}
 
-	if uncommittedChanges {
+	if uncommittedChanges && configuration.HandleUncommittedChanges == config.IncludeChanges {
+		if 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")
+		}
 		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'.")
 	}
@@ -580,7 +583,7 @@ func start(configuration config.Configuration) error {
 		startNewMobSession(configuration)
 	}
 
-	if uncommittedChanges && configuration.StartIncludeUncommittedChanges {
+	if uncommittedChanges && configuration.HandleUncommittedChanges == config.IncludeChanges {
 		stashes := silentgit("stash", "list")
 		stash := findStashByName(stashes, configuration.StashName)
 		git("stash", "pop", stash)
@@ -595,16 +598,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

@@ -532,19 +532,20 @@ func TestCleanMissingBaseBranch(t *testing.T) {
 
 func TestStartUnstagedChanges(t *testing.T) {
 	output, configuration := setup(t)
-	configuration.StartIncludeUncommittedChanges = false
+	configuration.HandleUncommittedChanges = config.FailWithError
 	createFile(t, "test.txt", "contentIrrelevant")
 
 	start(configuration)
 
 	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) {
 	_, configuration := setup(t)
-	configuration.StartIncludeUncommittedChanges = true
+	configuration.HandleUncommittedChanges = config.IncludeChanges
 	createFile(t, "test.txt", "contentIrrelevant")
 
 	start(configuration)
@@ -553,9 +554,21 @@ func TestStartIncludeUnstagedChanges(t *testing.T) {
 	assertMobSessionBranches(t, configuration, "mob-session")
 }
 
+func TestStartDiscardUnstagedChanges(t *testing.T) {
+	_, configuration := setup(t)
+	configuration.HandleUncommittedChanges = config.DiscardChanges
+	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
+	configuration.HandleUncommittedChanges = config.IncludeChanges
 	createDirectory(t, "subdirnew")
 	setWorkingDir(tempDir + "/local/subdirnew")
 	createFile(t, "test.txt", "contentIrrelevant")
@@ -587,7 +600,7 @@ func TestBranch(t *testing.T) {
 
 func TestStartIncludeUntrackedFiles(t *testing.T) {
 	_, configuration := setup(t)
-	configuration.StartIncludeUncommittedChanges = true
+	configuration.HandleUncommittedChanges = config.IncludeChanges
 	createFile(t, "example.txt", "contentIrrelevant")
 
 	start(configuration)
@@ -597,7 +610,7 @@ func TestStartIncludeUntrackedFiles(t *testing.T) {
 
 func TestStartUntrackedFiles(t *testing.T) {
 	_, configuration := setup(t)
-	configuration.StartIncludeUncommittedChanges = false
+	configuration.HandleUncommittedChanges = config.FailWithError
 	createFile(t, "example.txt", "contentIrrelevant")
 
 	start(configuration)
@@ -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) {
@@ -668,7 +683,7 @@ func TestStartCreateIncludeUncommitedChangesOnUnpushedFeatureBranchWithUncommite
 	createFile(t, "file.txt", "contentIrrelevant")
 
 	configuration.StartCreate = true
-	configuration.StartIncludeUncommittedChanges = true
+	configuration.HandleUncommittedChanges = config.IncludeChanges
 	start(configuration)
 
 	assertOnBranch(t, "mob/feature1")
@@ -680,7 +695,7 @@ func TestStartCreateIncludeUncommitedChangesOnUnpushedFeatureBranchWithUncommite
 	createFile(t, "file.txt", "contentIrrelevant")
 
 	configuration.StartCreate = true
-	configuration.StartIncludeUncommittedChanges = true
+	configuration.HandleUncommittedChanges = config.IncludeChanges
 	configuration.WipBranchQualifier = "green"
 	start(configuration)
 
@@ -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()
 }