Merge branch 'hotfix/docs-router'

Author: Xerkus

doc/book/examples.md

@@ -33,7 +33,7 @@ The above can be useful when composing event listeners into your controller.
 ### Accessing routing parameters
 
 The parameters returned when routing completes are wrapped in a
-`Zend\Mvc\Router\RouteMatch` object.  This object is detailed in the section on
+`Zend\Router\RouteMatch` object.  This object is detailed in the section on
 [Routing](routing.md).
 
 Within your controller, if you implement `InjectApplicationEventInterface` (as

doc/book/intro.md

@@ -17,11 +17,11 @@ The MVC layer is built on top of the following components:
   correctly with the SAPI and output buffering.
 - zend-stdlib - specifically `Zend\Stdlib\DispatchableInterface`. All
   "controllers" are simply dispatchable objects.
+- zend-router - provides routing of a request. In other
+  words, it matches the request to its respective controller (or dispatchable).
 
 Within the MVC layer, several sub-components are exposed:
 
-- `Zend\Mvc\Router` contains classes pertaining to routing a request. In other
-  words, it matches the request to its respective controller (or dispatchable).
 - `Zend\Mvc\Controller`, a set of abstract "controller" classes with basic
   responsibilities such as event wiring, action dispatching, etc., as well as
   controller plugins.
@@ -247,7 +247,7 @@ the application. In the default implementation, this does the following:
 - Attaches the default dispatch listener (`Zend\Mvc\DispatchListener`).
 - Attaches the `ViewManager` listener (`Zend\Mvc\View\ViewManager`).
 - Creates the `MvcEvent`, and injects it with the application, request, and
-  response; it also retrieves the router (`Zend\Mvc\Router\Http\TreeRouteStack`)
+  response; it also retrieves the router (`Zend\Router\Http\TreeRouteStack`)
   at this time and attaches it to the event.
 - Triggers the "bootstrap" event.
 

doc/book/quick-start.md

@@ -217,8 +217,8 @@ Now that we have a controller and a view script, we need to create a route to it
 >
 > We're going to create an explicit route in this example, as
 > creating explicit routes is a recommended practice. The application will look for a
-> `Zend\Mvc\Router\RouteStackInterface` instance to setup routing. The default generated router is a
-> `Zend\Mvc\Router\Http\TreeRouteStack`.
+> `Zend\Router\RouteStackInterface` instance to setup routing. The default generated router is a
+> `Zend\Router\Http\TreeRouteStack`.
 >
 > To use the "default route" functionality, you will need to edit the shipped
 > routing definition in the module's `config/module.config.php`, and replace:

doc/book/routing.md

@@ -12,7 +12,7 @@ more.
 The base unit of routing is a `Route`:
 
 ```php
-namespace Zend\Mvc\Router;
+namespace Zend\Router;
 
 use Zend\Stdlib\RequestInterface as Request;
 
@@ -28,7 +28,7 @@ A `Route` accepts a `Request`, and determines if it matches. If so, it returns a
 `RouteMatch` object:
 
 ```php
-namespace Zend\Mvc\Router;
+namespace Zend\Router;
 
 class RouteMatch
 {
@@ -58,7 +58,7 @@ facilitate this, you will use a route aggregate, usually implementing
 `RouteStack`:
 
 ```php
-namespace Zend\Mvc\Router;
+namespace Zend\Router;
 
 interface RouteStackInterface extends RouteInterface
 {
@@ -125,15 +125,15 @@ adding it to the route stack.
 
 ### TreeRouteStack
 
-`Zend\Mvc\Router\Http\TreeRouteStack` provides the ability to register trees of
+`Zend\Router\Http\TreeRouteStack` provides the ability to register trees of
 routes, and uses a B-tree algorithm to match routes. As such, you register a
 single route with many children.
 
 A `TreeRouteStack` will consist of the following configuration:
 
 - A base "route", which describes the base match needed, the root of the tree.
 - An optional `route_plugins`, which is a configured
-  `Zend\Mvc\Router\RoutePluginManager` that can lazy-load routes.
+  `Zend\Router\RoutePluginManager` that can lazy-load routes.
 - The option `may_terminate`, which hints to the router that no other segments
   will follow it.
 - An optional `child_routes` array, which contains additional routes that stem
@@ -153,7 +153,7 @@ route.
 
 zend-mvc ships with the following HTTP route types.
 
-### Zend\\Mvc\\Router\\Http\\Hostname
+### Zend\\Router\\Http\\Hostname
 
 The `Hostname` route attempts to match the hostname registered in the request
 against specific criteria. Typically, this will be in one of the following
@@ -198,7 +198,7 @@ $route = Hostname::factory([
 When matched, the above will return two keys in the `RouteMatch`, "subdomain"
 and "type".
 
-### Zend\\Mvc\\Router\\Http\\Literal
+### Zend\\Router\\Http\\Literal
 
 The `Literal` route is for doing exact matching of the URI path. Configuration
 therefore is solely the path you want to match, and the "defaults", or
@@ -217,7 +217,7 @@ $route = Literal::factory([
 The above route would match a path "/foo", and return the key "action" in the
 `RouteMatch`, with the value "foo".
 
-### Zend\\Mvc\\Router\\Http\\Method
+### Zend\\Router\\Http\\Method
 
 The `Method` route is used to match the HTTP method or 'verb' specified in the
 request (See RFC 2616 Sec. 5.1.1). It can optionally be configured to match
@@ -236,7 +236,7 @@ $route = Method::factory([
 The above route would match an http "POST" or "PUT" request and return a
 `RouteMatch` object containing a key "action" with a value of "form-submit".
 
-### Zend\\Mvc\\Router\\Http\\Part
+### Zend\\Router\\Http\\Part
 
 A `Part` route allows crafting a tree of possible routes based on segments of
 the URI path. It actually extends the `TreeRouteStack`.
@@ -328,32 +328,32 @@ You may use any route type as a child route of a `Part` route.
 > ### Route plugins
 >
 > In the above example, the `$routePlugins` is an instance of
-> `Zend\Mvc\Router\RoutePluginManager`, containing essentially the following
+> `Zend\Router\RoutePluginManager`, containing essentially the following
 > configuration:
 >
 > ```php
-> $routePlugins = new Zend\Mvc\Router\RoutePluginManager();
+> $routePlugins = new Zend\Router\RoutePluginManager();
 > $plugins = [
->     'hostname' => 'Zend\Mvc\Router\Http\Hostname',
->     'literal'  => 'Zend\Mvc\Router\Http\Literal',
->     'part'     => 'Zend\Mvc\Router\Http\Part',
->     'regex'    => 'Zend\Mvc\Router\Http\Regex',
->     'scheme'   => 'Zend\Mvc\Router\Http\Scheme',
->     'segment'  => 'Zend\Mvc\Router\Http\Segment',
->     'wildcard' => 'Zend\Mvc\Router\Http\Wildcard',
->     'query'    => 'Zend\Mvc\Router\Http\Query',
->     'method'   => 'Zend\Mvc\Router\Http\Method',
+>     'hostname' => 'Zend\Router\Http\Hostname',
+>     'literal'  => 'Zend\Router\Http\Literal',
+>     'part'     => 'Zend\Router\Http\Part',
+>     'regex'    => 'Zend\Router\Http\Regex',
+>     'scheme'   => 'Zend\Router\Http\Scheme',
+>     'segment'  => 'Zend\Router\Http\Segment',
+>     'wildcard' => 'Zend\Router\Http\Wildcard',
+>     'query'    => 'Zend\Router\Http\Query',
+>     'method'   => 'Zend\Router\Http\Method',
 > ];
 > foreach ($plugins as $name => $class) {
 >     $routePlugins->setInvokableClass($name, $class);
 > }
 > ```
 >
-> When using `Zend\Mvc\Router\Http\TreeRouteStack`, the `RoutePluginManager` is
+> When using `Zend\Router\Http\TreeRouteStack`, the `RoutePluginManager` is
 > set up by default, and the developer does not need to worry about autoloading
 > of standard HTTP routes.
 
-### Zend\\Mvc\\Router\\Http\\Regex
+### Zend\\Router\\Http\\Regex
 
 A `Regex` route utilizes a regular expression to match against the URI path. Any
 valid regular expression is allowed; our recommendation is to use named captures
@@ -385,7 +385,7 @@ items in the `RouteMatch`, an "id", the "controller", the "action", and the
 "format". When assembling a URL from this route, the "id" and "format" values
 would be used to fill the specification.
 
-### Zend\\Mvc\\Router\\Http\\Scheme
+### Zend\\Router\\Http\\Scheme
 
 The `Scheme` route matches the URI scheme only, and must be an exact match. As
 such, this route, like the `Literal` route, simply takes what you want to match
@@ -403,7 +403,7 @@ $route = Scheme::factory([
 The above route would match the "https" scheme, and return the key "https" in
 the `RouteMatch` with a boolean `true` value.
 
-### Zend\\Mvc\\Router\\Http\\Segment
+### Zend\\Router\\Http\\Segment
 
 A `Segment` route allows matching any segment of a URI path. Segments are
 denoted using a colon, followed by alphanumeric characters; if a segment is
@@ -440,7 +440,7 @@ $route = Segment::factory([
 ]);
 ```
 
-### Zend\\Mvc\\Router\\Http\\Query (Deprecated)
+### Zend\\Router\\Http\\Query (Deprecated)
 
 > #### Potential security issue
 >
@@ -449,7 +449,7 @@ $route = Segment::factory([
 > #### Deprecated
 >
 > This route part is deprecated since you can now add query parameters without a
-> query route.
+> query route. It was removed in version 3 of the router.
 
 The `Query` route part allows you to specify and capture query string parameters
 for a given route.
@@ -507,7 +507,7 @@ will then be appended as a query string.
 The output from our example should then be
 `/page/my-test-page?format=rss&limit=10`
 
-### Zend\\Mvc\\Router\\Http\\Wildcard (Deprecated)
+### Zend\\Router\\Http\\Wildcard (Deprecated)
 
 > #### Potential security issue
 >
@@ -632,7 +632,7 @@ return [
     'router' => [
         'routes' => [
             'modules.zendframework.com' => [
-                'type' => 'Zend\Mvc\Router\Http\Hostname',
+                'type' => 'Zend\Router\Http\Hostname',
                 'options' => [
                     'route' => ':4th.[:3rd.]:2nd.:1st', // domain levels from right to left
                     'constraints' => [
@@ -647,7 +647,7 @@ return [
                 // child route controllers may span multiple modules as desired
                 'child_routes' => [
                     'index' => [
-                        'type' => 'Zend\Mvc\Router\Http\Literal',
+                        'type' => 'Zend\Router\Http\Literal',
                         'options' => [
                             'route' => '/',
                             'defaults' => [
@@ -660,7 +660,7 @@ return [
                 ],
             ],
             'packages.zendframework.com' => [
-                'type' => 'Zend\Mvc\Router\Http\Hostname',
+                'type' => 'Zend\Router\Http\Hostname',
                 'options' => [
                     'route' => ':4th.[:3rd.]:2nd.:1st', // domain levels from right to left
                     'constraints' => [
@@ -675,7 +675,7 @@ return [
                 // child route controllers may span multiple modules as desired
                 'child_routes' => [
                     'index' => [
-                        'type' => 'Zend\Mvc\Router\Http\Literal',
+                        'type' => 'Zend\Router\Http\Literal',
                         'options' => [
                             'route' => '/',
                             'defaults' => [

doc/book/services.md

@@ -130,9 +130,9 @@ services configured out of the box.
     - If the `charset` subkey is present, the value is used to set the adapter
       charset.
 
-- `ConsoleRouter`, mapping to `Zend\Mvc\Service\ConsoleRouterFactory`. This
+- `ConsoleRouter`, mapping to `Zend\Mvc\Console\Router\ConsoleRouterFactory`. This
   grabs the `Config` service, and pulls from the `console` key and `router`
-  subkey, configuring a `Zend\Mvc\Router\Console\SimpleRouteStack` instance.
+  subkey, configuring a `Zend\Mvc\Console\Router\SimpleRouteStack` instance.
 
 - `ConsoleViewManager`, mapping to `Zend\Mvc\Service\ConsoleViewManagerFactory`.
   This creates and returns an instance of `Zend\Mvc\View\Console\ViewManager`,
@@ -176,9 +176,9 @@ services configured out of the box.
   It also uses the `DiAbstractServiceFactory` service, effectively allowing
   you to fall back to DI in order to retrieve form elements.
 
-- `HttpRouter`, mapping to `Zend\Mvc\Service\HttpRouterFactory`. This grabs
+- `HttpRouter`, mapping to `Zend\Router\Http\HttpRouterFactory`. This grabs
   the `Config` service, and pulls from the `router` key, configuring a
-  `Zend\Mvc\Router\Http\TreeRouteStack` instance.
+  `Zend\Router\Http\TreeRouteStack` instance.
 
 - `HttpViewManager`, mapping to `Zend\Mvc\Service\HttpViewManagerFactory`.
   This creates and returns an instance of `Zend\Mvc\View\Http\ViewManager`,
@@ -235,12 +235,12 @@ services configured out of the box.
   create a `Zend\Console\Response`; otherwise, for HTTP environments, it
   creates a `Zend\Http\PhpEnvironment\Response`.
 
-- `Router`, mapping to `Zend\Mvc\Service\RouterFactory`. If in a console
+- `Router`, mapping to `Zend\Router\RouterFactory`. If in a console
   environment, it proxies to the `ConsoleRouter` service; otherwise, it proxies
   to the `HttpRouter` service.
 
 - `RoutePluginManager`, mapping to `Zend\Mvc\Service\RoutePluginManagerFactory`.
-  This instantiates the `Zend\Mvc\Router\RoutePluginManager` instance, passing
+  This instantiates the `Zend\Router\RoutePluginManager` instance, passing
   it the service manager instance; this is used to manage [route types](routing.md#http-route-types).
   It also uses the `DiAbstractServiceFactory` service, effectively allowing
   you to fall back to DI in order to retrieve route types.
@@ -488,7 +488,7 @@ The following plugin managers are configured by default:
   and used to manage hydrator instances.
 - **InputFilterManager**, corresponding to `Zend\InputFilter\InputFilterPluginManager`,
   and used to manage input filter instances.
-- **RoutePluginManager**, corresponding to `Zend\Mvc\Router\RoutePluginManager`,
+- **RoutePluginManager**, corresponding to `Zend\Router\RoutePluginManager`,
   and used to manage route instances.
 - **SerializerAdapterManager**, corresponding to `Zend\Serializer\AdapterPluginManager`,
   and used to manage serializer instances.