Build the 'mailto:' matching into the EmailMatcher state machine

Author: gregjacobs

src/matcher/email-matcher.ts

@@ -23,26 +23,30 @@ export class EmailMatcher extends Matcher {
 	 */
 	protected localPartCharRegex = new RegExp( `[${alphaNumericAndMarksCharsStr}!#$%&'*+/=?^_\`{|}~-]` );
 
-	/**
-	 * Valid URI scheme for email address URLs
-	 */
-	protected mailToScheme : string = 'mailto:';
-
 
 	/**
 	 * @inheritdoc
 	 */
 	parseMatches( text: string ) {
 		const tagBuilder = this.tagBuilder,
 			  localPartCharRegex = this.localPartCharRegex,
-			  mailToScheme = this.mailToScheme,
 			  matches: Match[] = [],
 			  len = text.length,
-			  noCurrentEmailAddress = new CurrentEmailAddress();
+			  noCurrentEmailMatch = new CurrentEmailMatch();
+
+		// for matching a 'mailto:' prefix
+		const mailtoTransitions = {
+			'm': 'a',
+			'a': 'i',
+			'i': 'l',
+			'l': 't',
+			't': 'o',
+			'o': ':',
+		};
 
 		let charIdx = 0,
-			state = State.NonEmailAddress as State,
-			currentEmailAddress = noCurrentEmailAddress;
+			state = State.NonEmailMatch as State,
+			currentEmailMatch = noCurrentEmailMatch;
 
 		// For debugging: search for other "For debugging" lines
 		// const table = new CliTable( {
@@ -58,7 +62,11 @@ export class EmailMatcher extends Matcher {
 			// );
 
 			switch( state ) {
-				case State.NonEmailAddress: stateNonEmailAddress( char ); break;
+				case State.NonEmailMatch: stateNonEmailAddress( char ); break;
+
+				case State.Mailto: 
+					stateMailTo( text.charAt( charIdx - 1 ) as MailtoChar, char ); 
+					break;
 				case State.LocalPart: stateLocalPart( char ); break;
 				case State.LocalPartDot: stateLocalPartDot( char ); break;
 				case State.AtSign: stateAtSign( char ); break;
@@ -89,15 +97,62 @@ export class EmailMatcher extends Matcher {
 
 		// Handles the state when we're not in an email address
 		function stateNonEmailAddress( char: string ) {
-			if( localPartCharRegex.test( char ) ) {
-				beginEmailAddress();
+			if( char === 'm' ) {
+				beginEmailMatch( State.Mailto );
+
+			} else if( localPartCharRegex.test( char ) ) {
+				beginEmailMatch();
 
 			} else {
 				// not an email address character, continue
 			}
 		}
 
 
+		// Handles if we're reading a 'mailto:' prefix on the string
+		function stateMailTo( prevChar: MailtoChar, char: string ) {
+			if( prevChar === ':' ) {
+				// We've reached the end of the 'mailto:' prefix
+				if( localPartCharRegex.test( char ) ) {
+					state = State.LocalPart;
+					currentEmailMatch = new CurrentEmailMatch( { 
+						...currentEmailMatch, 
+						hasMailtoPrefix: true 
+					} );
+
+				} else {
+					// we've matched 'mailto:' but didn't get anything meaningful
+					// immediately afterwards (for example, we encountered a 
+					// space character, or an '@' character which formed 'mailto:@'
+					resetToNonEmailMatchState();
+				}
+
+			} else if( mailtoTransitions[ prevChar ] === char ) {
+				// We're currently reading the 'mailto:' prefix, stay in
+				// Mailto state
+				
+			} else if( localPartCharRegex.test( char ) ) {
+				// We we're reading a prefix of 'mailto:', but encountered a
+				// different character that didn't continue the prefix
+				state = State.LocalPart;
+
+			} else if( char === '.' ) {
+				// We we're reading a prefix of 'mailto:', but encountered a
+				// dot character
+				state = State.LocalPartDot;
+
+			} else if( char === '@' ) {
+				// We we're reading a prefix of 'mailto:', but encountered a
+				// an @ character
+				state = State.AtSign;
+
+			} else {
+				// not an email address character, return to "NonEmailAddress" state
+				resetToNonEmailMatchState();
+			}
+		}
+
+
 		// Handles the state when we're currently in the "local part" of an 
 		// email address (as opposed to the "domain part")
 		function stateLocalPart( char: string ) {
@@ -112,7 +167,7 @@ export class EmailMatcher extends Matcher {
 
 			} else {
 				// not an email address character, return to "NonEmailAddress" state
-				resetToNonEmailAddressState();
+				resetToNonEmailMatchState();
 			}
 		}
 
@@ -122,19 +177,19 @@ export class EmailMatcher extends Matcher {
 			if( char === '.' ) {
 				// We read a second '.' in a row, not a valid email address 
 				// local part
-				resetToNonEmailAddressState();
+				resetToNonEmailMatchState();
 
 			} else if( char === '@' ) {
 				// We read the '@' character immediately after a dot ('.'), not 
 				// an email address
-				resetToNonEmailAddressState();
+				resetToNonEmailMatchState();
 
 			} else if( localPartCharRegex.test( char ) ) {
 				state = State.LocalPart;
 
 			} else {
 				// Anything else, not an email address
-				resetToNonEmailAddressState();
+				resetToNonEmailMatchState();
 			}
 		}
 
@@ -145,7 +200,7 @@ export class EmailMatcher extends Matcher {
 
 			} else {
 				// Anything else, not an email address
-				resetToNonEmailAddressState();
+				resetToNonEmailMatchState();
 			}
 		}
 
@@ -192,8 +247,8 @@ export class EmailMatcher extends Matcher {
 				// we now know that the domain part of the email is valid, and
 				// we have found at least a partial EmailMatch (however, the
 				// email address may have additional characters from this point)
-				currentEmailAddress = new CurrentEmailAddress( { 
-					...currentEmailAddress, 
+				currentEmailMatch = new CurrentEmailMatch( { 
+					...currentEmailMatch, 
 					hasDomainDot: true 
 				} );
 
@@ -204,14 +259,14 @@ export class EmailMatcher extends Matcher {
 		}
 
 
-		function beginEmailAddress() {
-			state = State.LocalPart;
-			currentEmailAddress = new CurrentEmailAddress( { idx: charIdx } );
+		function beginEmailMatch( newState = State.LocalPart ) {
+			state = newState;
+			currentEmailMatch = new CurrentEmailMatch( { idx: charIdx } );
 		}
 
-		function resetToNonEmailAddressState() {
-			state = State.NonEmailAddress;
-			currentEmailAddress = noCurrentEmailAddress
+		function resetToNonEmailMatchState() {
+			state = State.NonEmailMatch;
+			currentEmailMatch = noCurrentEmailMatch;
 		}
 
 
@@ -220,47 +275,41 @@ export class EmailMatcher extends Matcher {
 		 * and resets the state to read another email address.
 		 */
 		function captureMatchIfValidAndReset() {
-			if( currentEmailAddress.hasDomainDot ) {  // we need at least one dot in the domain to be considered a valid email address
-				let offset = currentEmailAddress.idx;
-				let emailAddress = text.slice( offset, charIdx );
+			if( currentEmailMatch.hasDomainDot ) {  // we need at least one dot in the domain to be considered a valid email address
+				let matchedText = text.slice( currentEmailMatch.idx, charIdx );
 
 				// If we read a '.' or '-' char that ended the email address
 				// (valid domain name characters, but only valid email address
 				// characters if they are followed by something else), strip 
 				// it off now
-				if( /[-.]$/.test( emailAddress ) ){
-					emailAddress = emailAddress.slice( 0, -1 );
+				if( /[-.]$/.test( matchedText ) ){
+					matchedText = matchedText.slice( 0, -1 );
 				}
 
-				let matchedText = emailAddress;
-
-				// get the characters immediately preceding the email match
-				const potentialMailToSchemeOffset = offset - mailToScheme.length
-				const potentialMailToScheme = text.slice( potentialMailToSchemeOffset, offset );
-				if ( potentialMailToScheme === mailToScheme ) {
-					// if the email match is preceded by the 'mailTo:' scheme, 
-					// include those characters in the matched text
-					offset = potentialMailToSchemeOffset;
-					matchedText = text.slice( offset, charIdx );
-				}
+				const emailAddress = currentEmailMatch.hasMailtoPrefix 
+					? matchedText.slice( 'mailto:'.length ) 
+					: matchedText;
 
 				matches.push( new EmailMatch( {
 					tagBuilder  : tagBuilder,
 					matchedText : matchedText,
-					offset      : offset,
+					offset      : currentEmailMatch.idx,
 					email       : emailAddress
 				} ) );
 			}
 
-			resetToNonEmailAddressState();
+			resetToNonEmailMatchState();
 		}
 	}
 
 }
 
+type MailtoChar = 'm' | 'a' | 'i' | 'l' | 't' | 'o' | ':';
 
 const enum State {
-	NonEmailAddress = 0,
+	NonEmailMatch = 0,
+	
+	Mailto,  // if matching a 'mailto:' prefix
 	LocalPart,
 	LocalPartDot,
 	AtSign,
@@ -269,13 +318,14 @@ const enum State {
 	DomainDot
 }
 
-
-class CurrentEmailAddress {
+class CurrentEmailMatch {
 	readonly idx: number;  // the index of the first character in the email address
+	readonly hasMailtoPrefix: boolean;
 	readonly hasDomainDot: boolean;
 
-	constructor( cfg: Partial<CurrentEmailAddress> = {} ) {
+	constructor( cfg: Partial<CurrentEmailMatch> = {} ) {
 		this.idx = cfg.idx !== undefined ? cfg.idx : -1;
+		this.hasMailtoPrefix = !!cfg.hasMailtoPrefix;
 		this.hasDomainDot = !!cfg.hasDomainDot;
 	}
 }

tests/autolinker-email.spec.ts

@@ -102,4 +102,11 @@ describe( "Autolinker Email Matching -", () => {
 		expect( result ).toBe( 'My email is <a href="mailto:busueng.kim@aaa.com">busueng.kim@aaa.com</a>');
 	} );
 
+
+	it( "should automatically link an email address with a 'mailto:' prefix", function () {
+		let result = autolinker.link( "My email is mailto:asdf@asdf.com" );
+		
+		expect( result ).toBe( 'My email is <a href="mailto:asdf@asdf.com">asdf@asdf.com</a>');
+	} );
+
 } );

tests/matcher/email-matcher.spec.ts

@@ -242,14 +242,88 @@ describe( "Autolinker.matcher.Email", () => {
 			MatchChecker.expectEmailMatch( matches[ 0 ], 'asdf@asdf.com', 6 );
 		} );
 
-		it( 'should match mailto: scheme prefix', () => {
-			var matches = matcher.parseMatches( 'hello mailto:asdf@asdf.com there' );
+
+		it( 'when a match is prefixed with `mailto:`, should include that in the match (via the offset)', () => {
+			let matches = matcher.parseMatches( 'Hello mailto:asdf@asdf.com' );
 
 			expect( matches.length ).toBe( 1 );
 			MatchChecker.expectEmailMatch( matches[ 0 ], 'asdf@asdf.com', 6 );
+			expect( matches[ 0 ].getMatchedText() ).toBe( 'mailto:asdf@asdf.com' );
 		} );
 
-	} );
 
+		it( 'when a match is prefixed with `mailto` *without* a colon and it ' +
+			'is a valid email address, should match it', 
+		() => {
+			let matches = matcher.parseMatches( 'Hello mailtoasdf@asdf.com' );
+
+			expect( matches.length ).toBe( 1 );
+			MatchChecker.expectEmailMatch( matches[ 0 ], 'mailtoasdf@asdf.com', 6 );
+		} );
+
+
+		it( 'when a match is simply the string `mailto:` *without* any characters ' +
+		    'after it, should not match it', 
+		() => {
+			let matches = matcher.parseMatches( 'Hello mailto: other stuff' );
+
+			expect( matches.length ).toBe( 0 );
+		} );
+
+
+		it( 'when a match is the string `mailto:@something.com`, should not ' +
+		    'match it as it is invalid', 
+		() => {
+			let matches = matcher.parseMatches( 'Hello mailto:@asdf.com' );
+
+			expect( matches.length ).toBe( 0 );
+		} );
+
+
+		'mailto'.split( '' ).forEach( ( char, idx ) => {
+			const partialMailto = 'mailto'.substring( 0, idx + 1 );
+
+			it( `when a match is prefixed with a partial of 'mailto:' ('${partialMailto}') ` + 
+			    `and it is a valid email address, should match it`, 
+			() => {
+				let matches = matcher.parseMatches( `Hello ${partialMailto}@asdf.com` );
+
+				expect( matches.length ).toBe( 1 );
+				MatchChecker.expectEmailMatch( matches[ 0 ], `${partialMailto}@asdf.com`, 6 );
+			} );
+
+
+			it( `when a match is prefixed with a partial of 'mailto:' ('${partialMailto}') ` + 
+				`with other valid email address characters after it, and it is a valid ` +
+				`email address, should match it`, 
+			() => {
+				let matches = matcher.parseMatches( `Hello ${partialMailto}asdf@asdf.com` );
+
+				expect( matches.length ).toBe( 1 );
+				MatchChecker.expectEmailMatch( matches[ 0 ], `${partialMailto}asdf@asdf.com`, 6 );
+			} );
+
+
+			it( `when a match is prefixed with a partial of 'mailto:' ('${partialMailto}') ` + 
+				`with a dot after it (a valid email address character), and it is a valid ` +
+				`email address, should match it`, 
+			() => {
+				let matches = matcher.parseMatches( `Hello ${partialMailto}.asdf@asdf.com` );
+
+				expect( matches.length ).toBe( 1 );
+				MatchChecker.expectEmailMatch( matches[ 0 ], `${partialMailto}.asdf@asdf.com`, 6 );
+			} );
+
+
+			it( `when a match is prefixed with a partial of 'mailto:' ('${partialMailto}') ` + 
+			    `but then a space is encountered to end the email address, should not match it`, 
+			() => {
+				let matches = matcher.parseMatches( `Hello ${partialMailto} asdf.com` );
+
+				expect( matches.length ).toBe( 0 );
+			} );
+		} );
+
+	} );
 
 } );