Object oriented page templates in PHP

@ before a function call will simply turn off error reporting for that
particular call. You will have to choose a different syntax. And, yes,
personally, I am against this suggestion. There are template engines that
already do similar things (Blitz, for instance) without requiring changes
in the language core.

2012/4/9 Tom Boutell tom@punkave.com

<?@addLinks($this->escape($foo)) ?

What if PHP supported a short tag for calling a method of $this?

Then one could write:

<?@escape($foo) ?>

A big -1 on this.

If you want to roll your own template syntax, just do so. It's not
that hard to run a quick str_replace('<?@', '<?php echo $this->',
$code) over the template.

Especially consider that @ is already used for error suppression, so
code that previously just wanted to suppress some errors will suddenly
try to call class methods (which obviously will lead to fatal errors).

Nikita

What if PHP supported a short tag for calling a method of $this?

Then one could write:

<?@escape($foo) ?>

And 'escape' could be upgraded and modified as needed in an object
oriented way without the need to type<?php $this-> many times.

You might be able to achieve this using the prep extension written by
Andrei Zmievski: https://github.com/andreiz/prep/

A relevant example can be found here:
https://github.com/andreiz/prep/tree/master/examples/array_literal where
he introduces an alternative syntax to array().

--
Christer Edvartsen
http://cogo.wordpress.com/
http://twitter.com/#!/cogocogo

-----Original Message-----
From: Tom Boutell [mailto:tom@punkave.com]
Sent: 09 April 2012 16:10
To: PHP Internals
Subject: [PHP-DEV] Object oriented page templates in PHP

There has been talk of making PHP a better templating
language. After all, it did start out there.

Folks have mentioned ideas like making it easier to output
escaped content, etc., but these are all hardcoded solutions.
And one of the biggest problems with PHP as a template
language is that when best practices change, you're stuck
with the helper functions you already have unless you start
globally replacing things. You can't really subclass or
override a function.

So even frameworks that provide "helper functions" in the
vein of Symfony 1 (which borrowed the idea from Rails) get
stuck when you want to alter the behavior.

Last year I did a project in a one-off MVC framework of my
own in which I decided I didn't want to be stuck with that,
so I made a rule:
anything I wanted to call from the template had to be a
method of $this, the view object in whose render() method the
template file was require()'d.

This turned out to be a good thing. By writing <?php
$this->escape($foo) ?>, I was able to benefit from whatever
implementation of 'escape' the subclass of view in question
decided to supply to me.

But of course it is very verbose and a templating language
that is too tedious to use won't get used.

What if PHP supported a short tag for calling a method of $this?

Then one could write:

<?@escape($foo) ?>

And 'escape' could be upgraded and modified as needed in an
object oriented way without the need to type <?php $this-> many
times.

A problem with this proposal is that it does not address
nesting. One still has to write:

<?@addLinks($this->escape($foo)) ?>

And it is fairly common to combine such operations.

So maybe I should just define a sublimetext shortcut for:

<?php $this->

And be done with it. (: It detracts from readability relative
to a template language like Twig, but I can always choose to use
Twig.

This would be notably easier if PHP, like Java and C++,
called methods of the current object implicitly without the
need for $this->. But of course that would be too great a
change as there would be no way to make existing code work
correctly again if it reasonably expected
implode() to call the usual PHP function and not a method.
Plus it's probably a real pain to implement in general.

Thoughts?

$fn = [
'escape' => function($text) { return htmlspecialchars($text,
ENT_QUOTES|ENT_HTML5, 'UTF-8'); },
...
];
extract($fn);

<?=$escape('blah')?>

Do I think it's a good idea? Probably not in this case.

Jared