Merge pull request #133 from postmanlabs/feature/fix-file-protocol

Parser: handle `file://` and `file:///` correctly

Author: codenirvana

CHANGELOG.yaml

@@ -1,3 +1,9 @@
+unreleased:
+  fixed bugs:
+    - >-
+      GH-133 Fixed a bug where slashes in the `file` protocol are handled
+      incorrectly
+
 3.0.2:
   date: 2021-07-14
   fixed bugs:

parser/index.js

@@ -24,7 +24,9 @@
 
 const ReplacementTracker = require('./replacement-tracker'),
 
-    REGEX_EXTRACT_VARS = /{{[^{}]*[.:/?#@&\]][^{}]*}}/g,
+    REGEX_ALL_BACKSLASHES = /\\/g,
+    REGEX_LEADING_SLASHES = /^\/+/,
+    REGEX_ALL_VARIABLES = /{{[^{}]*[.:/?#@&\]][^{}]*}}/g,
 
     HASH_SEPARATOR = '#',
     PATH_SEPARATOR = '/',
@@ -35,8 +37,10 @@ const ReplacementTracker = require('./replacement-tracker'),
     PROTOCOL_SEPARATOR = '://',
     AUTH_SEGMENTS_SEPARATOR = ':',
     QUERY_SEGMENTS_SEPARATOR = '&',
-    PROTOCOL_SEPARATOR_WITH_BACKSLASH = ':\\\\',
 
+    E = '',
+    STRING = 'string',
+    FILE_PROTOCOL = 'file',
     SAFE_REPLACE_CHAR = '_',
     CLOSING_SQUARE_BRACKET = ']',
     URL_PROPERTIES_ORDER = ['protocol', 'auth', 'host', 'port', 'path', 'query', 'hash'];
@@ -52,7 +56,7 @@ const ReplacementTracker = require('./replacement-tracker'),
  * @returns {String} Normalized string
  */
 function normalizeVariables (str, replacements) {
-    let normalizedString = '',
+    let normalizedString = E,
         pointer = 0, // pointer till witch the string is normalized
         variable,
         match,
@@ -61,7 +65,7 @@ function normalizeVariables (str, replacements) {
     // find all the instances of {{<variable>}} which includes reserved chars
     // "Hello {{user#name}}!!!"
     //  ↑ (pointer = 0)
-    while ((match = REGEX_EXTRACT_VARS.exec(str)) !== null) {
+    while ((match = REGEX_ALL_VARIABLES.exec(str)) !== null) {
         // {{user#name}}
         variable = match[0];
 
@@ -154,12 +158,14 @@ function parse (urlString) {
         },
         replacements = new ReplacementTracker(),
         pointer = 0,
+        protocol,
+        _length,
         length,
         index,
         port;
 
     // bail out if input string is empty
-    if (!(urlString && typeof urlString === 'string')) {
+    if (!(urlString && typeof urlString === STRING)) {
         return parsedUrl;
     }
 
@@ -191,32 +197,34 @@ function parse (urlString) {
     }
 
     // 3. url.protocol
+    urlString = urlString.replace(REGEX_ALL_BACKSLASHES, PATH_SEPARATOR); // sanitize slashes
+
+    // @todo support `protocol:host/path` and `protocol:/host/path`
     if ((index = urlString.indexOf(PROTOCOL_SEPARATOR)) !== -1) {
         // extract from the front
-        url.protocol.value = urlString.slice(0, index);
+        url.protocol.value = protocol = urlString.slice(0, index);
         url.protocol.beginIndex = pointer;
         url.protocol.endIndex = pointer + index;
 
         urlString = urlString.slice(index + 3);
         length -= index + 3;
         pointer += index + 3;
     }
-    // protocol can be separated using :\\ as well
-    else if ((index = urlString.indexOf(PROTOCOL_SEPARATOR_WITH_BACKSLASH)) !== -1) {
-        // extract from the front
-        url.protocol.value = urlString.slice(0, index);
-        url.protocol.beginIndex = pointer;
-        url.protocol.endIndex = pointer + index;
 
-        urlString = urlString.slice(index + 3);
-        length -= index + 3;
-        pointer += index + 3;
-    }
+    // special handling for leading slashes e.g, http:///example.com
+    _length = length; // length with leading slashes
 
-    // 4. url.path
-    urlString = urlString.replace(/\\/g, '/'); // sanitize path
-    urlString = urlString.replace(/^\/+/, ''); // remove leading slashes
+    urlString = urlString.replace(REGEX_LEADING_SLASHES,
+        (protocol && protocol.toLowerCase() === FILE_PROTOCOL) ?
+            // file:////path -> file:///path
+            PATH_SEPARATOR :
+            // protocol:////host/path -> protocol://host/path
+            E);
 
+    length = urlString.length; // length without slashes
+    pointer += _length - length; // update pointer
+
+    // 4. url.path
     if ((index = urlString.indexOf(PATH_SEPARATOR)) !== -1) {
         // extract from the back
         url.path.value = urlString.slice(index + 1).split(PATH_SEPARATOR);

test/unit/parser/parser.test.js

@@ -220,7 +220,7 @@ describe('parser', function () {
             });
         });
 
-        it('should handle handle protocol with backslashes', function () {
+        it('should handle protocol with backslashes', function () {
             expect(parser.parse('http:\\\\localhost')).to.deep.include({
                 raw: 'http:\\\\localhost',
                 protocol: 'http',
@@ -229,11 +229,11 @@ describe('parser', function () {
         });
 
         it('should handle extra slashes after protocol', function () {
-            expect(parser.parse('http:////localhost')).to.deep.include({
-                raw: 'http:////localhost',
+            expect(parser.parse('http:////localhost/foo')).to.deep.include({
+                raw: 'http:////localhost/foo',
                 protocol: 'http',
                 host: ['localhost'],
-                path: undefined
+                path: ['foo']
             });
         });
 
@@ -264,6 +264,33 @@ describe('parser', function () {
             });
         });
 
+        it('should handle file://host/foo', function () {
+            expect(parser.parse('file://host/foo')).to.deep.include({
+                raw: 'file://host/foo',
+                protocol: 'file',
+                host: ['host'],
+                path: ['foo']
+            });
+        });
+
+        it('should handle file:///foo/bar', function () {
+            expect(parser.parse('file:///foo/bar')).to.deep.include({
+                raw: 'file:///foo/bar',
+                protocol: 'file',
+                host: undefined,
+                path: ['foo', 'bar']
+            });
+        });
+
+        it('should handle file://///foo/bar', function () {
+            expect(parser.parse('file://///foo/bar')).to.deep.include({
+                raw: 'file://///foo/bar',
+                protocol: 'file',
+                host: undefined,
+                path: ['foo', 'bar']
+            });
+        });
+
         it('should return default object for empty string input', function () {
             expect(parser.parse('')).to.deep.include(defaultObject);
             expect(parser.parse('  ')).to.deep.include(defaultObject);

test/unit/toNodeUrl.test.js

@@ -749,5 +749,29 @@ describe('.toNodeUrl', function () {
                 href: 'https://example.com/foo/bar'
             });
         });
+
+        // Refer: https://en.wikipedia.org/wiki/File_URI_scheme#How_many_slashes?
+        it('should handle file://host/path and file:///path', function () {
+            expect(toNodeUrl('file://host/path')).to.include({
+                host: 'host',
+                hostname: 'host',
+                pathname: '/path',
+                href: 'file://host/path'
+            });
+
+            expect(toNodeUrl('file:///path')).to.include({
+                host: '',
+                hostname: '',
+                pathname: '/path',
+                href: 'file:///path'
+            });
+
+            expect(toNodeUrl('file:////foo/bar')).to.include({
+                host: '',
+                hostname: '',
+                pathname: '/foo/bar',
+                href: 'file:///foo/bar'
+            });
+        });
     });
 });