fixed a bug where a single slash between two components was removed from paths

Author: JonathanMontane

src/parsers/paw/Parser.js

@@ -421,10 +421,25 @@ methods.isPartOfBaseUrl = (defaultUrl, defaultSecureUrl, urlPart) => {
   return defaultUrl.indexOf(urlPart) >= 0 || defaultSecureUrl.indexOf(urlPart) >= 0
 }
 
-// NOTE: we assume that the urlPart is after the protocol
-methods.findIntersection = (defaultUrl, urlPart) => {
-  const match = (defaultUrl + '####' + urlPart).match(/^.*?(.*)####\1(.*)$/)
+/**
+ * finds the intersection between two strings, and returns the intersection, as well as the right-
+ * most exclusion. This is used to find the overlap between a host url and a part of a url
+ * associated with that host.
+ * @param {string} defaultUrl: the default url to test against.
+ * @param {string} defaultSecureUrl: the default secure url to test against.
+ * @param {string} urlPart: the part of url to test
+ * @returns {{ inside: string, outside: string }}
+ *
+ * Note: this assumes Paw only supports http and https.
+ * Note: this may work incorrectly if url is as follow: http://example.com/example.com/ (not tested)
+ */
+methods.findIntersection = (defaultUrl, defaultSecureUrl, urlPart) => {
+  let baseUrl = defaultUrl
+  if (urlPart.match(/^[^:]*s:\/\//)) {
+    baseUrl = defaultSecureUrl
+  }
 
+  const match = (baseUrl + '####' + urlPart).match(/^.*?(.*)####\1(.*)$/)
   // always matches
   return { inside: match[1], outside: match[2] }
 }
@@ -452,15 +467,18 @@ methods.addComponentToBaseOrPath = (
   { baseComponents, pathComponents },
   { key: urlPart, value: component }
 ) => {
-  if (methods.isPartOfBaseUrl(defaultUrl, defaultSecureUrl, urlPart)) {
+  if (
+    pathComponents.length === 0 &&
+    methods.isPartOfBaseUrl(defaultUrl, defaultSecureUrl, urlPart)
+  ) {
     // component is member of base url
     baseComponents.push({ key: urlPart, value: component })
     return { baseComponents, pathComponents }
   }
 
   if (pathComponents.length === 0) {
     // component may be split between base url and path
-    const { inside, outside } = methods.findIntersection(defaultUrl, urlPart)
+    const { inside, outside } = methods.findIntersection(defaultUrl, defaultSecureUrl, urlPart)
     baseComponents.push({ key: inside, value: inside })
     pathComponents.push({ key: outside, value: outside })
   }

src/parsers/paw/__tests__/Parser.spec.js

@@ -595,13 +595,28 @@ describe('parsers/paw/Parser.js', () => {
   describe('@findIntersection', () => {
     it('should work', () => {
       const defaultUrl = 'http://echo.paw.cloud/pets'
-      const inputs = [ '/pets', '/pets/234', '/234' ]
+      const defaultSecureUrl = 'https://echo.paw.cloud/pets'
+      const inputs = [
+        '/pets',
+        '/pets/234',
+        '/234',
+        // this one should be outside, because our intersection method tries to place strings so
+        // that they overlap from the right
+        'http://echo.paw.cloud',
+        'http://echo.paw.cloud/pets',
+        'https://echo.paw.cloud/pets'
+      ]
       const expected = [
         { inside: '/pets', outside: '' },
         { inside: '/pets', outside: '/234' },
-        { inside: '', outside: '/234' }
+        { inside: '', outside: '/234' },
+        { inside: '', outside: 'http://echo.paw.cloud' },
+        { inside: 'http://echo.paw.cloud/pets', outside: '' },
+        { inside: 'https://echo.paw.cloud/pets', outside: '' }
       ]
-      const actual = inputs.map(input => __internals__.findIntersection(defaultUrl, input))
+      const actual = inputs.map(
+        input => __internals__.findIntersection(defaultUrl, defaultSecureUrl, input)
+      )
       expect(actual).toEqual(expected)
     })
   })