Improve code coverage, working on truncate-smart.ts

gregjacobs · gregjacobs · commit 94eb3cd346b3 · 2025-04-25T20:16:33.000-04:00
diff --git a/.nycrc b/.nycrc
@@ -4,7 +4,6 @@
         "text",
         "text-summary",
         "html",
-        "json-summary",
         "lcovonly"
     ],
     "report-dir": "coverage",
diff --git a/README.md b/README.md
@@ -4,6 +4,7 @@
 [![build](https://github.com/gregjacobs/Autolinker.js/actions/workflows/main.yml/badge.svg)](https://github.com/gregjacobs/Autolinker.js/actions/workflows/main.yml)
 [![NPM Downloads](https://img.shields.io/npm/dw/autolinker)](https://www.npmjs.com/package/autolinker)
 [![GitHub License](https://img.shields.io/github/license/gregjacobs/Autolinker.js)](https://github.com/gregjacobs/Autolinker.js/blob/master/LICENSE)
+<!--[![codecov](https://codecov.io/github/gregjacobs/Autolinker.js/graph/badge.svg?token=6sqLqa2oeb)](https://codecov.io/github/gregjacobs/Autolinker.js)-->
 
 Because I had so much trouble finding a good auto-linking implementation out in
 the wild, I decided to roll my own. It seemed that everything I found out there
diff --git a/src/htmlParser/parse-html.ts b/src/htmlParser/parse-html.ts
@@ -159,6 +159,7 @@ export function parseHtml(
                 stateDoctype(char);
                 break;
 
+            /* istanbul ignore next */
             default:
                 assertNever(state);
         }
diff --git a/src/match/hashtag-match.ts b/src/match/hashtag-match.ts
@@ -100,10 +100,10 @@ export class HashtagMatch extends AbstractMatch {
             case 'youtube':
                 return 'https://youtube.com/hashtag/' + hashtag;
 
+            /* istanbul ignore next */
             default:
-                // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case
+                // Should never happen because Autolinker's constructor should block any invalid values, but just in case
                 assertNever(serviceName);
-                throw new Error(`Invalid hashtag service: ${serviceName}`);
         }
     }
 
diff --git a/src/match/mention-match.ts b/src/match/mention-match.ts
@@ -95,10 +95,10 @@ export class MentionMatch extends AbstractMatch {
             case 'youtube':
                 return 'https://youtube.com/@' + this.mention;
 
+            /* istanbul ignore next */
             default:
-                // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case.
+                // Should never happen because Autolinker's constructor should block any invalid values, but just in case.
                 assertNever(this.serviceName);
-                throw new Error('Unknown service name to point mention to: ' + this.serviceName);
         }
     }
 
diff --git a/src/parser/parse-matches.ts b/src/parser/parse-matches.ts
@@ -215,6 +215,7 @@ export function parseMatches(text: string, args: ParseMatchesArgs): Match[] {
                         statePhoneNumberPoundChar(stateMachine, char);
                         break;
 
+                    /* istanbul ignore next */
                     default:
                         assertNever(stateMachine.state);
                 }
@@ -920,6 +921,7 @@ export function parseMatches(text: string, args: ParseMatchesArgs): Match[] {
                     return; // not a valid match
                 }
             } else {
+                /* istanbul ignore next */
                 assertNever(urlMatchType);
             }
 
@@ -994,6 +996,7 @@ export function parseMatches(text: string, args: ParseMatchesArgs): Match[] {
                 );
             }
         } else {
+            /* istanbul ignore next */
             assertNever(stateMachine);
         }
     }
diff --git a/src/truncate/truncate-smart.ts b/src/truncate/truncate-smart.ts
@@ -23,108 +23,56 @@ export function truncateSmart(url: string, truncateLen: number, ellipsisChars?:
         ellipsisLengthBeforeParsing = ellipsisChars.length;
     }
 
-    let parse_url = function (url: string) {
-        // Functionality inspired by PHP function of same name
-        let urlObj: UrlObject = {};
-        let urlSub = url;
-        let match = urlSub.match(/^([a-z]+):\/\//i);
-        if (match) {
-            urlObj.scheme = match[1];
-            urlSub = urlSub.substr(match[0].length);
-        }
-        match = urlSub.match(/^(.*?)(?=(\?|#|\/|$))/i);
-        if (match) {
-            urlObj.host = match[1];
-            urlSub = urlSub.substr(match[0].length);
-        }
-        match = urlSub.match(/^\/(.*?)(?=(\?|#|$))/i);
-        if (match) {
-            urlObj.path = match[1];
-            urlSub = urlSub.substr(match[0].length);
-        }
-        match = urlSub.match(/^\?(.*?)(?=(#|$))/i);
-        if (match) {
-            urlObj.query = match[1];
-            urlSub = urlSub.substr(match[0].length);
-        }
-        match = urlSub.match(/^#(.*?)$/i);
-        if (match) {
-            urlObj.fragment = match[1];
-            //urlSub = urlSub.substr(match[0].length);  -- not used. Uncomment if adding another block.
-        }
-        return urlObj;
-    };
-
-    let buildUrl = function (urlObj: UrlObject) {
-        let url = '';
-        if (urlObj.scheme && urlObj.host) {
-            url += urlObj.scheme + '://';
-        }
-        if (urlObj.host) {
-            url += urlObj.host;
-        }
-        if (urlObj.path) {
-            url += '/' + urlObj.path;
-        }
-        if (urlObj.query) {
-            url += '?' + urlObj.query;
-        }
-        if (urlObj.fragment) {
-            url += '#' + urlObj.fragment;
-        }
-        return url;
-    };
-
-    let buildSegment = function (segment: string, remainingAvailableLength: number) {
-        let remainingAvailableLengthHalf = remainingAvailableLength / 2,
-            startOffset = Math.ceil(remainingAvailableLengthHalf),
-            endOffset = -1 * Math.floor(remainingAvailableLengthHalf),
-            end = '';
-        if (endOffset < 0) {
-            end = segment.substr(endOffset);
-        }
-        return segment.substr(0, startOffset) + ellipsisChars + end;
-    };
+    // If the URL is shorter than the truncate length, return it as is
     if (url.length <= truncateLen) {
         return url;
     }
+
     let availableLength = truncateLen - ellipsisLength;
-    let urlObj = parse_url(url);
-    // Clean up the URL
+    let urlObj = parseUrl(url);
+
+    // Clean up the URL by removing any malformed query string
+    // (e.g. "?foo=bar?ignorethis")
     if (urlObj.query) {
-        let matchQuery = urlObj.query.match(/^(.*?)(?=(\?|\#))(.*?)$/i);
+        let matchQuery = urlObj.query.match(/^(.*?)(?=(\?|#))(.*?)$/i);
         if (matchQuery) {
             // Malformed URL; two or more "?". Removed any content behind the 2nd.
             urlObj.query = urlObj.query.substr(0, matchQuery[1].length);
             url = buildUrl(urlObj);
         }
     }
     if (url.length <= truncateLen) {
-        return url;
+        return url; // removing a malformed query string brought the URL under the truncateLength
     }
+
+    // Clean up the URL by removing 'www.' from the host if it exists
     if (urlObj.host) {
         urlObj.host = urlObj.host.replace(/^www\./, '');
         url = buildUrl(urlObj);
     }
     if (url.length <= truncateLen) {
-        return url;
+        return url; // removing 'www.' brought the URL under the truncateLength
     }
-    // Process and build the URL
-    let str = '';
+
+    // Process and build the truncated URL, starting with the hostname
+    let truncatedUrl = '';
     if (urlObj.host) {
-        str += urlObj.host;
+        truncatedUrl += urlObj.host;
     }
-    if (str.length >= availableLength) {
-        if ((urlObj.host as string).length == truncateLen) {
-            return (
-                (urlObj.host as string).substr(0, truncateLen - ellipsisLength) + ellipsisChars
-            ).substr(0, availableLength + ellipsisLengthBeforeParsing);
+    if (truncatedUrl.length >= availableLength) {
+        if (urlObj.host!.length === truncateLen) {
+            return (urlObj.host!.substr(0, truncateLen - ellipsisLength) + ellipsisChars).substr(
+                0,
+                availableLength + ellipsisLengthBeforeParsing
+            );
         }
-        return buildSegment(str, availableLength).substr(
+        return buildSegment(truncatedUrl, availableLength, ellipsisChars).substr(
             0,
             availableLength + ellipsisLengthBeforeParsing
         );
     }
+
+    // If we still have available chars left, add the path and query string
     let pathAndQuery = '';
     if (urlObj.path) {
         pathAndQuery += '/' + urlObj.path;
@@ -133,53 +81,133 @@ export function truncateSmart(url: string, truncateLen: number, ellipsisChars?:
         pathAndQuery += '?' + urlObj.query;
     }
     if (pathAndQuery) {
-        if ((str + pathAndQuery).length >= availableLength) {
-            if ((str + pathAndQuery).length == truncateLen) {
-                return (str + pathAndQuery).substr(0, truncateLen);
+        if ((truncatedUrl + pathAndQuery).length >= availableLength) {
+            if ((truncatedUrl + pathAndQuery).length == truncateLen) {
+                return (truncatedUrl + pathAndQuery).substr(0, truncateLen);
             }
-            let remainingAvailableLength = availableLength - str.length;
-            return (str + buildSegment(pathAndQuery, remainingAvailableLength)).substr(
-                0,
-                availableLength + ellipsisLengthBeforeParsing
-            );
+            let remainingAvailableLength = availableLength - truncatedUrl.length;
+            return (
+                truncatedUrl + buildSegment(pathAndQuery, remainingAvailableLength, ellipsisChars)
+            ).substr(0, availableLength + ellipsisLengthBeforeParsing);
         } else {
-            str += pathAndQuery;
+            truncatedUrl += pathAndQuery;
         }
     }
+
+    // If we still have available chars left, add the fragment
     if (urlObj.fragment) {
         let fragment = '#' + urlObj.fragment;
-        if ((str + fragment).length >= availableLength) {
-            if ((str + fragment).length == truncateLen) {
-                return (str + fragment).substr(0, truncateLen);
+        if ((truncatedUrl + fragment).length >= availableLength) {
+            if ((truncatedUrl + fragment).length == truncateLen) {
+                return (truncatedUrl + fragment).substr(0, truncateLen);
             }
-            let remainingAvailableLength2 = availableLength - str.length;
-            return (str + buildSegment(fragment, remainingAvailableLength2)).substr(
-                0,
-                availableLength + ellipsisLengthBeforeParsing
-            );
+            let remainingAvailableLength2 = availableLength - truncatedUrl.length;
+            return (
+                truncatedUrl + buildSegment(fragment, remainingAvailableLength2, ellipsisChars)
+            ).substr(0, availableLength + ellipsisLengthBeforeParsing);
         } else {
-            str += fragment;
+            truncatedUrl += fragment;
         }
     }
+
+    // If we still have available chars left, add the scheme
     if (urlObj.scheme && urlObj.host) {
         let scheme = urlObj.scheme + '://';
-        if ((str + scheme).length < availableLength) {
-            return (scheme + str).substr(0, truncateLen);
+        if ((truncatedUrl + scheme).length < availableLength) {
+            return (scheme + truncatedUrl).substr(0, truncateLen);
         }
     }
-    if (str.length <= truncateLen) {
-        return str;
+    if (truncatedUrl.length <= truncateLen) {
+        return truncatedUrl;
     }
+
     let end = '';
     if (availableLength > 0) {
-        end = str.substr(-1 * Math.floor(availableLength / 2));
+        end = truncatedUrl.substr(-1 * Math.floor(availableLength / 2));
     }
-    return (str.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(
+    return (truncatedUrl.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(
         0,
         availableLength + ellipsisLengthBeforeParsing
     );
 }
 
+/**
+ * Parses a URL into its components: scheme, host, path, query, and fragment.
+ */
+function parseUrl(url: string): UrlObject {
+    // Functionality inspired by PHP function of same name
+    let urlObj: UrlObject = {};
+    let urlSub = url;
+
+    // Parse scheme
+    let match = urlSub.match(/^([a-z]+):\/\//i);
+    if (match) {
+        urlObj.scheme = match[1];
+        urlSub = urlSub.slice(match[0].length);
+    }
+
+    // Parse host
+    match = urlSub.match(/^(.*?)(?=(\?|#|\/|$))/i);
+    if (match) {
+        urlObj.host = match[1];
+        urlSub = urlSub.slice(match[0].length);
+    }
+
+    // Parse path
+    match = urlSub.match(/^\/(.*?)(?=(\?|#|$))/i);
+    if (match) {
+        urlObj.path = match[1];
+        urlSub = urlSub.slice(match[0].length);
+    }
+
+    // Parse query
+    match = urlSub.match(/^\?(.*?)(?=(#|$))/i);
+    if (match) {
+        urlObj.query = match[1];
+        urlSub = urlSub.slice(match[0].length);
+    }
+
+    // Parse fragment
+    match = urlSub.match(/^#(.*?)$/i);
+    if (match) {
+        urlObj.fragment = match[1];
+        //urlSub = urlSub.slice(match[0].length);  -- not used. Uncomment if adding another block.
+    }
+
+    return urlObj;
+}
+
+function buildUrl(urlObj: UrlObject): string {
+    let url = '';
+    if (urlObj.scheme && urlObj.host) {
+        url += urlObj.scheme + '://';
+    }
+    if (urlObj.host) {
+        url += urlObj.host;
+    }
+    if (urlObj.path) {
+        url += '/' + urlObj.path;
+    }
+    if (urlObj.query) {
+        url += '?' + urlObj.query;
+    }
+    if (urlObj.fragment) {
+        url += '#' + urlObj.fragment;
+    }
+    return url;
+}
+
+function buildSegment(segment: string, remainingAvailableLength: number, ellipsisChars: string) {
+    let remainingAvailableLengthHalf = remainingAvailableLength / 2,
+        startOffset = Math.ceil(remainingAvailableLengthHalf),
+        endOffset = -1 * Math.floor(remainingAvailableLengthHalf),
+        end = '';
+    if (endOffset < 0) {
+        end = segment.substr(endOffset);
+    }
+    return segment.substr(0, startOffset) + ellipsisChars + end;
+}
+
 interface UrlObject {
     scheme?: string;
     host?: string;
diff --git a/src/utils.ts b/src/utils.ts
@@ -100,6 +100,6 @@ export function removeWithPredicate<T>(arr: T[], fn: (item: T) => boolean) {
  * Function that should never be called but is used to check that every
  * enum value is handled using TypeScript's 'never' type.
  */
-export function assertNever(theValue: never) {
+export function assertNever(theValue: never): never {
     throw new Error(`Unhandled case for value: '${theValue}'`);
 }
diff --git a/tests/truncate/truncate-smart.spec.ts b/tests/truncate/truncate-smart.spec.ts
@@ -20,6 +20,18 @@ describe('Truncate.truncate.truncateSmart', function () {
         expect(truncatedUrl.length).toBe(72);
     });
 
+    it(`when just a hostname is present and it's exactly the truncate length, should return it as-is`, () => {
+        let truncatedUrl = truncateSmart('yahoo.com', 'yahoo.com'.length, '..');
+
+        expect(truncatedUrl).toBe('yahoo.com');
+    });
+
+    it(`when the hostname is exactly the truncate length but there's also a scheme, should ellipsis the hostname while removing the scheme`, () => {
+        let truncatedUrl = truncateSmart('http://yahoo.com', 'yahoo.com'.length, '..');
+
+        expect(truncatedUrl).toBe('yahoo.c..');
+    });
+
     it('Will remove malformed query section 1st', function () {
         let truncatedUrl = truncateSmart(
             'http://www.yahoo.com/some/long/path/to/a/file?foo=bar?ignorethis#baz=bee',

Original file line number	Diff line number	Diff line change
`@@ -159,6 +159,7 @@ export function parseHtml(`
`159`	`159`	`stateDoctype(char);`
`160`	`160`	`break;`
`161`	`161`
	`162`	`+ /* istanbul ignore next */`
`162`	`163`	`default:`
`163`	`164`	`assertNever(state);`
`164`	`165`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,10 +100,10 @@ export class HashtagMatch extends AbstractMatch {`
`100`	`100`	`case 'youtube':`
`101`	`101`	`return 'https://youtube.com/hashtag/' + hashtag;`
`102`	`102`
	`103`	`+ /* istanbul ignore next */`
`103`	`104`	`default:`
`104`		`- // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case`
	`105`	`+ // Should never happen because Autolinker's constructor should block any invalid values, but just in case`
`105`	`106`	`assertNever(serviceName);`
`106`		- throw new Error(`Invalid hashtag service: ${serviceName}`);
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
Original file line number	Diff line number	Diff line change
`@@ -95,10 +95,10 @@ export class MentionMatch extends AbstractMatch {`
`95`	`95`	`case 'youtube':`
`96`	`96`	`return 'https://youtube.com/@' + this.mention;`
`97`	`97`
	`98`	`+ /* istanbul ignore next */`
`98`	`99`	`default:`
`99`		`- // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case.`
	`100`	`+ // Should never happen because Autolinker's constructor should block any invalid values, but just in case.`
`100`	`101`	`assertNever(this.serviceName);`
`101`		`- throw new Error('Unknown service name to point mention to: ' + this.serviceName);`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
Original file line number	Diff line number	Diff line change
`@@ -215,6 +215,7 @@ export function parseMatches(text: string, args: ParseMatchesArgs): Match[] {`
`215`	`215`	`statePhoneNumberPoundChar(stateMachine, char);`
`216`	`216`	`break;`
`217`	`217`
	`218`	`+ /* istanbul ignore next */`
`218`	`219`	`default:`
`219`	`220`	`assertNever(stateMachine.state);`
`220`	`221`	`}`
`@@ -920,6 +921,7 @@ export function parseMatches(text: string, args: ParseMatchesArgs): Match[] {`
`920`	`921`	`return; // not a valid match`
`921`	`922`	`}`
`922`	`923`	`} else {`
	`924`	`+ /* istanbul ignore next */`
`923`	`925`	`assertNever(urlMatchType);`
`924`	`926`	`}`
`925`	`927`
`@@ -994,6 +996,7 @@ export function parseMatches(text: string, args: ParseMatchesArgs): Match[] {`
`994`	`996`	`);`
`995`	`997`	`}`
`996`	`998`	`} else {`
	`999`	`+ /* istanbul ignore next */`
`997`	`1000`	`assertNever(stateMachine);`
`998`	`1001`	`}`
`999`	`1002`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,6 +100,6 @@ export function removeWithPredicate<T>(arr: T[], fn: (item: T) => boolean) {`
`100`	`100`	`* Function that should never be called but is used to check that every`
`101`	`101`	`* enum value is handled using TypeScript's 'never' type.`
`102`	`102`	`*/`
`103`		`-export function assertNever(theValue: never) {`
	`103`	`+export function assertNever(theValue: never): never {`
`104`	`104`	throw new Error(`Unhandled case for value: '${theValue}'`);
`105`	`105`	`}`