remove the word basic from basic router

Author: Dashron

README.md

@@ -42,7 +42,7 @@ Roads is a simple web framework. It's similar to Express.js, but has some very i
   - [Parsing request bodies](#parsing-request-bodies)
     - [Parse Body Context](#parse-body-context)
   - [Remove trailing slash](#remove-trailing-slash)
-  - [Basic router](#basic-router)
+  - [Router](#router)
     - [applyMiddleware(road: *Road*)](#applymiddlewareroad-road)
     - [addRoute(method: *string*, path: *string*, fn: *function*)](#addroutemethod-string-path-string-fn-function)
     - [addRouteFile(filePath: *string*, prefix?: *string*)](#addroutefilefilepath-string-prefix-string)
@@ -547,8 +547,8 @@ var road = new Road();
 road.use(RemoveTrailingSlashMiddleware.middleware);
 ```
 
-## Basic router
-This is a basic router middleware for roads. It allows you to easily attach functionality to HTTP methods and paths.
+## Router
+This is a Router middleware for roads. It allows you to easily attach functionality to HTTP methods and paths.
 
 Here's how you use it.
 

example/ts/.gitignore

@@ -1 +1,2 @@
-public/*
+public/*
+types/*

example/ts/src/client.ts

@@ -6,7 +6,7 @@
  * This file is an example of using roads router in the client
  */
 
-import { Road, RoadsPJAX, ParseBodyMiddleware, BasicRouterMiddleware, CookieMiddleware, Request } from 'roads';
+import { Road, RoadsPJAX, ParseBodyMiddleware, RouterMiddleware, CookieMiddleware, Request } from 'roads';
 import applyPublicRotues from './routes/applyPublicRoutes';
 import emptyTo404 from './middleware/emptyTo404';
 
@@ -25,7 +25,7 @@ road.use(ParseBodyMiddleware.middleware);
 road.use(CookieMiddleware.buildClientMiddleware(document));
 pjax.register();
 pjax.registerAdditionalElement(document.getElementById('home') as HTMLAnchorElement);
-const router = new BasicRouterMiddleware.BasicRouter(road);
+const router = new RouterMiddleware.Router(road);
 applyPublicRotues(router);
 
 const testRequest = new Request(false, 'localhost', 8081);

example/ts/src/routes/applyPrivateRoutes.ts

@@ -9,7 +9,7 @@
 import * as fs from 'fs';
 import { CookieContext } from 'roads/types/middleware/cookieMiddleware';
 import { StoreValsContext } from 'roads/types/middleware/storeVals';
-import { BasicRouterMiddleware, Response } from 'roads';
+import { RouterMiddleware, Response } from 'roads';
 const TITLE_KEY = 'page-title';
 
 /**
@@ -19,7 +19,7 @@ const TITLE_KEY = 'page-title';
   *
   * @param {SimpleRouter} router - The router that the routes will be added to
   */
-export default function applyPrivateRotues(router: BasicRouterMiddleware.BasicRouter<StoreValsContext>): void {
+export default function applyPrivateRotues(router: RouterMiddleware.Router<StoreValsContext>): void {
 	router.addRoute<CookieContext>('GET', '/private', async function () {
 		this.storeVal(TITLE_KEY, 'Private Resource');
 		this.setCookie('private_cookie', 'foo', {

example/ts/src/routes/applyPublicRoutes.ts

@@ -6,7 +6,7 @@
  * This file is an example of how to assign some public routes to a roads server
  */
 
-import { Response, BasicRouterMiddleware } from 'roads';
+import { Response, RouterMiddleware } from 'roads';
 const TITLE_KEY = 'page-title';
 
 import { ParseBodyContext } from 'roads/types/middleware/parseBody';
@@ -24,7 +24,7 @@ interface ExampleRequestBody {
   *
   * @param {SimpleRouter} router - The router that the routes will be added to
   */
-export default function applyPublicRotues(router: BasicRouterMiddleware.BasicRouter<StoreValsContext>): void {
+export default function applyPublicRotues(router: RouterMiddleware.Router<StoreValsContext>): void {
 	router.addRoute('GET', '/', async function () {
 		this.storeVal(TITLE_KEY, 'Root Resource');
 

example/ts/src/server.ts

@@ -7,7 +7,7 @@
  */
 
 import { Road, Response, RemoveTrailingSlashMiddleware, CookieMiddleware,
-	StoreValsMiddleware, ParseBodyMiddleware, BasicRouterMiddleware } from 'roads';
+	StoreValsMiddleware, ParseBodyMiddleware, RouterMiddleware } from 'roads';
 
 import { Server } from 'roads-server';
 import addLayout from './middleware/addLayout';
@@ -28,7 +28,7 @@ road.use(StoreValsMiddleware.middleware);
 road.use(addLayout);
 road.use(ParseBodyMiddleware.middleware);
 
-const router = new BasicRouterMiddleware.BasicRouter(road);
+const router = new RouterMiddleware.Router(road);
 applyPublicRotues(router);
 applyPrivateRoutes(router);
 road.use(emptyTo404);

example/ts/types/build.d.ts

@@ -11,4 +11,4 @@ export * as ParseBodyMiddleware from './middleware/parseBody';
 export * as RerouteMiddleware from './middleware/reroute';
 export * as StoreValsMiddleware from './middleware/storeVals';
 export * as ModifiedSinceMiddleware from './middleware/modifiedSince';
-export * as BasicRouterMiddleware from './middleware/basicRouter';
+export * as RouterMiddleware from './middleware/router';

example/ts/types/buildClient.d.ts

@@ -1,9 +1,9 @@
 /**
- * basicRouter.ts
+ * router.ts
  * Copyright(c) 2021 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
- * This is a basic router middleware for roads.
+ * This is a  router middleware for roads.
  * 	It allows you to easily attach functionality to HTTP methods and paths.
  */
 
@@ -15,7 +15,7 @@ import { NextCallback, RequestChain } from '../core/requestChain';
 
 
 export interface Route<ContextType extends Context> {
-	(this: ContextType, method: string, path: BasicRouterURL, body: string,
+	(this: ContextType, method: string, path: RouterURL, body: string,
 		headers: IncomingHeaders, next: NextCallback): Promise<Response>
 }
 
@@ -25,14 +25,14 @@ interface RouteDetails {
 	method: string
 }
 
-export interface BasicRouterURL extends ReturnType<typeof parse> {
+export interface RouterURL extends ReturnType<typeof parse> {
 	args?: Record<string, string | number>
 }
 /**
- * This is a basic router middleware for roads.
- * You can assign functions to url paths, and those paths can have some very basic variable templating
+ * This is a router middleware for roads.
+ * You can assign functions to url paths, and those paths can have variable templating
  *
- * Templating is basic. Each URI is considered to be a series of "path parts" separated by slashes.
+ * There are only a couple of template options. Each URI is considered to be a series of "path parts" separated by slashes.
  * If a path part starts with a #, it is assumed to be a numeric variable. Non-numbers will not match this route
  * If a path part starts with a $, it is considered to be an alphanumeric variabe.
  * 		All non-slash values will match this route.
@@ -43,13 +43,13 @@ export interface BasicRouterURL extends ReturnType<typeof parse> {
  * /users/#user_id will match /users/12345, not /users/abcde. If a request is made to /users/12345
  * 	 the route's requestUrl object will contain { args: {user_id: 12345}} along with all other url object values
  *
- * @name BasicRouter
+ * @name Router
  */
-export class BasicRouter<RouterContextType extends Context> {
+export class Router<RouterContextType extends Context> {
 	protected _routes: RouteDetails[];
 
 	/**
-	 * @param {Road} [road] - The road that will receive the BasicRouter middleware
+	 * @param {Road} [road] - The road that will receive the Router middleware
 	 */
 	constructor (road?: Road) {
 		this._routes = [];
@@ -63,15 +63,15 @@ export class BasicRouter<RouterContextType extends Context> {
 	 * If you don't provide a road to the SimpleRouter constructor, your routes will not be executed.
 	 * 	If you have reason not to assign the road off the bat, you can assign it later with this function.
 	 *
-	 * @param  {Road} road - The road that will receive the BasicRouter middleware
+	 * @param  {Road} road - The road that will receive the Router middleware
 	 */
 	applyMiddleware (road: Road): void {
 		// We need to alias because "this" for the middleware function must
-		//		be the this applied by road.use, not the BasicRouter
+		//		be the this applied by road.use, not the Router
 		// eslint-disable-next-line @typescript-eslint/no-this-alias
 		const _self = this;
 
-		// We do this to ensure we have access to the BasicRouter once we lose this due to road's context
+		// We do this to ensure we have access to the Router once we lose this due to road's context
 		road.use((function (request_method, request_url, request_body, request_headers, next) {
 			return _self._middleware.call(this, _self._routes, request_method, request_url,
 				request_body, request_headers, next);
@@ -82,7 +82,7 @@ export class BasicRouter<RouterContextType extends Context> {
 	 * This is where you want to write the majority of your webservice. The `fn` parameter should contain
 	 * 	the actions you want to perform when a certain `path` and HTTP `method` are accessed via the `road` object.
 	 *
-	 * The path supports a very basic templating system. The values inbetween each slash can be interpreted
+	 * The path supports a templating system. The values inbetween each slash can be interpreted
 	 * 	in one of three ways
 	 *  - If a path part starts with a #, it is assumed to be a numeric variable. Non-numbers will not match this route
 	 *  - If a path part starts with a $, it is considered to be an alphanumeric variabe. All non-slash values
@@ -203,7 +203,7 @@ export class BasicRouter<RouterContextType extends Context> {
 /**
  * Checks to see if the route matches the request, and if true assigns any applicable url variables and returns the route
  *
- * @param {object} route - Route object from this basic router class
+ * @param {object} route - Route object from this router class
  * @param {object} route.method - HTTP method associated with this route
  * @param {object} route.path - HTTP path associated with this route
  * @param {object} request_url - Parsed HTTP request url
@@ -242,14 +242,14 @@ function compareRouteAndApplyArgs (route: {method: string, path: string}, reques
 			}
 
 			// TODO: get rid of this `as`
-			applyArg(request_url as BasicRouterURL, template_part.substring(1), Number(actual_part));
+			applyArg(request_url as RouterURL, template_part.substring(1), Number(actual_part));
 			continue;
 		}
 
 		if (template_part[0] === '$') {
 			// $ templates accept any non-slash alphanumeric character
 			// TODO: get rid of this `as`
-			applyArg(request_url as BasicRouterURL, template_part.substring(1), String(actual_part));
+			applyArg(request_url as RouterURL, template_part.substring(1), String(actual_part));
 			// Continue so that
 			continue;
 		}
@@ -272,7 +272,7 @@ function compareRouteAndApplyArgs (route: {method: string, path: string}, reques
  * @param {string} template_part - The template variable
  * @param {*} actual_part - The url value
  */
-function applyArg(request_url: BasicRouterURL, template_part: string, actual_part: string | number): void {
+function applyArg(request_url: RouterURL, template_part: string, actual_part: string | number): void {
 	if (typeof(request_url.args) === 'undefined') {
 		request_url.args = {};
 	}