Add tests for defaults and add support for explicit inclusion of default values in url generation

Author: Tobias Feijten

Resources/js/router.test.js

@@ -154,6 +154,53 @@ function testGenerateSupportsHostPlaceholdersDefaults() {
     assertEquals('http://api.localhost/foo/bar', router.generate('homepage'));
 }
 
+function testGenerateSupportsNonOptionalPlaceholderDefaults() {
+    var router = new fos.Router({base_url: '/foo', host: "localhost", scheme: "http"}, {
+        homepage: {
+            tokens: [['text', '/bar'],['variable', '/','', 'page']],
+            defaults: {page: 'api'},
+            requirements: {},
+            hosttokens: [
+                ['text', 'localhost']
+            ]
+        }
+    });
+
+    assertEquals('/foo/api/bar', router.generate('homepage'));
+}
+
+function testGenerateSupportsOptionalPlaceholderDefaults() {
+    var router = new fos.Router({base_url: '/foo', host: "localhost", scheme: "http"}, {
+        homepage: {
+            tokens: [['variable', '/','', 'page'],['text', '/bar']],
+            defaults: {page: 'api'},
+            requirements: {},
+            hosttokens: [
+                ['text', 'localhost']
+            ]
+        }
+    });
+
+    assertEquals('/foo/bar', router.generate('homepage'));
+}
+
+function testGenerateSupportsExplicitNonOptionalPlaceholderDefaults() {
+    var router = new fos.Router({base_url: '/foo', host: "localhost", scheme: "http"}, {
+        homepage: {
+            tokens: [['variable', '/','', '!page'],['text', '/bar']],
+            defaults: {page: 'api'},
+            requirements: {},
+            hosttokens: [
+                ['text', 'localhost']
+            ]
+        }
+    });
+
+    assertEquals('/foo/bar/api', router.generate('homepage'));
+}
+
+
+
 function testGenerateGeneratesRelativePathWhenTheSameHostGiven() {
     var router = new fos.Router({base_url: '/foo', host: "api.localhost", scheme: "http"}, {
         homepage: {

Resources/js/router.ts

@@ -202,6 +202,10 @@ export class Router {
       }
 
       if ('variable' === token[0]) {
+        if (typeof token[3] === 'string' && token[3][0] === '!') { // If parameter starts with exclamation mark, always include in path
+          token[3] = token[3].substring(1); // Remove the exclamation mark
+          optional = false;
+        }
         let hasDefault = route.defaults && !Array.isArray(route.defaults) && typeof token[3] === 'string' && (token[3] in route.defaults);
         if (false === optional || !hasDefault || ((typeof token[3] === 'string' && token[3] in params) && !Array.isArray(route.defaults) && params[token[3]] != route.defaults[token[3]])) {
           let value;

Resources/public/js/router.js

@@ -26,13 +26,13 @@ exports["default"] = exports.Routing = exports.Router = void 0;
 
 function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
 var Router = /*#__PURE__*/function () {
   function Router(context, routes) {
@@ -211,6 +211,12 @@ var Router = /*#__PURE__*/function () {
         }
 
         if ('variable' === token[0]) {
+          if (typeof token[3] === 'string' && token[3][0] === '!') {
+            token[3] = token[3].substring(1); // Remove the exclamation mark
+
+            optional = false;
+          }
+
           var hasDefault = route.defaults && !Array.isArray(route.defaults) && typeof token[3] === 'string' && token[3] in route.defaults;
 
           if (false === optional || !hasDefault || typeof token[3] === 'string' && token[3] in params && !Array.isArray(route.defaults) && params[token[3]] != route.defaults[token[3]]) {