Home>PHP source code>Other categories
Download

Router @ minasrouter

the

minasrouter is simple, fast and extremely readable for routes. Create and manage your routes in just a few steps.

Simple, fast and VERY functional. minasrouter is a PHP routes component for MVC projects! It was made to abstract the RESTfull verbs (GET, POST, PUT, PATCH, DELETE) and render in a simple and easy way in the application controller.

minasrouter works and processes all information in isolation, making the process easier for the developer and accelerating the development/progress of the project.

Simple, fast and VERY functional. minasrouter is a PHP routes component for MVC projects! It is designed to abstract the RESTfull (GET, POST, PUT, PATCH, DELETE) verbs and render them simply and easily in the application controller.

minasrouter works and processes all information in isolation, facilitating the process for the developer and accelerating the development/progress of the project.

Highlights @ minasrouter

  • In a few minutes you can create routes for your application or api (Yes, it really is a few minutes)
  • Fast and Easy middleware system
  • Respect the RESTfull verbs and have great functions to deal with them
  • Route customization, regex in dynamic parameters and optional parameters
  • Spoofing for verbalization and data control (FormSpoofing)
  • Carries dynamic parameters to controller arguments
  • Easy routing groups and fast create
  • It has a Request Class to control and work with route data

With two lines you start using routes!

Application example

Maybe you are a person who learns by watching, you can access the example folder, which contains a folders architecture example of how we use minasrouter .

Tests

You can check all tests done here. Enjoy!

Installation

minasrouter is available via Composer require :

minasrouter": "^1.0" }">
 " require " {
    "nicollassilva/ minasrouter " : " ^1.0 "
}

or run in terminal : 

composer require nicollassilva/ minasrouter

Documentation

1.Configuration

  • Redirect to Public Folder
  • Public Folder Configuration
  • Apache
  • Nginx

2. Routes

  • My first route
  • RESTfull Verbs
  • Customization
  • Named Routes
  • Dynamic Parameters (Required and Optional)
  • Validating a Dynamic Parameter
  • Middleware
  • Set Global Middlewares
  • Attach in a route
  • Delete the middleware
  • Route Groups
  • All Methods
  • Named Group
  • Prefixed Group
  • Default Namespace Group
  • Default Middleware Group
  • Nested Group Methods
  • Others
  • Route Redirect
  • Route with Individual Middleware in Group
  • Route with Different Name in Group
  • Fallback Routes

3. Request Route

  • Introduction
  • Methods
  • RequestPath
  • Request URL
  • Request Headers
  • Request IP Address
  • Retrieving Data
  • Request Method

Introduction

To start using minasrouter , all navigation management must be redirected to your system's default route file, which will carry out the entire route processing process and return what was configured by default. Configure according to the examples below and according to your server.

To start using minasrouter , all navigation management must be redirected to your system's default route file, which will do the entire route handling process and return what was configured by default. Configure according to the examples below and according to your server.

Redirect to Public Folder 

 RewriteEngine on
Options All -Indexes

RewriteCond %{HTTPS} on
RewriteCond %{HTTP_HOST} (www.)?localhost
RewriteRule (.*) https:// %{HTTP_HOST} [L,R=301]

RewriteCond %{REQUEST_URI} !public/
RewriteRule (.*) /public/$1 [L]

apache 

 RewriteEngine On
# Options All -Indexes

# Handle Authorization Header
RewriteCond %{HTTP:Authorization} .
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

# URL Rewrite
RewriteCond %{SCRIPT_FILENAME} !-f
RewriteCond %{SCRIPT_FILENAME} !-d
RewriteRule ^(.*)$ index.php?route=/$1 [L,QSA]

# ## Do not use the settings below if you are using developing in a local environment, use only in production.

# # WWW Redirect
# RewriteCond %{HTTP_HOST} !^www. [NC]
# RewriteRule ^ https://www.%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

# # HTTPS Redirect
# RewriteCond %{HTTP:X-Forwarded-Proto} !https
# RewriteCond %{HTTPS} off
# RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

nginx 

 location / {
  if ( $script_filename !~ "-f" ){
    rewrite ^(.*)$ /index.php?route=/ $1 break;
  }
}

The first route

To start the components:

minasrouterRouterRoute; // The second argument is optional. It separates the Controller and Method from the string // Example: "Controller@method" Route::start("http://yourdomain.com", "@"); Route::get("/", function() { // ... }); // ... all routes here // You will put all your routes before this function Route::execute();">
 <?php
    require __DIR__ . " /../vendor/autoload.php " ;
    
use minasrouter  Router  Route ;

// The second argument is optional. It separates the Controller and Method from the string
// Example: "Controller@method"
Route:: start ( " http://yourdomain.com " , " @ " );

Route:: get ( " / " , function () {
    // ...
});

// ... all routes here

// You will put all your routes before this function
Route:: execute ();

RESTfull Verbs

Methods:

Function Parameter Parameter Parameter
get String $uri $callback
post String $uri $callback
put String $uri $callback
patch String $uri $callback
delete String $uri $callback
match Array $httpVerbs String $uri $callback
any String $uri $callback

Example: 

Route:: get ( ' /users ' , [ App  Controllers User::class, ' index ' ]);
Route:: post ( ' /users ' , [ App  Controllers User::class, ' store ' ]);
Route:: put ( ' /users/{id} ' , [ App  Controllers User::class, ' update ' ]);
Route:: patch ( ' /users/{id} ' , [ App  Controllers User::class, ' update ' ]);
Route:: delete ( ' /users/{id} ' , [ App  Controllers User::class, ' delete ' ]);

// The router allows you to register routes that respond to any HTTP verb:
Route:: any ( ' / ' , function () {
    // ...
});

// Sometimes you may need to register a route that responds to multiple HTTP verbs:
Route:: match ([ " GET " , " POST " ], " / " , function () {
    // ...
});

Named routes

Methods:

Function Parameter
name String $name
to the String $name

Example: 

Route:: get ( " /users/create " , function () {
    // ...
})-> name ( " user.create " );

Route:: get ( " /users/2 " , function () {
    // ...
})-> as ( " user.show " );

Dynamic parameters (required and optional) 

Route:: get ( " / " , function () {
    // ...
})-> name ( " web.index " );

Route:: get ( " /user/{id} " , function ( $ id ) {
    echo $ id ;
})-> name ( " user.show " );

Route:: get ( " /post/{id?} " , function ( $ id ) {
    if (! $ id ) {
        // ...
    }
    
    // ...
})-> name ( " post.show " );

Validating a dynamic parameter

Methods:

Function Parameter Parameter
where Array $params
whereParam String $param String $regex
whereNumber String $param
whereAlpha String $param
whereAlphaNumeric String $param
whereUuid String $param

Example: 

Route:: get ( " /user/{id} " , [ App  Controllers UserController::class, " show " ])
    -> name ( " user.show " )
    -> where ([ " id " => " [0-9]+ " ]);

// whereParam is alias of where method
Route:: get ( " /profile/{slug} " , [ App  Controllers UserController::class, " profile " ])
    -> name ( " user.profile " )
    -> whereParam ( " id " , " [0-9]+ " );

Route:: get ( " /book/{id} " , [ App  Controllers BookController::class, " show " ])
    -> name ( " book.show " )
    -> whereNumber ( " id " );

Middleware

Working with middlewares around here is pretty easy, we just need to pass the full names of the classes or set them as global, and from there, we use their alias.

Set Global Middlewares

NOTE: It is important that you place all routes below. Routes above this class will not have these middlewares as global. 

Route:: globalMiddlewares ([
    ' isLogged ' =>  App  Middlewares isLogged::class,
    ' isAdmin ' =>  App  Middlewares isAdmin::class
]);

// ... all routes

Attach in a route

You may use the middleware method to assign middleware to a route. 

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ( " isLogged " );

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ([ " isLogged " ]);

You can assign multiple middleware to the route by passing an array of middleware names to the middleware method. 

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ( " first, second " );

Route:: get ( " /movies " , function () {
    // ...
})-> middleware ([ " first " , " second " ]);

When assigning middleware, you may also pass the fully qualified class name: 

 use App  Middlewares  VerifyCsrfToken ;

Route:: get ( " /series " , function () {
    // ...
})-> middleware (VerifyCsrfToken::class);

Route:: get ( " /series " , function () {
    // ...
})-> middleware ( App  Middlewares VerifyCsrfToken::class);

Delete the middleware

Sometimes you create a group of routes with middleware, but you want only one or a few routes to be without a specific middleware, you can do that. 

Route:: middleware ([ ' auth ' , ' api ' ])-> group ( function () {
    Route:: get ( ' / ' , function () {
        // All middlewares will works in this route
    });
    
    Route:: get ( ' /no-api ' , function () {
        // Only the auth middleware works here
    })-> withoutMiddleware ( ' api ' );
});

Route Groups

All methods:

Function Parameter ::function ->function
namespace String $namespace Yes Yes
prefix String $prefix Yes Yes
name String $name Yes Yes
middleware String $middlewares Yes Yes

Group methods can be called static way or normal, don't forget to call a function group to insert as routes inside the closure.

Examples:

named group 

Route:: name ( " admin. " )-> group ( function () {
    Route:: get ( " / " , function () {
        // admin.index
    })-> name ( " index " );
});

prefixed group 

Route:: prefix ( " admin/ " )-> group ( function () {
    Route:: get ( " /index " , function () {
        // http://localhost/admin/index
    })-> name ( " index " );
});

Default namespace group 

Route:: namespace ( " AppControllers " )-> group ( function () {
    Route:: get ( " /user/{id} " , [ " User " , " show " ])-> name ( " show " );
    // AppControllersUser
});

Default Middleware group 

Route:: middleware ( App  Middlewares isLogged::class)-> group ( function () {
    Route:: get ( " /user/{id} " , [ " User " , " show " ])-> name ( " show " );
});

Nested group methods 

Route:: namespace ( " AppControllersAdmin " )
    -> middleware ([ " isLogged " , " isAdmin " ])
    -> name ( " admin. " )
    -> prefix ( " admin " )
    -> group ( function () {
    // ...
});

Others

Route with Individual Middleware in group

You can use routes with individual middlewares within a route group. 

Route:: namespace ( " isLogged " )-> group ( function () {
    Route:: get ( " /posts " , function () {
        // ...
    })-> middleware ( " isAdmin " );
    
    // ...
});

Route with Different name in group

Maybe you are wanting a route where you ignore the group name, you can use the second parameter of the name method for that. 

Route:: name ( " admin. " )-> group ( function () {
    Route:: get ( " /posts " , function () {
        // name: app.posts
    })-> name ( " app.posts " , true );
});

Route redirect

Methods:

Function Parameter Parameter Parameter
redirect String $uri String $redirect Int $statusCode = 302
permanentRedirect String $uri String $redirect

Example: 

 // Returns 302 status code by default.
Route:: redirect ( " /here " , " /there " );

Route:: redirect ( " /here " , " /there " , 301 );

// permanentRedirect always returns 301
Route:: permanentRedirect ( " /here " , " /there " );

// You can return an existing route
Route:: redirect ( " /index " , " web.index " );

Fallback Routes

The fallback route is responsible when there is no route registered with that url address. Whenever there is no route that was requested by the user, the fallback route will be called. 

Route:: fallback ( function () {
    echo ' Route error! ' ;
    // ...
});

NOTE: Be careful if you want to redirect to an existing route, if it contains dynamic arguments, it will return the entire regex and will cause an error.

Be careful you redirect to an existing route, because if it has dynamic arguments, it will return the entire regex and error returned.

Request Route

Each time the route is called and the Closure or controller method is called, you will have as a parameter an instance of minasrouter HttpRequest. If the route has dynamic parameters (mandatory or optional), they need to be passed before receiving the Request instance.

Function Parameter Parameter
getParams
path
url
fullUrl
header String $header String $default
hasHeader String $header
ip
query ?String $query ?String $default
all ?String $except
getMethod
isMethod String $expectedMethod

The dynamic parameters of the route are directly passed in the method together with an instance of Request.

Example:

minasrouterHttpRequest; Route::get("/", function(Request $request)) { // ... }); Route::get("/user/{id}", function($id, Request $request)) { // ... }); Route::get("/posts/{slug?}", function($slug, Request $request)) { // ... }); Route::get("/book/{slug}", function($slug, Request $request) { // Retrieving all dynamic parameters print_r($request->getParams()); }); ">
 use  minasrouter  Http  Request ;

Route:: get ( " / " , function ( Request $ request )) {
   // ... 
});

Route:: get ( " /user/{id} " , function ( $ id , Request $ request )) {
   // ... 
});

Route:: get ( " /posts/{slug?} " , function ( $ slug , Request $ request )) {
   // ... 
});

Route:: get ( " /book/{slug} " , function ( $ slug , Request $ request ) {
    // Retrieving all dynamic parameters
    print_r ( $ request -> getParams ());
});

The Request method is the method that has all your form data, query parameters, dynamic route parameters, and the entire request header.

Request Methods

Retrieving The Request Path

The path method returns the request's path information. So, if the incoming request is targeted at http://localhost/foo/bar , the path method will return foo/bar : 

 $ uri = $ request -> path ();

Retrieving The Request URL

To retrieve the full URL for the incoming request you may use the url or fullUrl methods. The url method will return the URL without the query string, while the fullUrl method includes the query string: 

 $ url = $ request -> url ();

$ urlWithQueryString = $ request -> fullUrl ();

Request Headers

You may retrieve a request header from the minasrouter HttpRequest instance using the header method. If the header is not present on the request, null will be returned. However, the header method accepts an optional second argument that will be returned if the header is not present on the request: 

 $ value = $ request -> header ( " Header-Name " );

$ value = $ request -> header ( " Header-Name " , " default " );

The hasHeader method may be used to determine if the request contains a given header: 

 if ( $ request -> hasHeader ( " Header-Name " )) {
    // ...
}

The bearerToken method may be used to retrieve a bearer token from the Authorization header. If no such header is present, null will be returned. 

 $ token = $ request -> bearerToken ();

Request IP Address

The ip method may be used to retrieve the IP address of the client that made the request to your website: 

 $ ipAddress = $ request -> ip ();

Retrieving Data

The query method will only retrieve values ​​from the query string: 

 $ id = $ request -> query ( " id " );

If the requested query string value data is not present, the second argument to this method will be returned: 

 $ developer = $ request -> query ( " developer " , " Nicollas " );

You may call the query method without any arguments in order to retrieve all of the query string values. 

 $ query = $ request -> query ();

You can access queryString's and input data directly, how properties of the Request class.

minasrouter"> $title = $request->title;">
 // http://localhost/?foo=bar

$ foo = $ request -> foo ;

// <input type="text" name="title" value=" minasrouter ">

$ title = $ request -> title ;

You may retrieve all of the incoming request's input data as an array using the all method. This method may be used regardless of whether the incoming request is from an HTML form or is an XHR request. If you want to nullify some data, you can pass it as a second parameter. 

 $ data = $ request -> all ();

// all, except csrf_token, page
$ data = $ request -> all ( " csrf_token, page " );

Retrieving The Request Method

The getMethod method will return the HTTP verb for the request. You may use the isMethod method to verify that the HTTP verb matches a given string: 

 $ httpMethod = $ request -> getMethod ();

if ( $ request -> isMethod ( ' POST ' )) {
    // ...
}
Expand
Additional Information
Related Applications
Recommended for You
Related Information All