The captured params are specific to the individual routes, e.g.

app.route(/foo/:foo', function (req) {
Y.log(req.params.foo);
});

app.route(/foo/:bar', function (req) {
Y.log(req.params.bar);
});

app.navigate('/foo/bla');

// => "bla"
// => "bla"

I am sorry, but this is your implementation detail.

A handler for the route '*' should have the information of the actual concrete route and the route's URL parameters should be visible to it. After all, query parameters are!

And besides, what about the URL parameters not being decoded, even at the concrete route level?

It's not an implementation detail, it's an explicit design decision.

Describe to me how you'd handle the following:

app.route('*', function (req, res, next) {
// What should `req.params` be?
next();
});

app.route('/:foo/' ...);
app.route('/users/:foo/', ...);

app.navigate('/users/123/');

In the `"*"` route, should `req.params.foo` be "users" or "123"?

The parameters not being decoded is a separate issue, could you please file a separate bug for it?

Imagine a different implementation for the '*' route.
Suppose that all the middleware from '*' is inserted at each and every route.
Then

app.route('*', function (req, res, next) {

// What should `req.params` be?

next();

});

app.route('/:foo/' ...);

app.route('/users/:foo/', ...);

app.route('*', function (req, res, next) {

// What should `req.params` be?

next();

});

app.route('/:foo/', [function (req, res, next) {

// What should `req.params` be?

next();

}, ...]);

app.route('/users/:foo/', [function (req, res, next) {

// What should `req.params` be?

next();

}, ...]);

This transformation is semantically correct, because the invariant that all the middleware registered for '*' executes the first is preserved. Of course, the imaginary insertion occurs only for the routes following the '*' route.

Anyway, in this case the answer for your question is trivial. /users/123 navigates to the last route and hence req.params.foo is "123".

The only problem is when the given route is not covered by any concrete route, in which case req.params should be empty as today.

If you agree with me that the presented imaginary transformation is a legitimate implementation, then the existing limitation is the result of the current implementation details. It does not have to be this way.

I had a typo in my example, I meant:

app.route('/:foo/*' ...);

app.route('/users/:foo/', ...);

app.navigate('/users/123/');

In any case, this would a drastic changes from the way router operates, and is not something I'd like to change to. If you'd like middleware to run for every route and be context-aware of that route's specific parameter mapping, then I'd suggest doing the following:

var router = new Y.Router();


router.upperCaseParams = function (req, res, next) {

  Y.Object.each(req.params, function(param, name, params) {

    params[name] = param.toUpperCase();

  });

  

  next();

};

router.logFoo = function (req, res, next) {

  Y.log(req.params.foo);

  next();

});

router.route('/:foo/*', 'upperCaseParams', 'logFoo');

router.route('/users/:foo', 'uppserCaseParams', 'logFoo');

router.save('/users/ericf');

// => "USERS"

// => "ERICF"

For the other issue of decoding the URL-encoded path segments for `req.params`. How does this look? Give it a try and let me know if it fixes your issue:
https://github.com/yui/yui3/pull/335

Ticket automatically closed due to no activity.