[Symfony 2] Cannot import resource

str_replace("\\", "/", $mon_prefix);

PS: évite le "Putain"... Ses très impolie... ont dit Purée.

Lol oui je sais mais c'était dans le délire ^^
Et je dois placer ta ligne php dans mon controller ?

str_replace permet de remplacer un string pour ton cas "\" remplace le \ par / pour avoir ton chemin en home/aragorn/www/ au lieu de home\aragorn\www (j'ai eux ce soucis) ^^ sinon je connais pas trop Symfony 2

Oui mais je ovulais dire je dois placer ça dans quel fichier ?? ^^

dans ce qui te bloque :)

Le soucis est que justement je ne sais pas dans quel fichier cela pourrait merder :D

Mmmh...

YamlFileLoader.php on line 127
Route.php line 81
essaye de voir de c'est deux côté ;)

Nan toujours la même erreur ....

Un petit up please, je dois terminer ce site assez rapidement mais je suis pas un professionel de la matière, donc aidez-moi svp ....

L'erreur vient du fait que tu passes une chaîne de caractères à la fonction __construct du Router au lieu de lui passer un tableau comme prévu.

Daccord, merci bien mais comment je peut régler cela ?
et est-ce que le fait que j'ai des '/' et des '\' dans l'url du routing.yml ait une consequence sur ça ?

en te remerciant, ;-)

Non, je ne pense pas

Daccord mais comment je peut régler le fait de refaire passer la chaîne en array stp ?

Je sais pas trop, je vais essayer :)

essaye:

return $this->render(str_replace("\\", "/", "EtNewsBundle:News:ajouter.html.twig"));

Le message est toujours le même, je penche plutôt fire le fait qu'il ne peut trouver tout seul le fichier routing du bundle plutôt que du fait que cela viendrait la fonction PHP return

Ah oui j'avais pas pensée...

J'ai regardé vite fait Symfony et j'aurai besoin que tu me montres ce fichier:
C:\wamp\www\e-t\vendor\symfony\symfony\src\Symfony\Component\Routing\Loader\YamlFileLoader.php
Et celui-là:
C:\wamp\www\e-t\vendor\symfony\symfony\src\Symfony\Component\Routing\Route.php

Pour transformer une chaîne en un tableau rien de plus simple:

$render = array('0' => 'EtNewsBundle:News:ajouter.html.twig');
return $this->render($render);

C'est un simple exemple code tout à fait basique.

Alors mon YamlFileLoader.php:

<?php
/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Symfony\Component\Routing\Loader;
use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;
use Symfony\Component\Config\Resource\FileResource;
use Symfony\Component\Yaml\Parser as YamlParser;
use Symfony\Component\Config\Loader\FileLoader;
/**
 * YamlFileLoader loads Yaml routing files.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Tobias Schultze <http://tobion.de>
 *
 * @api
 */
class YamlFileLoader extends FileLoader
{
    private static $availableKeys = array(
        'resource', 'type', 'prefix', 'pattern', 'path', 'host', 'schemes', 'methods', 'defaults', 'requirements', 'options',
    );
    private $yamlParser;
    /**
     * Loads a Yaml file.
     *
     * @param string $file A Yaml file path
     * @param string|null $type The resource type
     *
     * @return RouteCollection A RouteCollection instance
     *
     * @throws \InvalidArgumentException When a route can't be parsed because YAML is invalid
     *
     * @api
     */
    public function load($file, $type = null)
    {
        $path = $this->locator->locate($file);
        if (!stream_is_local($path)) {
            throw new \InvalidArgumentException(sprintf('This is not a local file "%s".', $path));
        }
        if (!file_exists($path)) {
            throw new \InvalidArgumentException(sprintf('File "%s" not found.', $path));
        }
        if (null === $this->yamlParser) {
            $this->yamlParser = new YamlParser();
        }
        $config = $this->yamlParser->parse(file_get_contents($path));
        $collection = new RouteCollection();
        $collection->addResource(new FileResource($path));
        // empty file
        if (null === $config) {
            return $collection;
        }
        // not an array
        if (!is_array($config)) {
            throw new \InvalidArgumentException(sprintf('The file "%s" must contain a YAML array.', $path));
        }
        foreach ($config as $name => $config) {
            if (isset($config'pattern'])) {
                if (isset($config'path'])) {
                    throw new \InvalidArgumentException(sprintf('The file "%s" cannot define both a "path" and a "pattern" attribute. Use only "path".', $path));
                }
                $config'path'] = $config'pattern'];
                unset($config'pattern']);
            }
            $this->validate($config, $name, $path);
            if (isset($config'resource'])) {
                $this->parseImport($collection, $config, $path, $file);
            } else {
                $this->parseRoute($collection, $name, $config, $path);
            }
        }
        return $collection;
    }
    /**
     * {@inheritdoc}
     *
     * @api
     */
    public function supports($resource, $type = null)
    {
        return is_string($resource) && 'yml' === pathinfo($resource, PATHINFO_EXTENSION) && (!$type || 'yaml' === $type);
    }
    /**
     * Parses a route and adds it to the RouteCollection.
     *
     * @param RouteCollection $collection A RouteCollection instance
     * @param string $name Route name
     * @param array $config Route definition
     * @param string $path Full path of the YAML file being processed
     */
    protected function parseRoute(RouteCollection $collection, $name, array $config, $path)
    {
        $defaults = isset($config'defaults']) ? $config'defaults'] : array();
        $requirements = isset($config'requirements']) ? $config'requirements'] : array();
        $options = isset($config'options']) ? $config'options'] : array();
        $host = isset($config'host']) ? $config'host'] : '';
        $schemes = isset($config'schemes']) ? $config'schemes'] : array();
        $methods = isset($config'methods']) ? $config'methods'] : array();
        $route = new Route($config'path'], $defaults, $requirements, $options, $host, $schemes, $methods);
        $collection->add($name, $route);
    }
    /**
     * Parses an import and adds the routes in the resource to the RouteCollection.
     *
     * @param RouteCollection $collection A RouteCollection instance
     * @param array $config Route definition
     * @param string $path Full path of the YAML file being processed
     * @param string $file Loaded file name
     */
    protected function parseImport(RouteCollection $collection, array $config, $path, $file)
    {
        $type = isset($config'type']) ? $config'type'] : null;
        $prefix = isset($config'prefix']) ? $config'prefix'] : '';
        $defaults = isset($config'defaults']) ? $config'defaults'] : array();
        $requirements = isset($config'requirements']) ? $config'requirements'] : array();
        $options = isset($config'options']) ? $config'options'] : array();
        $host = isset($config'host']) ? $config'host'] : null;
        $schemes = isset($config'schemes']) ? $config'schemes'] : null;
        $methods = isset($config'methods']) ? $config'methods'] : null;
        $this->setCurrentDir(dirname($path));
        $subCollection = $this->import($config'resource'], $type, false, $file);
        /* @var $subCollection RouteCollection */
        $subCollection->addPrefix($prefix);
        if (null !== $host) {
            $subCollection->setHost($host);
        }
        if (null !== $schemes) {
            $subCollection->setSchemes($schemes);
        }
        if (null !== $methods) {
            $subCollection->setMethods($methods);
        }
        $subCollection->addDefaults($defaults);
        $subCollection->addRequirements($requirements);
        $subCollection->addOptions($options);
        $collection->addCollection($subCollection);
    }
    /**
     * Validates the route configuration.
     *
     * @param array $config A resource config
     * @param string $name The config key
     * @param string $path The loaded file path
     *
     * @throws \InvalidArgumentException If one of the provided config keys is not supported,
     * something is missing or the combination is nonsense
     */
    protected function validate($config, $name, $path)
    {
        if (!is_array($config)) {
            throw new \InvalidArgumentException(sprintf('The definition of "%s" in "%s" must be a YAML array.', $name, $path));
        }
        if ($extraKeys = array_diff(array_keys($config), self::$availableKeys)) {
            throw new \InvalidArgumentException(sprintf(
                'The routing file "%s" contains unsupported keys for "%s": "%s". Expected one of: "%s".',
                $path, $name, implode('", "', $extraKeys), implode('", "', self::$availableKeys)
            ));
        }
        if (isset($config'resource']) && isset($config'path'])) {
            throw new \InvalidArgumentException(sprintf(
                'The routing file "%s" must not specify both the "resource" key and the "path" key for "%s". Choose between an import and a route definition.',
                $path, $name
            ));
        }
        if (!isset($config'resource']) && isset($config'type'])) {
            throw new \InvalidArgumentException(sprintf(
                'The "type" key for the route definition "%s" in "%s" is unsupported. It is only available for imports in combination with the "resource" key.',
                $name, $path
            ));
        }
        if (!isset($config'resource']) && !isset($config'path'])) {
            throw new \InvalidArgumentException(sprintf(
                'You must define a "path" for the route "%s" in file "%s".',
                $name, $path
            ));
        }
    }
}

Et mon Route.php:

<?php
/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Symfony\Component\Routing;
/**
 * A Route describes a route and its parameters.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Tobias Schultze <http://tobion.de>
 *
 * @api
 */
class Route implements \Serializable
{
    /**
     * @var string
     */
    private $path = '/';
    /**
     * @var string
     */
    private $host = '';
    /**
     * @var array
     */
    private $schemes = array();
    /**
     * @var array
     */
    private $methods = array();
    /**
     * @var array
     */
    private $defaults = array();
    /**
     * @var array
     */
    private $requirements = array();
    /**
     * @var array
     */
    private $options = array();
    /**
     * @var null|RouteCompiler
     */
    private $compiled;
    /**
     * Constructor.
     *
     * Available options:
     *
     * * compiler_class: A class name able to compile this route instance (RouteCompiler by default)
     *
     * @param string $path The path pattern to match
     * @param array $defaults An array of default parameter values
     * @param array $requirements An array of requirements for parameters (regexes)
     * @param array $options An array of options
     * @param string $host The host pattern to match
     * @param string|array $schemes A required URI scheme or an array of restricted schemes
     * @param string|array $methods A required HTTP method or an array of restricted methods
     *
     * @api
     */
    public function __construct($path, array $defaults = array(), array $requirements = array(), array $options = array(), $host = '', $schemes = array(), $methods = array())
    {
        $this->setPath($path);
        $this->setDefaults($defaults);
        $this->setRequirements($requirements);
        $this->setOptions($options);
        $this->setHost($host);
        // The conditions make sure that an initial empty $schemes/$methods does not override the corresponding requirement.
        // They can be removed when the BC layer is removed.
        if ($schemes) {
            $this->setSchemes($schemes);
        }
        if ($methods) {
            $this->setMethods($methods);
        }
    }
    public function serialize()
    {
        return serialize(array(
            'path' => $this->path,
            'host' => $this->host,
            'defaults' => $this->defaults,
            'requirements' => $this->requirements,
            'options' => $this->options,
            'schemes' => $this->schemes,
            'methods' => $this->methods,
        ));
    }
    public function unserialize($data)
    {
        $data = unserialize($data);
        $this->path = $data'path'];
        $this->host = $data'host'];
        $this->defaults = $data'defaults'];
        $this->requirements = $data'requirements'];
        $this->options = $data'options'];
        $this->schemes = $data'schemes'];
        $this->methods = $data'methods'];
    }
    /**
     * Returns the pattern for the path.
     *
     * @return string The pattern
     *
     * @deprecated Deprecated in 2.2, to be removed in 3.0. Use getPath instead.
     */
    public function getPattern()
    {
        return $this->path;
    }
    /**
     * Sets the pattern for the path.
     *
     * This method implements a fluent interface.
     *
     * @param string $pattern The path pattern
     *
     * @return Route The current Route instance
     *
     * @deprecated Deprecated in 2.2, to be removed in 3.0. Use setPath instead.
     */
    public function setPattern($pattern)
    {
        return $this->setPath($pattern);
    }
    /**
     * Returns the pattern for the path.
     *
     * @return string The path pattern
     */
    public function getPath()
    {
        return $this->path;
    }
    /**
     * Sets the pattern for the path.
     *
     * This method implements a fluent interface.
     *
     * @param string $pattern The path pattern
     *
     * @return Route The current Route instance
     */
    public function setPath($pattern)
    {
        // A pattern must start with a slash and must not have multiple slashes at the beginning because the
        // generated path for this route would be confused with a network path, e.g. '//domain.com/path'.
        $this->path = '/'.ltrim(trim($pattern), '/');
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the pattern for the host.
     *
     * @return string The host pattern
     */
    public function getHost()
    {
        return $this->host;
    }
    /**
     * Sets the pattern for the host.
     *
     * This method implements a fluent interface.
     *
     * @param string $pattern The host pattern
     *
     * @return Route The current Route instance
     */
    public function setHost($pattern)
    {
        $this->host = (string) $pattern;
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the lowercased schemes this route is restricted to.
     * So an empty array means that any scheme is allowed.
     *
     * @return array The schemes
     */
    public function getSchemes()
    {
        return $this->schemes;
    }
    /**
     * Sets the schemes (e.g. 'https') this route is restricted to.
     * So an empty array means that any scheme is allowed.
     *
     * This method implements a fluent interface.
     *
     * @param string|array $schemes The scheme or an array of schemes
     *
     * @return Route The current Route instance
     */
    public function setSchemes($schemes)
    {
        $this->schemes = array_map('strtolower', (array) $schemes);
        // this is to keep BC and will be removed in a future version
        if ($this->schemes) {
            $this->requirements'_scheme'] = implode('|', $this->schemes);
        } else {
            unset($this->requirements'_scheme']);
        }
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the uppercased HTTP methods this route is restricted to.
     * So an empty array means that any method is allowed.
     *
     * @return array The schemes
     */
    public function getMethods()
    {
        return $this->methods;
    }
    /**
     * Sets the HTTP methods (e.g. 'POST') this route is restricted to.
     * So an empty array means that any method is allowed.
     *
     * This method implements a fluent interface.
     *
     * @param string|array $methods The method or an array of methods
     *
     * @return Route The current Route instance
     */
    public function setMethods($methods)
    {
        $this->methods = array_map('strtoupper', (array) $methods);
        // this is to keep BC and will be removed in a future version
        if ($this->methods) {
            $this->requirements'_method'] = implode('|', $this->methods);
        } else {
            unset($this->requirements'_method']);
        }
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the options.
     *
     * @return array The options
     */
    public function getOptions()
    {
        return $this->options;
    }
    /**
     * Sets the options.
     *
     * This method implements a fluent interface.
     *
     * @param array $options The options
     *
     * @return Route The current Route instance
     */
    public function setOptions(array $options)
    {
        $this->options = array(
            'compiler_class' => 'Symfony\\Component\\Routing\\RouteCompiler',
        );
        return $this->addOptions($options);
    }
    /**
     * Adds options.
     *
     * This method implements a fluent interface.
     *
     * @param array $options The options
     *
     * @return Route The current Route instance
     */
    public function addOptions(array $options)
    {
        foreach ($options as $name => $option) {
            $this->options$name] = $option;
        }
        $this->compiled = null;
        return $this;
    }
    /**
     * Sets an option value.
     *
     * This method implements a fluent interface.
     *
     * @param string $name An option name
     * @param mixed $value The option value
     *
     * @return Route The current Route instance
     *
     * @api
     */
    public function setOption($name, $value)
    {
        $this->options$name] = $value;
        $this->compiled = null;
        return $this;
    }
    /**
     * Get an option value.
     *
     * @param string $name An option name
     *
     * @return mixed The option value or null when not given
     */
    public function getOption($name)
    {
        return isset($this->options$name]) ? $this->options$name] : null;
    }
    /**
     * Checks if an option has been set
     *
     * @param string $name An option name
     *
     * @return Boolean true if the option is set, false otherwise
     */
    public function hasOption($name)
    {
        return array_key_exists($name, $this->options);
    }
    /**
     * Returns the defaults.
     *
     * @return array The defaults
     */
    public function getDefaults()
    {
        return $this->defaults;
    }
    /**
     * Sets the defaults.
     *
     * This method implements a fluent interface.
     *
     * @param array $defaults The defaults
     *
     * @return Route The current Route instance
     */
    public function setDefaults(array $defaults)
    {
        $this->defaults = array();
        return $this->addDefaults($defaults);
    }
    /**
     * Adds defaults.
     *
     * This method implements a fluent interface.
     *
     * @param array $defaults The defaults
     *
     * @return Route The current Route instance
     */
    public function addDefaults(array $defaults)
    {
        foreach ($defaults as $name => $default) {
            $this->defaults$name] = $default;
        }
        $this->compiled = null;
        return $this;
    }
    /**
     * Gets a default value.
     *
     * @param string $name A variable name
     *
     * @return mixed The default value or null when not given
     */
    public function getDefault($name)
    {
        return isset($this->defaults$name]) ? $this->defaults$name] : null;
    }
    /**
     * Checks if a default value is set for the given variable.
     *
     * @param string $name A variable name
     *
     * @return Boolean true if the default value is set, false otherwise
     */
    public function hasDefault($name)
    {
        return array_key_exists($name, $this->defaults);
    }
    /**
     * Sets a default value.
     *
     * @param string $name A variable name
     * @param mixed $default The default value
     *
     * @return Route The current Route instance
     *
     * @api
     */
    public function setDefault($name, $default)
    {
        $this->defaults$name] = $default;
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the requirements.
     *
     * @return array The requirements
     */
    public function getRequirements()
    {
        return $this->requirements;
    }
    /**
     * Sets the requirements.
     *
     * This method implements a fluent interface.
     *
     * @param array $requirements The requirements
     *
     * @return Route The current Route instance
     */
    public function setRequirements(array $requirements)
    {
        $this->requirements = array();
        return $this->addRequirements($requirements);
    }
    /**
     * Adds requirements.
     *
     * This method implements a fluent interface.
     *
     * @param array $requirements The requirements
     *
     * @return Route The current Route instance
     */
    public function addRequirements(array $requirements)
    {
        foreach ($requirements as $key => $regex) {
            $this->requirements$key] = $this->sanitizeRequirement($key, $regex);
        }
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the requirement for the given key.
     *
     * @param string $key The key
     *
     * @return string|null The regex or null when not given
     */
    public function getRequirement($key)
    {
        return isset($this->requirements$key]) ? $this->requirements$key] : null;
    }
    /**
     * Checks if a requirement is set for the given key.
     *
     * @param string $key A variable name
     *
     * @return Boolean true if a requirement is specified, false otherwise
     */
    public function hasRequirement($key)
    {
        return array_key_exists($key, $this->requirements);
    }
    /**
     * Sets a requirement for the given key.
     *
     * @param string $key The key
     * @param string $regex The regex
     *
     * @return Route The current Route instance
     *
     * @api
     */
    public function setRequirement($key, $regex)
    {
        $this->requirements$key] = $this->sanitizeRequirement($key, $regex);
        $this->compiled = null;
        return $this;
    }
    /**
     * Compiles the route.
     *
     * @return CompiledRoute A CompiledRoute instance
     *
     * @throws \LogicException If the Route cannot be compiled because the
     * path or host pattern is invalid
     *
     * @see RouteCompiler which is responsible for the compilation process
     */
    public function compile()
    {
        if (null !== $this->compiled) {
            return $this->compiled;
        }
        $class = $this->getOption('compiler_class');
        return $this->compiled = $class::compile($this);
    }
    private function sanitizeRequirement($key, $regex)
    {
        if (!is_string($regex)) {
            throw new \InvalidArgumentException(sprintf('Routing requirement for "%s" must be a string.', $key));
        }
        if ('' !== $regex && '^' === $regex[0]) {
            $regex = (string) substr($regex, 1); // returns false for a single character
        }
        if ('$' === substr($regex, -1)) {
            $regex = substr($regex, 0, -1);
        }
        if ('' === $regex) {
            throw new \InvalidArgumentException(sprintf('Routing requirement for "%s" cannot be empty.', $key));
        }
        // this is to keep BC and will be removed in a future version
        if ('_scheme' === $key) {
            $this->setSchemes(explode('|', $regex));
        } elseif ('_method' === $key) {
            $this->setMethods(explode('|', $regex));
        }
        return $regex;
    }
}

je sais, j'ai fait une réponse mode XXL ^^
Est-ce que tu crois que mon problème viendrai de la chaîne à transfomer en tableau ou juste car il trouve pas le fichier routing ?

Au moins c'est complet. Ton problème pourrait venir d'un problème d'inclusion du fichier de routing j'ai bien l'impression.
C'est bien un problème d'array (de tableau) apparemment ligne 127 du Yamloader:
on voit qu'on fait à la classe Route et le 3ème arguments est $requirements hors il semblerait qu'ici $requirement ne soit pas un tableau et dans la classe route la fonction __construct exige que le 3ème argument soit un tableau.

Donc c'est simple à la ligne 126 du Yamloader fait un

print_r($requirements);

ainsi je pourrai voir ce que contient cette variable et te dirai comment corriger le problème.

J'obtiens ceci :

http://hpics.li/a3c267e

Tu ne fais que me montrer l'erreur sous forme de capture d'écran le print_r ne te renvoie vraiment rien ?

Nan il renvoie rien à part le \d* en haut à gauche

En effet donc le $requirement n'est pas un array(tableau) d'où ton erreur maintenant il va falloir trouver où est ce que tu définis ce que contient le $requirements.
Apparemment cela viendrait du routing.html du bundle:

requirements: \d*

Je vais faire quelques recherches et je t'en dirai plus puisque je n'ai jamais utilisé symfony ^^

Ah oki, ba en tout cas je te remerci 2x fois plus vu que tu connais pas le framework mais que tu tentes de m'aider quand même ^^

Alors j'ai regardé c'est bien un array qu'il faut passer par défaut si tu renseignes pas le requirements alors ce sera un tableau vide.
S'il y a des espaces ou de l'indentation tu peux aussi avoir une erreur comme la tienne.
Dans le routing.html du bundle remplace donc:

requirements: \d*

par

requirements:\d*
ou
requirements:

Sinon dans ton instance de la classe Route il faut que tu fasses passer un tableau en 3ème paramètre en sachant que le requirements c'est des regex qu'il faut mettre cf la doc de symfony 2.
D'ailleurs dans ton routing.html du bundle je vois bien que tu n'as aucun requirements pour ajouter ;) essayes de mettre requirements:\d*
ou juste requirements:
Sinon tu fais passer un tableau lors de l'instance de la classe avec une regex du genre:

$requirements = array('0' => '(.*)');

Si je fais ce que tu dis au niveau du requirements, j'obtiens ceci:

(Unable to parse at line 4 (near "requirements:\d*").)

Et le cannot import ressource n'apparaît plus ?
En tout cas essaye de mettre un requirements: \d+ à la règle de routing de l'ajout de news dans le routing.html du bundle.

Déjà mon IDE indique que c'est une erreur vu qu'il est censé avoir un espace entre le':' et '\d+' donc je pense que c'est normal que le cannot import ressource ne marche plus. Normalement, je les ai déjà mis ces requirements, ils apparaissent dans le fichier que j'ai mis au début de ce topic ^^

Oui remet l'espace mais je te parle pour ajouter regarde ce que tu as mis:

etnews_acceuil:
    path: /{page}
    defaults: { _controller: EtNewsBundle:News:index, page: 1 }
    requirements: \d*

etnews_voir:
    path: /news/{id}
    defaults: { _controller: EtnewsBundle:News:voir }
    requirements: \d+

etnews_ajouter:
    path: /ajouter
    defaults: {_controller: EtNewsBundle:News:ajouter }

etnews_modifier:
    path: /modifier/{id}
    defaults: { _controller: EtNewsBundle:News:modifier }
    requirements: \d+

etnews_supprimer:
    path: /supprimer/{id}
    defaults: { _controller: EtNewsBundle:News:supprimer }
    requirements: \d+

Comme tu le dis c'est bien ajouter qui ne fonctionne pas et comme par hasard aucun requirements ;) et c'est bien lui le coupable d'après l'erreur renvoyé par l'instance de la classe.

Le fait que je mette un requirements signifie qu'il attend un numéro d'ID de news, or, lorsque tu ajoteu une news, la route n'attends pas de numéro d'ID vu que la news n'a pas encore été créer donc je ne sais pas ce que je peut mettre en requirements à part rien .... ^^
Si je laisse vide le requirements à la route ajouter, le message d'erreur reste toujours le même

Ok c'est donc bien ce que j'avais compris ;) .

Du coup il faut voir du côté du YamFileloader à la ligne 127:

$route = new Route($config'path'], $defaults, $requirements, $options, $host, $schemes, $methods);

Savoir ce que contient le $requirements puisque c'est lui qui pose soucis, il doit soit être vide soit correspondre à un tableau en l'occurrence il s'agit d'une chaîne de caractères d'après l'erreur renvoyée.
Tu connais les fonctions de debug de symfony 2 ? Si oui essayes les sur le $requirements soit avant soit après avoir fait l'instance de la classe.

D'ailleurs pourquoi quand tu ajoutes un article tu n'utilises pas l'id de l'article pour l'ajouter à la base ? Lorsque tu le modifies tu utilises un id pour savoir lequel modifier, la suppression pareil etc... mais par lors de l'ajout.

Non malheureusement je suis débutant en symfony 2 donc je n'en suis pas encore là ^^
Je vais essayer de me renseigner sur la documentation officielle de Symfony ^^

Au pire faire un

debug_backtrace($requirements);

ça devrait t'en dire un peu plus sur ce que contient cette fichue variable à cet endroit et de quelle type elle est.

Y a rien qui apparait, pourtant je l'ai mis dans le YamlLoader.php
Mais je viens de constater aussi que le message d'erreur à changer:

Cannot import resource "C:\wamp\www\e-t\src\Et\NewsBundle/Resources/config/routing.yml" from "C:/wamp/www/e-t/app/config\routing.yml". (Warning: debug_backtrace() expects parameter 1 to be long, string given in C:\wamp\www\e-t\vendor\symfony\symfony\src\Symfony\Component\Routing\Loader\YamlFileLoader.php line 126)

Ok donc c'est bien ce qui est soupçonné depuis le début ici le $requirements est une chaîne de caractère d'où l'erreur qui change puisque debug_backtrace ne veut pas de chaîne de caractère.
Il va falloir transformer ta jolie chaîne de caractère en tableau si seulement je savais ce qu'elle contient. Je regarderai demain je me suis fait extraire 6 dents il y a quelques jours et on peut pas dire que je pète la forme (mal de crâne etc...).

Je te laisse essayer de trouver une fonction de debug sous symfony 2 pour connaître ce que contient la variable $requirements j'ai vu que tu pouvais utiliser dump qui est basé sur la fonction var_dump().

Daccord il y a pas de soucis, c'est déjà gentil de ta part d'essayer de m'aider :-) Bon courage à toi ;-)

Bonsoir, je me suis renseigné un peut partout j'ai pas trouvé de solution désolé :(

Finalement, j'ai trouvé mon bonheur ici

Je te remercie quand même pour ton aide, malgrès le fait que tu ne connaisse pas SF2 et que tu es des dents en moins ;)

Ok pas de soucis j'étais quand même sur la bonne voie donc ;) Je me doutais bien que c'était les requirements qui faisaient défauts ^^ .

Je connais le site du zéro j'y suis aussi mais je traîne pas trop sur la partie PHP de ce site ;) plutôt graphisme et demande de configs.

Ahahaha ^^
Moi j'y suis juste pour le forum XD

J'y allais beaucoup avant (j'ai deux comptes avec plus de 1 000 messages) mais ces temps-ci le temps me manque ^^ . En tout cas ce genre de site communautaire est toujours bénéfique à chacun.