/**
* Loads a Routes collection by parsing Controller method names.
*
* @param string $controller Some identifier for the controller
* @param string $type The resource type
*
* @return RouteCollection A RouteCollection instance
*/
public function load($controller, $type = null)
{
if (class_exists($controller)) {
// full class name
$class = $controller;
$controllerPrefix = $class . '::';
} elseif (false !== strpos($controller, ':')) {
// bundle:controller notation
try {
$notation = $this->parser->parse($controller . ':method');
list($class, $method) = explode('::', $notation);
$controllerPrefix = $class . '::';
} catch (\Exception $e) {
throw new \InvalidArgumentException(sprintf('Can\'t locate "%s" controller.', $controller));
}
} elseif ($this->container->has($controller)) {
// service_id
$controllerPrefix = $controller . ':';
// FIXME: this is ugly, but I do not see any good alternative
$this->container->enterScope('request');
$this->container->set('request', new Request());
$class = get_class($this->container->get($controller));
$this->container->leaveScope('request');
}
if (empty($class)) {
throw new \InvalidArgumentException(sprintf('Class could not be determined for Controller identified by "%s".', $controller));
}
// Check that every passed parent has non-empty singular name
foreach ($this->parents as $parent) {
if (empty($parent) || '/' === substr($parent, -1)) {
throw new \InvalidArgumentException('All parent controllers must have ::getSINGULAR_NAME() action');
}
}
$class = new \ReflectionClass($class);
$collection = new RestRouteCollection();
$collection->addResource(new FileResource($class->getFileName()));
$prefixAnnotationClass = 'FOS\\RestBundle\\Controller\\Annotations\\Prefix';
$prefix = $this->reader->getClassAnnotation($class, $prefixAnnotationClass);
if ($prefix) {
$this->prefix = $prefix->value;
}
$namePrefixAnnotationClass = 'FOS\\RestBundle\\Controller\\Annotations\\NamePrefix';
$namePrefix = $this->reader->getClassAnnotation($class, $namePrefixAnnotationClass);
if ($namePrefix) {
$this->namePrefix = $namePrefix->value;
}
// Trim "/" at the start
if (null !== $this->prefix && isset($this->prefix[0]) && '/' === $this->prefix[0]) {
$this->prefix = substr($this->prefix, 1);
}
$routeAnnotationClass = 'FOS\\RestBundle\\Controller\\Annotations\\Route';
$patternStartRoute = $this->reader->getClassAnnotation($class, $routeAnnotationClass);
$patternStart = null;
if ($patternStartRoute) {
$patternStart = trim($patternStartRoute->getPattern(), "/");
}
$routes = array();
foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
$matches = array();
// If method name starts with underscore - skip
if ('_' === substr($method->getName(), 0, 1)) {
continue;
}
// If method has @NoRoute annotation - skip
$noAnnotationClass = 'FOS\\RestBundle\\Controller\\Annotations\\NoRoute';
if (null !== $this->reader->getMethodAnnotation($method, $noAnnotationClass)) {
continue;
}
if (preg_match('/([a-z][_a-z0-9]+)(.*)Action/', $method->getName(), $matches)) {
$httpMethod = $matches[1];
$resources = preg_split('/([A-Z][^A-Z]*)/', $matches[2], -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
$arguments = $method->getParameters();
// Ignore arguments that are or extend from Symfony\Component\HttpFoundation\Request
foreach ($arguments as $key => $argument) {
$class = $argument->getClass();
if ($class && ($class->getName() === 'Symfony\\Component\\HttpFoundation\\Request' || is_subclass_of($class->getName(), 'Symfony\\Component\\HttpFoundation\\Request'))) {
unset($arguments[$key]);
}
}
// If we have 1 resource passed & 1 argument, then it's object call, so
// we can set collection singular name
if (1 === count($resources) && 1 === count($arguments) - count($this->parents)) {
$collection->setSingularName($resources[0]);
}
// If we have parents passed - merge them with own resource names
if (count($this->parents)) {
$resources = array_merge($this->parents, $resources);
}
$urlParts = array();
$routeName = $httpMethod;
if (empty($resources)) {
$resources[] = null;
}
foreach ($resources as $i => $resource) {
if (null !== $resource) {
$routeName .= '_' . basename($resource);
}
// If we already added all parent routes paths to URL & we have prefix - add it
if (!empty($this->prefix) && $i === count($this->parents)) {
$urlParts[] = $this->prefix;
}
// If we have argument for current resource, then it's object. Otherwise - it's collection
if (isset($arguments[$i])) {
if ($patternStart) {
$urlParts[] = strtolower($patternStart) . '/{' . $arguments[$i]->getName() . '}';
} elseif (null !== $resource) {
$urlParts[] = strtolower(Pluralization::pluralize($resource)) . '/{' . $arguments[$i]->getName() . '}';
} else {
$urlParts[] = '{' . $arguments[$i]->getName() . '}';
}
} else {
if ($patternStart) {
$urlParts[] = $patternStart;
} elseif (null !== $resource) {
$urlParts[] = strtolower($resource);
}
}
}
// If passed method is not valid HTTP method
// then it's either a hypertext driver,
// a custom object (PUT) or collection (GET) method
if (!in_array($httpMethod, $this->availableHTTPMethods)) {
$urlParts[] = $httpMethod;
// allow hypertext as the engine of application state
// through conventional GET actions
if (in_array($httpMethod, $this->availableConventionalActions)) {
$httpMethod = 'get';
} else {
//custom object
$httpMethod = 'post';
// resource collection
if (count($arguments) < count($resources)) {
$httpMethod = 'get';
}
}
}
$pattern = implode('/', $urlParts);
$defaults = array('_controller' => $controllerPrefix . $method->getName(), '_format' => $this->defaultFormat);
$requirements = array('_method' => strtoupper($httpMethod));
$options = array();
// Read annotations
foreach ($this->annotationClasses as $annotationClass) {
$routeAnnnotation = $this->reader->getMethodAnnotation($method, $annotationClass);
if (null !== $routeAnnnotation) {
$annoRequirements = $routeAnnnotation->getRequirements();
if (!isset($annoRequirements['_method']) || null === $annoRequirements['_method']) {
$annoRequirements['_method'] = $requirements['_method'];
}
$pattern = $routeAnnnotation->getPattern() ?: $pattern;
$requirements = array_merge($requirements, $annoRequirements);
$options = array_merge($options, $routeAnnnotation->getOptions());
$defaults = array_merge($defaults, $routeAnnnotation->getDefaults());
break;
}
}
//Adding in the optional _format param for serialization
$pattern .= ".{_format}";
// Create route with gathered parameters
$route = new Route($pattern, $defaults, $requirements, $options);
$routeName = $this->namePrefix . strtolower($routeName);
// Move custom actions at the beginning, default at the end
if (!preg_match('/^(' . implode('|', $this->availableHTTPMethods) . ')/', $routeName)) {
array_unshift($routes, array('name' => $routeName, 'route' => $route));
} else {
$routes[] = array('name' => $routeName, 'route' => $route);
}
}
}
foreach ($routes as $routeInfo) {
$collection->add($routeInfo['name'], $routeInfo['route']);
}
$this->prefix = null;
$this->namePrefix = null;
return $collection;
}