install¶

You need composer to install Briz.

$ composer create-project briz/briz helloworld

this command creates briz inside the directory helloworld.

Basic Hello world¶

This version uses echo instead of PSR-7 response object. edit index.php in www directory.

<?php
//autoload the required files
require './vendor/autoload.php';

// create a new application instance
    $app = new Briz\App();

//create a router with the name web
$app->route("web", function($router){

    //a route for GET requests to '/'

            $router->get('/',function($b){
                    echo "Hello World";
            });
 });

//run the application
$app->run();

PSR-7 Hello World¶

this version uses built in PSR-7 response object. edit index.php in www directory.

<?php
   //autoload the required files
   require './vendor/autoload.php';

   // create a new application instance
       $app = new Briz\App();

   //create a router with the name web
   $app->route("web", function($router){

       //a route for GET requests to '/'

               $router->get('/',function($b){
                       $b->response->write("hello world");
               });
    });

   $app->run();

Hello World with Renderer¶

this version uses renderer so that we can use view. edit index.php in www directory. some framework features requires usage of renderer to work.

<?php
//autoload the required files
require './vendor/autoload.php';

// create a new application instance
    $app = new Briz\App();

//create a router with the name gen
$app->route("gen", function($router){

    //a route for GET requests to '/'

            $router->get('/',function($b){
                    $b->renderer('hello');
            });
 });

$app->run();

now create a directory gen (router name) inside MyApp/views and create a file hello.view.php in it with any content like this one,

hello world

HelloWorld with controller¶

<?php
//autoload the required files
require './vendor/autoload.php';

// create a new application instance
    $app = new Briz\App();

//create a router with the name gen
$app->route("gen", function($router){

    //a route for GET requests to '/'
            $router->get('/','HelloController@sayHello');
 });

$app->run();

now create a file (controller) HelloController.php in MyApp/Controllers directory.

<?php
namespace MyApp\Controllers;

use Briz\Concrete\BController;
class HelloController extends BController
{
    public function sayHello()
    {
        $this->response->write("hello world");
    }
}

more¶

usage of Briz framework for creating a web app and simple mobile api at the same time is explained in Quick Start

Installation¶

You can install Briz using composer which is the recommended way.

$ composer create-project briz/briz quickstart

replace the quickstart with the path to the directory you want to install. this will install all depandancies and make it ready to run.

if you like the other way you can use git-repository . clone it or use download zip option. then run the following command after navigating to the target directory (after extracting th zip if you did it in that way),

$ composer install

Running¶

You can easily run Briz navigating to www direcory and run the php Development Server. assuming the code is at the directory quickstart, if you prefer other servers such as apache don’t frogetpoint it to www

$ cd quickstart/www
$ php -S localhost:8000

now navigate to http://localhost:8000 using your favourite browser. you can see the Briz web page running.

Code¶

now use your favourite editor to open www/index.php. the default code in this file will be enough, since we are using the same code for this quickstart. let me explain,

<?php
require '../vendor/autoload.php';
$app = new Briz\App();

$app->route("web", function($router){
    $router->get('/',function($briz){
        $data = 'hello';
        $briz->renderer('hello',['title'=>'Welcome to Briz Framework',
            'content'=>'Thanks for using Briz Framework. You can Learn More at Our Documentaion Page ',
            'link'=>'http://briz.readthedocs.org/en/latest/'
        ]);
    });
});

$app->run();

$app->route('mobile',function($router){

         // Identify using header identity.
         // if a header With X-Request-Cli with value android encountered then it will use this router
         $router->identify('header','X-Request-Cli','mobile');

         //now the responses will be rendererd as json
     $router->setRenderer('JsonView');
 },'web');

<html>
<body>
<script>
var request = new XMLHttpRequest();
var path = "http://localhost:8000";
request.onreadystatechange = function(){
if(request.readyState == 4 && request.status == 200)
{
    document.getElementById('yt').innerHTML = request.responseText;
}
};
request.open("GET",path,true);
request.setRequestHeader("X-Request-Cli","mobile");
request.send();

</script>
<p id ="yt">loading...</p>
</body>

Routing¶

in modern web frameworks all requests will be handled by a router. in our case there are two files in www folder 1 is an .htaccess file and other is an index.php file all requests to this web server will come to the access point index.php since it is the only web accessable part. so without .htaccess file our typcal request will be localhost:8000/index.php/hello but our .htaccess file passess all requests to index.php if there is no file extension such as .php .js etc. so we will have to use only localhost:8000/hello instead of localhost:8000/index.php/hello.

well, that is not the routing we are talking about. routing is done by router component. it generates appropriate responses based on the request for this it uses the url after localhost:8000 here it is /hello. so if create a route for /hello it defines what should we do when our request reaches localhost:800/hello.

you can find more about routing at Routing page.

controller¶

controllers controlls the route. it is the main component of the system. when a request is recived by index.php it is passed to the router. router finds an appropriate controller to do actions related to the path in the url. and then this controller decides what to do. in Briz you can pass set a controller in two ways. as a callback function or as a Controller class. the

//Using Controller as a callback
$router->get('/{name}',function($briz){
                $briz->render('hello',['name' => 'briz->']);
});

//Using Controller as a class
$router->get('/profile/{name}','ProfileController@show');

‘’

when using a controller as a callback you are using can use passed $briz to handle rendering. then when using controller as a class it should be stored in the controller namespace. by default it is at MyApp\controllers so you should store it there. the ProfileController@show shows that we should use the public method show in the controller class named ProfileController

we have another options of using to directly define route in $app->route() that will be explained in Routing section. more on controllers can be found at Controllers page.

Views¶

Views are all about how the data is sent to the user. in a typical MVC workflow the application logic is seperated from view. we pass the output generated from controller to the view. The renderer is responsible for rendering the view. view_engines or renderers decide how to process the input. the default view_engines consists of components like ParsedView and JsonView for rendering html and JSON respectively.

Basic Routing¶

The App::route() will create a new router with the name specified. we can use this router to create routes.

lets discuss about basic routing,

$app = new Briz\App();
$app->route("web", function($router){
        //code
        $router->get('/','IndexController@show');
   });

that will create a router with the name web. inside it you can specify routes. here $router->get('/','IndexController@show'); is such a route

the second argument to the above method can be an anonymous function or a controller. if a controller is used the above code will change to

$app = new Briz\App();
$app->route("web", "SomeController");

where SomeController is the controller name . if so routes will be generated from the controller. see Controller Routing below. but i think the anonymous function version is better because it provides more flexibility. that was my personal opinion. you can use anything you like.

$router->get('/details','IndexController@show');

$router->get('/details',function($b){
               $b->renderer('index',['title'=>'home']);
}

$router->post('/','IndexController@create');

//example of a put route

$router->put('/','IndexController@edit');

//example of a delete route

$router->delete('/','IndexController@delete');

//example of options route

$router->options('/','IndexController@show');

//example of patch route

$router->patch('/','IndexController');

$router->any('/help','HelpController');

$router->set(['GET','POST'],'/help','HelpController');

Controller Routing¶

It is possible to pass router directly to a controller. I am assuming you read Controllers before reading this resource.

when a router is directly passed to a Controller. the controller will have to generate routes. for this we use Docblock. Here @Route is used to specify a route

<?php
namespace MyApp\Controllers;

use Briz\Concrete\BController;

class AdminController extends BController
{
   /**
    * @Route [get]
    */
    public function index()
    {
        $this->response->write('Administration Panel');
    }

   /**
    *
    * @Use app
    * @Route [get,post]
    */
    public function details($app,$n)
    {
        $this->renderer('details',[]);
    }
}

here the comma seperated values in @Route inside [] in the doc block is used as HTTP methods to resolve routes. these routes are resolved as /admin since the first method name is index and /admin/details/{name} . the first part is the name of the controller before Controller in lower case. here it is admin. the second part is the name of the method. and last part is parameters passed to it. if there are n number of @Use anotation then first n parameters will be discarded. here it discards the $app in details this way

Route Inheritance¶

The first parameter passed to $app->route() is route name. the second parameter is controller and the third parameter is parent. the parent should be name of another router.

a child route will have all the properties of its parent. including routes and identities. as stated in Quick Start the main advatage of this is to extend current route.

if a child route matches then its parent will be ignored.

Route Patterns¶

//static route matches only /hello
$route->get('/hello','handler');

//dynamic route matches with hello/*
$route->get('/hello/{name}','handler');

// Matches /user/42, but not /user/xyz
$r->get('/user/{id:\d+}', 'handler');

// Matches /user/foobar, but not /user/foo/bar
$r->get('/user/{name}', 'handler');

// Matches /user/foo/bar as well
$r->get('/user/{name:.+}', 'handler');

// This route
$r->get('/user/{id:\d+}[/{name}]', 'handler');
// Is equivalent to these two routes
$r->get('/user/{id:\d+}', 'handler');
$r->get('/user/{id:\d+}/{name}', 'handler');

// This route is NOT valid, because optional parts can only occur at the end
$r->get('/user[/{id:\d+}]/{name}', 'handler');

Basics¶

You must specify a controller directly from router or pass router to controller.

to specify a controller from router

$app = new App();
$app->route('name',function($r){
        $r->get('/','IndexController');
        $r->get('/contact','IndexController@contact');
},'parent',$args);

IndexController@contact means the contact method at IndexController

here a router instance is passed to $r and using $r->get() we set route / to IndexController since no method is specified it will use the default index method. next we set /contact to contact method of IndexController. @ is the spererator to identify controller from action (action is another name commonly used for methods inside a controller)

Or we pass the controller to router.

$app = new App();
$app->route('admin','AdminController');

here we passed the router to AdminController . more about controller routing is available at Controller Routing section.

Creating a controller¶

a controller must be inside controller namespace which is by default MyApp\Controllers if you look at MyApp/Controllers directory you can see a file ErrorsController Dont delete that file. it is your responsibility to care that file. you can edit it in the way you want but dont delete it.

back to creating controller. the controller should extend Briz\Concrete\BController. if you dont do so nothing is wrong. it will still work. but you will not get access to some helper methods such as renderer() and show404()

basic structure of a controller is as follows

namespace MyApp\Controllers;

use Briz\Concrete\BController;

class IndexController extends BController
{
   /**
    * Index Page
    */
    public function index()
    {
       $this->renderer('index',['param'=>'value']);
    }

   /**
    * Contact page.
    *
    * @Use app
    */
    public function contact($app)
    {
        $data = $app;
        $this->renderer('index',['name'=>$app]);
    }
}

this is our IndexController with the routes we defined above in Basics . index method will match with the route / and contact method will match with the route /contact if used with the routes defined above. if you want to know what is the @Use in the docblock above the function contact, read the section below.

Dependancy Injection and Passing Values¶

Dependancies are the components used by the Briz. In Briz adding a dependancy is very easy. dependancies are added using the config files in config directory. there is a container for storing all the dependancies. every value stored in this container can be accessed

consider there are two routes /profile and /profile/{name} for get method (see Route Patterns). which will point to the methods index and showProfile in the controller ProfileController

namespace MyApp\Controllers;

use Briz\Concrete\BController;

/**
 * Profile controller
 *
 * @Use auth
 */
class ProfileController extends BController
{
   /**
    * Index Page
    *
    * @Use membership
    */
    public function index($mem)
    {
       $min = $mem->type();
       $name = $this->auth->getname();
       $this->renderer('profile',['name'=>$name,'mem'=>$min]);
    }

   /**
    * show profile.
    *
    * @Use app_name
    */
    public function showProfile($app,$name)
    {
        $data = $app;
        $this->renderer('index',['name'=>$app,'user'=>$name]);
    }
}

we can pass dependancies using @Use in docblock. it specifies which components should be loaded from container. by default you will have request and response dependancies injected. you can pass more using @Use. here we use two imaginary components auth and membership. if we want a dependancy available everywhere in the class the @Use can be used above the class as in the example above. in that case it will be in the form $component where component is the key for the value stored in the container use it as $this->component inside a method. when the dependancy is only needed inside a method we can pass it using @Use above the method. in that case it will be passed to the arguments in the function. if there are two injections then it will be passed to first two function parameters in order. this is done by the internal ControllerResolver which resolves the controller for router.

the showProfile method has one parameter from @Use and one from /profile/{name} the parameter from route will be stored to $name in that method. which means the @Use parameters will be resolved before route parameters

there is no limit on what should be stored in container. here app_name is a string storing the application name. you can edit it inside config/application.php.

Available Methods¶

The Following Methods are Available from BController class. if you create a new Response object then there must a return statement with that Response or set $this->response to that object.

public function show($name)
{
    if($this->notFound($name)
    {
        return $this->show404();
    }
}

public function show($name,$redirectUrl)
{
    if($this->isAuthorized)
    {
        return $this->redirect($redirectUrl);
    }
}

public function show($name,$redirectUrl)
{
    $params = $arrayOrObject;
    $this->renderer('hello',$params);
}

ParsedView¶

ParsedView is a class which uses view directory. it checks if the view file exists and parses array or object to variables to the file. it then stores it’s output to response.

if we call renderer like

$b->renderer('hello',['name'=>'haseeb','greet'=>'hello']);

if the name of the router is web. it will check inside views/web for the file hello.view.php and converts the array to variables. so, we can use it in view file like $greet and $name. if our view file contains,

<?php
echo "$greet $name";
?>

it will output

hello haseeb

JsonView¶

the JsonView will generate output in JSON format and sets a Json content-type header. this will not use any files.

DirectView¶

This view is not of much use. it will just write to response evrything thrown at it. it expects an array to be single dimentional.

View Configuration¶

the view configurations should be stored inside config\view.php

If you open this file you can find what are the values stored init.

Creating an identity¶

for example lets create a simple identity for checking port number

create a directory Identities under MyApp and create a file PortIdentity.php

 <?php
 namespace MyApp\Identities;

 use Briz\Base\Identity;

/**
 * Identity for checking port values.
 */
 class PortIdentity extends Identity
 {
     /**
     * Check for port.
     *
     * @param int $port
     * @return bool
     */
     public function identify($port, $v='')
     {
        $request = $this->container->get('request');
         if($request->getUri()->getPort() == $port){
             return true;
         }
         return false;
     }
 }

This code checks if a specific port $port is matched with the port number in the request.$v is initialized with blank value because IdentityInterface for identities requires two parameters for method identify().

at first, we need to register the identity. for this edit config\identities.php and add a key port and set its value to our class name with namespace. Then this file will look like,

<?php
return [
    'header' => 'Briz\Beam\HeaderIdentity',
    'port' => 'MyApp\Identities\PortIdentity'
];

next in your Quick Start file (or the default www/index.php when briz is installed ). edit the line for checking identity.

//$router->identify('header','X-Request-Cli','mobile');

$router->identify('port',8080,'');

just like above we had to pass a blank third parameter inside $router->identify(). now use PHP Development Server to go to localhost:8000 by

$ php -S localhost:8000

and then after exiting, goto localhost:8080 by typing

$ php -S localhost:8080

check both and see the difference yourself. Now you have created your first Identity.

Using Identities outsite Route¶

you can also use identities outside the Route. for that, you have to use IdentityTrait. As traits provide automated copy paste in php. we can use IdentityTrait to add some methods and variables for accessing Identity to your Controller.

adding the trait.

class IdentityController
{
    use \Briz\Beam\IdentityTrait;

    public function idcheck()
    {
        //code goes here.
    }
}

the use \Briz\Beam\IdentityTrait; will add the identity management trait for your controller.

now, you have the following methods and two protected arrays $identifies, the list of identites registered with the class and $idt_keyIndex, the key index

Creating a Provider¶

Since there is no default model in Briz, I decided to add it first. it is the M in any MVC framework (Model View Controller). models are classes which should work with data. mainly they are used for communicating with database. since we dont have it by default, it is just VC. so to make it MVC we are adding a model.

there are two types of models which are widely used

1. Active Record.
2. Data mapper.

php-active-record and Eloquent are examples of active record type models. spot-2 and doctrine are examples of data mapper approch.

Both are good and have thier own advantages and disadvantages. you have to find it yourself. here i am going to add php active record as a provider in example.

<?php
namespace MyApp\Providers;

use Activerecord;

class PhpAR
{
    /**
     * @param string $root root directory
     * @param string $app user directory name
     */
    public static function register($root,$app)
    {
        $cfg = ActiveRecord\Config::instance();
        $cfg->set_model_directory($root.'/'.$app.'/Models');
        $cfg->set_connections(
            array(
                'development' => 'mysql://dev:dev@localhost/bridge',
                'test' => 'mysql://username:password@localhost/test_database_name',
                'production' => 'mysql://username:password@localhost/production_database_name'
            )
        );
        $cfg->set_default_connection('development');
    }
}

$ composer require php-activerecord/php-activerecord

Using Container¶

to add data to container use:

$this->container['key'] = 'value'

to get data from container you have two ways:

// access directly
$value = $this->container['key'];

//this method has an advantage of interoperability. so it is recommended.
$value = $this->container->get('key');

to check if a key exists in a container:

if($this->container->has('key')){
    //do something
}

Default data¶

the default data available in container are the following,

Adding an empty collection to Container¶

If you want an empty collection available throughout the application from start. then you can add it to the container using config/collections.php file. you can add a collection in this file by adding "name" => "init_collection" to the array.

adding non empty collection to container¶

To add a non empty container which should be available throughout the application you have to use it as a provider (see Providers section)

constructing¶

you can create a new collection by

use Briz\Base\Collection;

$collection = new Collection();

use Briz\Base\Collection;

$array = [ 'name' => 'value','foo' => 'bar'];

$collection = new Collection($array);

Adding/replacing¶

$collection->set('key','value');

$array = ['a'=>'b','c'=>'d'];

$collection->replace($array);

$array = ['a'=>'b','c'=>'d'];

$collection->merge($array);

//to merge two collections
$newCollection = new Collection(['key'=>'value','foo'=>'bb','bar'=>'h']);
$newCollection->merge($collection->all());

Get values¶

//If key not found it will return an empty array otherwise return the value
$value = $collection->get('key',[]);

//it will return null  if key is not in collection. otherwise will return the value.
$value = $collection->get('key');

$value = $collection->all();

Remove Items¶

$collection->remove('key');

$collection->clear();

Checking¶

if($collection->has('key'))
{
    //do something
}

if($collection->isempty())
{
    //do something
}

$count = $collection->count();

Operations¶

//callback to add prefix.
$callback = function($key,$value){
        $key = 'rf_'.$key;
        $value = 'rf_'.$value;
}

$collection->each($callback);

Request Method¶

The HTTP request methods supported by Briz are,

• CONNECT
• DELETE
• GET
• HEAD
• OPTIONS
• PATCH
• POST
• PUT
• TRACE

$method = $this->request->getMethod();

$this->request = $this->request->withMethod($method);

<input type="hidden" name="X-HTTP-Method-Override" value="put">

Uri¶

There is an interface in PSR-7 for reprecenting Uri Psr\Http\Message\UriInterface. So in request uri reprecents an object of a class implementing that interface. more about our implementation is explained in Uri

$uri = $this->request->getUri();

//now you can use $uri object like,
$port = $uri->getPort();

//this will change the request Uri
$this->request = $this->request->withUri($uri);

$target = $this->request->getRequestTarget();

$request = $this->request->withRequestTarget();

Server Parameters¶

The server parameters part of the request are mostly derived from $_SERVER super global. but they can also contain other values.

$params = $this->request->getServerParams();

//then we can use it like $params['xyz'] etc.

Cookies¶

$cookies = $this->request->getCookieParams();

//this will change the request cookies
$this->request = $this->request->withCookieParams($array);

Query String¶

consider the url http://example.com/briz/i?a=b&c=d the a=b&c=d part is called query string. query string parameters are a=b and c=d

$queryParams = $this->request->getQueryParams();

//this will change the request query parameters
$this->request = $this->request->withQueryParams($queryasArray);

Uploaded Files¶

There is an interface in PSR-7 to reprecent UploadedFiles (Psr\Http\Message\UploadedFileInterface). so we will use our implementation of this interface for reprecting uploaded files. Each uploaded File is reprecented by Briz\Http\UploadedFile class.

$files = $this->request->getUploadedFiles();

//this will change the uploaded files with current request
$this->request = $this->request->withUploadedFiles($uploadedFiles);

Request Body¶

Http request body usually contains POST data. when you use HTTP POST method the request will send your data o server in the request body. You can get this body directly or can get a parsed version (the data in $_POST is actually parsed version)

// unparsed body
$body = $this->request->getBody();

$body = $this->request->getParsedBody();

//parser to parse json as object instead of array.
$parser = function($body){
        return json_decode($body);
   };

$this->registerParser("application/json", $parser);

$body = $this->getParsedBody();

$this->request = $this->request->withBody($newStream);

Headers¶

$headers = $this->request->getHeaders();

if($this->request->hasHeader($name))
{
    //do something.
}

$header = $this->request->getHeader($name);

$header = $this->request->getHeaderLine($name);

$request = $this->request->withHeader($name, $value);

$request = $this->request->withAddedHeader($name, $value);

$request = $this->request->withoutHeader($name);

HTTP version¶

The http protocol version supported by briz are 1.0, 1.1 and 2.0

$version = $this->request->getProtocolVersion();

$request = $this->request->withProtocolVersion($version);

HTTP Status¶

an HTTP response will contain a three digit status code which explains the status of the current response to the client. the most common HTTP status anybody know is 404 Not Found since it is an error message. there are other status codes too. in Briz\Http\Response status codes and reason phrases are defined as below.

protected static $phrases = [
    // INFORMATIONAL CODES
    100 => 'Continue',
    101 => 'Switching Protocols',
    102 => 'Processing',
    // SUCCESS CODES
    200 => 'OK',
    201 => 'Created',
    202 => 'Accepted',
    203 => 'Non-Authoritative Information',
    204 => 'No Content',
    205 => 'Reset Content',
    206 => 'Partial Content',
    207 => 'Multi-status',
    208 => 'Already Reported',
    // REDIRECTION CODES
    300 => 'Multiple Choices',
    301 => 'Moved Permanently',
    302 => 'Found',
    303 => 'See Other',
    304 => 'Not Modified',
    305 => 'Use Proxy',
    306 => 'Switch Proxy', // Deprecated
    307 => 'Temporary Redirect',
    // CLIENT ERROR
    400 => 'Bad Request',
    401 => 'Unauthorized',
    402 => 'Payment Required',
    403 => 'Forbidden',
    404 => 'Not Found',
    405 => 'Method Not Allowed',
    406 => 'Not Acceptable',
    407 => 'Proxy Authentication Required',
    408 => 'Request Time-out',
    409 => 'Conflict',
    410 => 'Gone',
    411 => 'Length Required',
    412 => 'Precondition Failed',
    413 => 'Request Entity Too Large',
    414 => 'Request-URI Too Large',
    415 => 'Unsupported Media Type',
    416 => 'Requested range not satisfiable',
    417 => 'Expectation Failed',
    418 => 'I\'m a teapot',
    422 => 'Unprocessable Entity',
    423 => 'Locked',
    424 => 'Failed Dependency',
    425 => 'Unordered Collection',
    426 => 'Upgrade Required',
    428 => 'Precondition Required',
    429 => 'Too Many Requests',
    431 => 'Request Header Fields Too Large',
    451 => 'Unavailable For Legal Reasons',
    // SERVER ERROR
    500 => 'Internal Server Error',
    501 => 'Not Implemented',
    502 => 'Bad Gateway',
    503 => 'Service Unavailable',
    504 => 'Gateway Time-out',
    505 => 'HTTP Version not supported',
    506 => 'Variant Also Negotiates',
    507 => 'Insufficient Storage',
    508 => 'Loop Detected',
    511 => 'Network Authentication Required',
];

For normal response the status will be 200 OK. The codes above are the only codes supported by Briz. But you have an option to change the reason phrase.

$status = $this->response->getStatusCode();

$reason = $this->response->getReasonPhrase();

$reason = $this->response->withStatus($code);

Response Body¶

Http Response body contains what you will get in browser window. it is the Html part of the response.

$this->response->write($data);
//OR
$this->response->setContent($data);

$this->response->getBody();

$this->response = $this->response->withBody($newStream);

Headers¶

//replace
$this->response->setHeader($header,$value);
//append
$this->response->setHeader($header2,$value,false);

HTTP Version¶

the supported operations on http protocol version are exactly same as the one in request HTTP version

Scheme¶

Uri schemes supported by Briz are HTTP and HTTPS or it can be blank as a placeholder. Other uri schemes will result in an InvalidArgumentException.

$scheme = $uri->getScheme();

$uri = $uri->withScheme($scheme);

Host¶

A host can be an IP address or an address like example.com or long address like web.www.ex.example.com

$host = $uri->getHost();

$host = $uri->withHost($host);

Port¶

a port number must be between 1 and 65535. the default port number of http is 80 and that of https is 443. If you are using a port number other than default one then you must specify it. http://example.com is actually http://example.com:80. since 80 is the default port of http it is nor given. the briz quick start tutorial will start php development server at port 8000. so you have to specify it as http://localhost:8000 since 8000 is not the default port.

$port = $uri->getPort();

$uri = $uri->withPort($port);

Path¶

$path = $uri->getPath();

$uri = $uri->withPath($path);

Query String¶

The Query String is separated from the preceding part by a question mark.

$query = $uri->getQuery();

$uri = $uri->withQuery($query);

Fragment¶

the part of the Uri after # is called Uri Fragment. it is usually used as identifiers for sections in html page.

$fragment = $uri->getFragment();

$uri = $uri->withFragment($fragment);

User Information¶

Uri as defined by rfc3986 and PSR-7 can contain user information. user information is usename and password. empty passwords are also valid.

$user = $uri->getUserInfo();

$authority = $uri->getAuthority();

$uri = $uri->withUserInfo($user, $password);