Simplify target existence checks

core/copy.go

@@ -15,64 +15,65 @@ import (
 
 // CopyArgument copies a field from an entry to the clipboard.
 func CopyArgument(targetLocation string, field int) error {
-	if isFile, _, err := back.TargetIsFile(targetLocation, true, 2); isFile {
-		if err != nil {
-			return err
-		}
-
-		decryptedEntry, err := crypt.DecryptFileToSlice(targetLocation)
-		if err != nil {
-			return errors.New("unable to decrypt entry: " + err.Error())
-		}
-		var copySubject string // will store data to be copied
-
-		// ensure field exists in entry
-		if len(decryptedEntry) > field {
-
-			// ensure field is not empty
-			if decryptedEntry[field] == "" {
-				return errors.New("field is empty")
-			}
-
-			if field != 2 {
-				copySubject = decryptedEntry[field]
-			} else { // TOTP mode
-				var secret string // stores secret for TOTP generation
-				var forSteam bool // indicates whether to generate TOTP in Steam format
-
-				if strings.HasPrefix(decryptedEntry[2], "steam@") {
-					secret = decryptedEntry[2][6:]
-					forSteam = true
-				} else {
-					secret = decryptedEntry[2]
-				}
-
-				fmt.Println("Clipboard will be kept up to date with the current TOTP code until this process is closed")
-
-				for { // keep token copied to clipboard, refresh on 30-second intervals
-					currentTime := time.Now()
-					token, err := GenTOTP(secret, currentTime, forSteam)
-					if err != nil {
-						return err
-					}
-					err = copyString(true, token)
-					if err != nil {
-						return err
-					}
-					// sleep until next 30-second interval
-					time.Sleep(time.Duration(30-(currentTime.Second()%30)) * time.Second)
-				}
-			}
-		} else {
-			return errors.New("field does not exist in entry")
-		}
-
-		// copy field to clipboard, launch clipboard clearing process
-		err = copyString(false, copySubject)
-		if err != nil {
-			return err
-		}
+	// ensure targetLocation exists and is a file
+	_, err := back.TargetIsFile(targetLocation, true)
+	if err != nil {
+		return err
 	}
+
+	decryptedEntry, err := crypt.DecryptFileToSlice(targetLocation)
+	if err != nil {
+		return errors.New("unable to decrypt entry: " + err.Error())
+	}
+	var copySubject string // will store data to be copied
+
+	// ensure field exists in entry
+	if len(decryptedEntry) > field {
+
+		// ensure field is not empty
+		if decryptedEntry[field] == "" {
+			return errors.New("field is empty")
+		}
+
+		if field != 2 {
+			copySubject = decryptedEntry[field]
+		} else { // TOTP mode
+			var secret string // stores secret for TOTP generation
+			var forSteam bool // indicates whether to generate TOTP in Steam format
+
+			if strings.HasPrefix(decryptedEntry[2], "steam@") {
+				secret = decryptedEntry[2][6:]
+				forSteam = true
+			} else {
+				secret = decryptedEntry[2]
+			}
+
+			fmt.Println("Clipboard will be kept up to date with the current TOTP code until this process is closed")
+
+			for { // keep token copied to clipboard, refresh on 30-second intervals
+				currentTime := time.Now()
+				token, err := GenTOTP(secret, currentTime, forSteam)
+				if err != nil {
+					return err
+				}
+				err = copyString(true, token)
+				if err != nil {
+					return err
+				}
+				// sleep until next 30-second interval
+				time.Sleep(time.Duration(30-(currentTime.Second()%30)) * time.Second)
+			}
+		}
+	} else {
+		return errors.New("field does not exist in entry")
+	}
+
+	// copy field to clipboard, launch clipboard clearing process
+	err = copyString(false, copySubject)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 

core/edit.go

@@ -9,8 +9,11 @@ import (
 
 // GetOldEntryData decrypts and returns old entry data (with all required lines present).
 func GetOldEntryData(targetLocation string, field int) ([]string, error) {
-	// ensure targetLocation exists
-	back.TargetIsFile(targetLocation, true, 2)
+	// ensure targetLocation exists and is a file
+	_, err := back.TargetIsFile(targetLocation, true)
+	if err != nil {
+		return nil, err
+	}
 
 	// read old entry data
 	decryptedEntry, err := crypt.DecryptFileToSlice(targetLocation)

core/init.go

@@ -18,12 +18,12 @@ import (
 func LibmuttonInit(inputCB func(prompt string) string, clientSpecificIniData [][3]string, rcwPassphrase []byte, preserveOldConfigDir bool) error {
 	r := strings.ToLower(inputCB("Configure SSH settings (for synchronization)? (y/N)"))
 	if len(r) > 0 && r[0] == 'y' {
-		// ensure ssh key file exists
+		// ensure ssh key file exists (and is a file)
 		fallbackSSHKey := back.Home + global.PathSeparator + ".ssh" + global.PathSeparator + "id_ed25519"
 		sshKeyPath := cmp.Or(back.ExpandPathWithHome(inputCB(back.AnsiBold+"Note:"+back.AnsiReset+" Only key-based authentication is supported (keys may optionally be passphrase-protected).\n      The remote server must already be in your ~"+global.PathSeparator+".ssh"+global.PathSeparator+"known_hosts file.\n\nSSH private identity file path (falls back to \""+fallbackSSHKey+"\"):")), fallbackSSHKey)
-		sshKeyIsFile, _, _ := back.TargetIsFile(sshKeyPath, false, 0) // error is ignored because errorOnFail is false
-		if !sshKeyIsFile {
-			return errors.New("SSH identity file not found: " + sshKeyPath)
+		_, err := back.TargetIsFile(sshKeyPath, true)
+		if err != nil {
+			return errors.New("unable to find SSH identity file: " + err.Error())
 		}
 
 		// get other ssh info from user

core/utilitiesMisc.go

@@ -156,15 +156,15 @@ func ClampTrailingWhitespace(note []string) {
 // Returns: statusCode (0 = success, 1 = target location already exists, 2 = containing directory is invalid).
 func EntryAddPrecheck(targetLocation string) (uint8, error) {
 	// ensure target location does not already exist
-	_, isAccessible, _ := back.TargetIsFile(targetLocation, false, 0) // error is ignored because errorOnFail is false
+	isAccessible, _ := back.TargetIsFile(targetLocation, false) // error is ignored because dir/file status is irrelevant
 	if isAccessible {
 		return 1, errors.New("target location already exists")
 	}
-	// ensure target containing directory exists and is a directory (not a file)
+	// ensure target containing directory exists and is not a file
 	containingDir := targetLocation[:strings.LastIndex(targetLocation, global.PathSeparator)]
-	isFile, isAccessible, _ := back.TargetIsFile(containingDir, false, 1) // error is ignored because errorOnFail is false
-	if isFile || !isAccessible {
-		return 2, errors.New("\"" + containingDir + "\" is not a valid containing directory")
+	_, err := back.TargetIsFile(containingDir, false)
+	if err != nil {
+		return 2, errors.New("\"" + containingDir + "\" is not a valid containing directory: " + err.Error())
 	}
 	return 0, nil
 }