Replace regex-based email matcher with state machine parser

Author: gregjacobs

gulpfile.js

@@ -293,7 +293,7 @@ function buildSrcMinifyUmdTask() {
 async function buildSrcCheckMinifiedSizeTask() {
 	const stats = await fs.stat( './dist/Autolinker.min.js' );
 	const sizeInKb = stats.size / 1000;
-	const maxExpectedSizeInKb = 44;
+	const maxExpectedSizeInKb = 46;
 
 	if( sizeInKb > maxExpectedSizeInKb ) {
 		throw new Error( `

src/htmlParser/parse-html.ts

@@ -1,5 +1,6 @@
 import { State } from './state';
 import { letterRe, digitRe, whitespaceRe, quoteRe, controlCharsRe } from '../regex-lib';
+import { throwUnhandledCaseError } from '../utils';
 
 // For debugging: search for other "For debugging" lines
 // import CliTable from 'cli-table';
@@ -108,7 +109,7 @@ export function parseHtml( html: string, { onOpenTag, onCloseTag, onText, onComm
 			case State.Doctype: stateDoctype( char ); break;
 
 			default: 
-				throwUnhandledStateError( state );
+				throwUnhandledCaseError( state );
 		}
 
 		// For debugging: search for other "For debugging" lines
@@ -127,14 +128,6 @@ export function parseHtml( html: string, { onOpenTag, onCloseTag, onText, onComm
 	//console.log( '\n' + table.toString() );
 
 
-	/**
-	 * Function that should never be called but is used to check that every
-	 * enum value is handled using TypeScript's 'never' type.
-	 */
-	function throwUnhandledStateError( state: never ) {
-		throw new Error( 'Unhandled State' )
-	}
-
 
 	// Called when non-tags are being read (i.e. the text around HTML †ags)
 	// https://www.w3.org/TR/html51/syntax.html#data-state

src/matcher/email-matcher.ts

@@ -1,8 +1,11 @@
 import { Matcher } from "./matcher";
-import { alphaNumericAndMarksCharsStr, getDomainNameStr } from "../regex-lib";
-import { tldRegex } from "./tld-regex";
+import { alphaNumericAndMarksCharsStr, domainNameCharRegex } from "../regex-lib";
 import { EmailMatch } from "../match/email-match";
 import { Match } from "../match/match";
+import { throwUnhandledCaseError } from '../utils';
+
+// For debugging: search for other "For debugging" lines
+// import CliTable from 'cli-table';
 
 /**
  * @class Autolinker.matcher.Email
@@ -15,49 +18,245 @@ import { Match } from "../match/match";
 export class EmailMatcher extends Matcher {
 
 	/**
-	 * The regular expression to match email addresses. Example match:
-	 *
-	 *     [email protected]
-	 *
-	 * @protected
-	 * @property {RegExp} matcherRegex
+	 * Valid characters that can be used in the "local" part of an email address,
+	 * i.e. the "name" part of "[email protected]"
 	 */
-	protected matcherRegex = (function() {
-		var specialCharacters = '!#$%&\'*+\\-\\/=?^_`{|}~',
-			restrictedSpecialCharacters = '\\s"(),:;<>@\\[\\]',
-			validCharacters = alphaNumericAndMarksCharsStr + specialCharacters,
-			validRestrictedCharacters = validCharacters + restrictedSpecialCharacters,
-		    emailRegex = new RegExp( '(?:[' + validCharacters + '](?:[' + validCharacters + ']|\\.(?!\\.|@))*|\\"[' + validRestrictedCharacters + '.]+\\")@');
-
-		return new RegExp( [
-			emailRegex.source,
-			getDomainNameStr( 1 ),
-			'\\.', tldRegex.source   // '.com', '.net', etc
-		].join( "" ), 'gi' );
-	} )();
+	protected localPartCharRegex = new RegExp( `[${alphaNumericAndMarksCharsStr}!#$%&'*+/=?^_\`{|}~-]` );
 
 
 	/**
 	 * @inheritdoc
 	 */
 	parseMatches( text: string ) {
-		let matcherRegex = this.matcherRegex,
-		    tagBuilder = this.tagBuilder,
-		    matches: Match[] = [],
-		    match: RegExpExecArray | null;
+		const tagBuilder = this.tagBuilder,
+			  localPartCharRegex = this.localPartCharRegex,
+			  matches: Match[] = [],
+			  len = text.length,
+			  noCurrentEmailAddress = new CurrentEmailAddress();
+
+		let charIdx = 0,
+			state = State.NonEmailAddress as State,
+			currentEmailAddress = noCurrentEmailAddress;
+
+		// For debugging: search for other "For debugging" lines
+		// const table = new CliTable( {
+		// 	head: [ 'charIdx', 'char', 'state', 'charIdx', 'currentEmailAddress.idx', 'hasDomainDot' ]
+		// } );
 
-		while( ( match = matcherRegex.exec( text ) ) !== null ) {
-			let matchedText = match[ 0 ];
+		while( charIdx < len ) {
+			const char = text.charAt( charIdx );
 
-			matches.push( new EmailMatch( {
-				tagBuilder  : tagBuilder,
-				matchedText : matchedText,
-				offset      : match.index,
-				email       : matchedText
-			} ) );
+			// For debugging: search for other "For debugging" lines
+			// table.push( 
+			// 	[ charIdx, char, State[ state ], charIdx, currentEmailAddress.idx, currentEmailAddress.hasDomainDot ] 
+			// );
+
+			switch( state ) {
+				case State.NonEmailAddress: stateNonEmailAddress( char ); break;
+				case State.LocalPart: stateLocalPart( char ); break;
+				case State.LocalPartDot: stateLocalPartDot( char ); break;
+				case State.AtSign: stateAtSign( char ); break;
+				case State.DomainChar: stateDomainChar( char ); break;
+				case State.DomainHyphen: stateDomainHyphen( char ); break;
+				case State.DomainDot: stateDomainDot( char ); break;
+	
+				default: 
+					throwUnhandledCaseError( state );
+			}
+
+			// For debugging: search for other "For debugging" lines
+			// table.push( 
+			// 	[ charIdx, char, State[ state ], charIdx, currentEmailAddress.idx, currentEmailAddress.hasDomainDot ] 
+			// );
+
+			charIdx++;
 		}
 
+		// Capture any valid match at the end of the string
+		captureMatchIfValidAndReset();
+
+		// For debugging: search for other "For debugging" lines
+		//console.log( '\n' + table.toString() );
+		
 		return matches;
+
+
+		// Handles the state when we're not in an email address
+		function stateNonEmailAddress( char: string ) {
+			if( localPartCharRegex.test( char ) ) {
+				beginEmailAddress();
+
+			} else {
+				// not an email address character, continue
+			}
+		}
+
+
+		// 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 ) {
+			if( char === '.' ) {
+				state = State.LocalPartDot;
+
+			} else if( char === '@' ) {
+				state = State.AtSign;
+
+			} else if( localPartCharRegex.test( char ) ) {
+				// stay in the "local part" of the email address
+
+			} else {
+				// not an email address character, return to "NonEmailAddress" state
+				resetToNonEmailAddressState();
+			}
+		}
+
+
+		// Handles the state where we've read 
+		function stateLocalPartDot( char: string ) {
+			if( char === '.' ) {
+				// We read a second '.' in a row, not a valid email address 
+				// local part
+				resetToNonEmailAddressState();
+
+			} else if( char === '@' ) {
+				// We read the '@' character immediately after a dot ('.'), not 
+				// an email address
+				resetToNonEmailAddressState();
+
+			} else if( localPartCharRegex.test( char ) ) {
+				state = State.LocalPart;
+
+			} else {
+				// Anything else, not an email address
+				resetToNonEmailAddressState();
+			}
+		}
+
+
+		function stateAtSign( char: string ) {
+			if( domainNameCharRegex.test( char ) ) {
+				state = State.DomainChar;
+
+			} else {
+				// Anything else, not an email address
+				resetToNonEmailAddressState();
+			}
+		}
+
+		function stateDomainChar( char: string ) {
+			if( char === '.' ) {
+				state = State.DomainDot;
+
+			} else if( char === '-' ) {
+				state = State.DomainHyphen;
+
+			} else if( domainNameCharRegex.test( char ) ) {
+				// Stay in the DomainChar state
+
+			} else {
+				// Anything else, we potentially matched if the criteria has
+				// been met
+				captureMatchIfValidAndReset();
+			}
+		}
+
+		function stateDomainHyphen( char: string ) {
+			if( char === '-' || char === '.' ) {
+				// Not valid to have two hyphens ("--") or hypen+dot ("-.")
+				captureMatchIfValidAndReset();
+
+			} else if( domainNameCharRegex.test( char ) ) {
+				state = State.DomainChar;
+
+			} else {
+				// Anything else
+				captureMatchIfValidAndReset();
+			}
+		}
+
+		function stateDomainDot( char: string ) {
+			if( char === '.' || char === '-' ) {
+				// not valid to have two dots ("..") or dot+hypen (".-")
+				captureMatchIfValidAndReset();
+
+			} else if( domainNameCharRegex.test( char ) ) {
+				state = State.DomainChar;
+
+				// After having read a '.' and then a valid domain character,
+				// 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, 
+					hasDomainDot: true 
+				} );
+
+			} else {
+				// Anything else
+				captureMatchIfValidAndReset();
+			}
+		}
+
+
+		function beginEmailAddress() {
+			state = State.LocalPart;
+			currentEmailAddress = new CurrentEmailAddress( { idx: charIdx } );
+		}
+
+		function resetToNonEmailAddressState() {
+			state = State.NonEmailAddress;
+			currentEmailAddress = noCurrentEmailAddress
+		}
+
+
+		/*
+		 * Captures the current email address as an EmailMatch if it's valid,
+		 * 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 emailAddress = text.slice( currentEmailAddress.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 );
+				}
+
+				matches.push( new EmailMatch( {
+					tagBuilder  : tagBuilder,
+					matchedText : emailAddress,
+					offset      : currentEmailAddress.idx,
+					email       : emailAddress
+				} ) );
+			}
+
+			resetToNonEmailAddressState();
+		}
 	}
 
 }
+
+
+const enum State {
+	NonEmailAddress = 0,
+	LocalPart,
+	LocalPartDot,
+	AtSign,
+	DomainChar,
+	DomainHyphen,
+	DomainDot
+}
+
+
+class CurrentEmailAddress {
+	readonly idx: number;  // the index of the first character in the email address
+	readonly hasDomainDot: boolean;
+
+	constructor( cfg: Partial<CurrentEmailAddress> = {} ) {
+		this.idx = cfg.idx !== undefined ? cfg.idx : -1;
+		this.hasDomainDot = !!cfg.hasDomainDot;
+	}
+}

src/regex-lib.ts

@@ -168,3 +168,10 @@ export const getDomainNameStr = ( group: number ) => {
  * Ex: 'google', 'yahoo', 'some-other-company', etc.
  */
 export const domainNameRegex = new RegExp( '[' + alphaNumericAndMarksCharsStr + '.\\-]*[' + alphaNumericAndMarksCharsStr + '\\-]' );
+
+
+/**
+ * A regular expression that is simply the character class of the characters
+ * that may be used in a domain name, minus the '-' or '.'
+ */
+export const domainNameCharRegex = new RegExp( `[${alphaNumericAndMarksCharsStr}]` );

src/utils.ts

@@ -127,3 +127,12 @@ export function splitAndCapture( str: string, splitRegex: RegExp ) {
 
 	return result;
 }
+
+
+/**
+ * Function that should never be called but is used to check that every
+ * enum value is handled using TypeScript's 'never' type.
+ */
+export function throwUnhandledCaseError( theValue: never ) {
+	throw new Error( `Unhandled case for value: '${theValue}'` );
+}

tests/autolinker-email.spec.ts

@@ -33,6 +33,13 @@ describe( "Autolinker Email Matching -", () => {
 	} );
 
 
+	it( "should automatically link email addresses with a period at the end of a sentence (but not include the period)", function() {
+		let result = autolinker.link( "Joe's email is [email protected]. Try emailing him" );
+
+		expect( result ).toBe( 'Joe\'s email is <a href="mailto:[email protected]">[email protected]</a>. Try emailing him' );
+	} );
+
+
 	it( "should automatically link email addresses with a period in the 'local part'", function() {
 		let result = autolinker.link( "Joe's email is [email protected]" );
 
@@ -88,6 +95,7 @@ describe( "Autolinker Email Matching -", () => {
 		expect( result ).toBe( 'Hi there@stuff' );
 	} );
 
+
 	it( "should automatically link an email address with tld matched localpart", function () {
 		let result = autolinker.link( "My email is [email protected]" );