Zend_Acl

The package provides classical ACL functionality. There are roles, resources and privileges, and you can assign them to each other via deny and allow rules. For example you can say that XY user(role) is allowed to moderate(privilege) the PHP topic(resource) in a forum. You don’t have to always specify all the three part, for example you can say, that administrator can moderate any topic.

I won’t introduce the Zend_Acl package, it has an easy to understand manual page. Some observation which could be interesting related to this post:

• There is no separate user and group in Zend_Acl, the concept of role includes both of them. A role can have multiple parents, so roles compose a directed graph.
• Resources can have only one parent so they compose a tree.

Zend_Acl limitations/problems

Consider a forum where you have a lot of users/groups and a lot of resources (topics). You have have to add all of them (manually one at a time) to the Acl object which is very memory and time consuming task. Of course once you build the Acl object you can save it (in a serialized form) and reuse it next time but it will eat a lot of memory too. To make this clear check the following code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

You can see that if I want to reference a role or a resource in the allow/deny method, first I have to add it to the Acl object.

My other problem is that the Zend_Acl doesn’t support different type of roles/resources. Of course you can use a prefix, but maybe different roles/resources should be handled in a different way.

I wanted to come up with a solution where I have to define only the access rules and the Acl automatically checks if the referenced entity exists and automatically handles its relations (parent[s]), something like this:

1
2
3
4
5
6
7
8

You may have immeditaley a problem with this code: how can we distinguish the different roles/resources? Yes, we need one more step to have enough felxibility:
$acl = new Zend_Acl();

$acl->deny(‘group:guest’, ‘topic:membersonly’);

echo $acl->isAllowed(‘user:someUser’, ‘topic:membersonly’) ? ‘allowed’ : ‘denied’;
?>
With this notation we can have any type of roles and resources. In a typical application you will have a user and a group roles, but you can have for example an ldapuser too.

Foo_Acl

After a little planning I find out the following structure:

Zend_Acl has a RoleRegistry but I needed more functionality so I extended it. In Zend_Acl there is no ResourceRegistry, so I added to the Foo_Acl package, its functionality is very similar to the RoleRegistry. For both of them I defined an interface, they can handle any role/resource which implements it. This interfaces extends the proper interfaces in the Zend_Acl package, and defines some more basic functionality: getting the relation(s) of the role/resource and loading it. For example the Foo_Acl_Role_Interface is the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

The functionality of different roles/resources is very similar, so I created a default implementation for both of this interfaces, and you can easily create custom ones by extending it. The default implementation of the Foo_Acl_Role_Interface is the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

If you want to create a custom role you should extend this class and overwrite the load function which responsibility is to check if the specified role exists and to instantiate the proper role object. I wrote some sample custom rules, the following is for representing users:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

You can see it is very straightforward to create a new role. I commented out the caching codes because I am in changing the cache implementations and I could not put it to sample code.

The Foo_Acl package provide an effective and convenient way to handle a huge number of entity:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

I tested it on the database of a bigger forum and it worked very well. You can download the sample code here.

__callStatic()

Probably you are familiar with PHP’s magic methods. PHP 5.3 introduces a new magic method: __callStatic, which is very similar to __call but it is for static calls. It is cool, we are waiting for the __get, __set etc. counterparts.

1
2
3
4
5
6
7
8
9
10
11

Dynamic static calls

I think variable variables are one of the most useful things in PHP. In PHP 5.3 there is a new possibility on this area, the following code is possible:

1
2
3
4
5
6
7
8
9

You can find here a useful example from Etienne Kneuss, who implemented the patch for this functionality.

Improved ini handling

Jani Taskinen created a patch providing improved ini handling. We can get some insight of how it will be working from the commit message:

• Added “.htaccess” style user-defined php.ini files support for CGI/FastCGI.
• Added support for special [PATH=/opt/httpd/www.example.com/] sections in php.ini. All directives set in these sections will not be able to be overridden in user-defined ini-files or during runtime in the specified path.
• Improved php.ini handling:
  • Added better error reporting for syntax errors in php.ini files
  • Allowed “ini-variables” to be used almost everywhere ini php.ini files
  • Allowed using alphanumeric/variable indexes in “array” ini options
  • Fixed get_cfg_var() to be able to return “array” ini options

And we can get some more information from the related php.ini addition:

1
2
3
4
5
6
7
8
9
10
11

OpenID support

In PHP 5.3 the openssl extension will provide high speed Diffie-Hellman support, which is important for OpenID. You can get more information from Dmitry Stogov’s proposal.

XSLT profiling

Christian Stocker mentioned in his blog that he added his XSLT profiling to the official PHP source.

getopt() on any platform

As from PHP 5.3 the getopt() function will be available even on Windows systems, and getopt() will support longopts on every system.

Error levels

E_STRICT will be splitted to E_STRICT and E_DEPRECATED. E_STRICT error will mean common bad practices and E_DEPRECATED will be triggered when you try to use such a language feature which is likely to go away from a later version. E_STRICT will be part of E_ALL.

Other improvements

• Sqlite3 support via the ext/sqlite extension
• array_replace[_recursive] functions
• SPL improvements:
  • DirectoryIterator implements ArrayAccess
  • Implementing Spl(Array|Index|Member)Reference
  • Implement DualIterator
  • Implement RecursiveTreeIterator

The overview of the advantages of mysqlnd over libmysql: high integration with the Zend Engine, faster execution, lower memory footprint, performance statistics for bottle-neck analysis, easier compilation, own development life cycle, usage of PHP stream API, client side query cache and a lot of possibility for future features.

Over the technical advantages theres is a licensing one. MySQL is rely on the GPL license which is not compatible with the PHP license, using libmysql with PHP needs the FLOSS exception, but mysqlnd is licensed under the PHP license so this is no more a problem (check the mysqlnd FAQ).

The installation process will be easier, you won’t need to have libmysql on the server. Libmysql is shipped with the MySQL server, updating libmysql means that you have to update the MySQL server too. With myslqnd this bounding no more exists, it has its own release and development life cycle. Mysqlnd has a common code base for PHP5 and PHP6, so the maintenance of the code is easier, a bug should be fixed only at one place.

High integration with the Zend Engine

Mysqlnd is highly integrated with the Zend engine, so it can leverage all the internal PHP infrastructure for communication and memory management, it can do a lot of tricky thing to improve performance. If you are curious about the details you should check Andrey Hristov’s presentation from mysqlnd (I get some illustration from it). You can find here a little benchmark about the performance of mysqlnd.

Comply with the memory_limit settings

Myslqnd uses the Zend Engine’s memory management so it comply (in contrast to libmysql) with the memory limit setting. It allocates bigger chunk of memory (allocating memory is relatively expensive task), it tries to reuse zvals using zval cache to save CPU cycle.

Memory savings

Mysqlnd introduces an interesting concept: read only variables with which it can save a huge amount of memory. You can read about it in the mentioned presentation or in Ulf Wendel’s blog entry. To completely understand this you should be familiar with the internal representation of variables in PHP (I’ll write about it soon), the short version is the following. When you run a buffered query libmysql reads first the data into its own buffer, and then when you run mysql_fetch_*() function the data is get copied from this buffer into another memory area which represents the PHP variables. Mysqlnd uses a read buffer too, but when you run the mysql_fetch_*() function it isn’t copy the data but links the PHP variables to this memory area. This way it can consume only half as much memory as libmysql.

Usage of the PHP stream API

Mysqlnd uses the PHP stream API, which holds a lot of possibility because it makes possible to hook into the communication with MySQL. Exposing the streams to users is not yet implemented, if it is done one can easily write a custom proxy using stream filters.

Persistent connections

You may know that persistent connections was disabled in mysqli extension, but with mysqlnd you will have again the possibility to use persistent connection (mysqli_connect('p:localhost', ...);). This is an interesting post about this topic.

Statistical data collection

Mysqlnd collects a lot of statistics which you can use for tuning your application. This statistical information will simplify the process of finding bottlenecks in your system, you can easily monitor your application and you can even build automatic problem detection into it. You can access these data via phpinfo(), mysqli_get_client_stats() (per process statistics), mysqli_get_connection_stats() (per connections statistics) functions. Currently 59 statistical information are collected by mysqlnd, you can read more about this at Ulf’s blog. It collects information about its internal zval cache, this you can get with the mysqli_get_cache_stat(), which could bu useful to tweak you zval cahe related php.ini settings, or to find an incidental bad habits in your code (for example you needlessly modify the fetched data and hence you lose the memory saving option).

Client-side query cache

Mysqlnd supports client-side query cache which could be very useful in some situation because it eliminates communication overhead (network latency), memory allocation overhead. By client side query cache it could be interesting the invalidation of the cache, mysqlnd currently supports only TTL (time-to-live) invalidation which you can control via php.ini settings. This part of the library is experimental, will change a lot in the future.

Possible future improvements, features

There is a lot of possibility in this area, just to name a few: improving the client side query cache, exposing PHP streams to users, prepared statement cache, automatic load balancing, built-in profiling. More foretastes for gourmands: the wishlist of Lukas, and Peter Zaitsev (MySQL Performance Blog).

Enjoy your meal!

Late static binding basic

First let me introduce what late static binding is about. I am not going to write too much about the basics, because fortunately I get a helping hand . So the base problem is the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Static references to the current class like self:: or __CLASS__ are resolved using the class in which the function belongs, as in where it was defined, so when we call the test() method on class B it will call the who() method of class A.

PHP 5.3 introduces a new possibility by allowing a keyword that references the class that was initially called at runtime:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

This is the basic behavior of the static keyword in this context, you can get more information in the manual. Now back to the ActiveRecord.

Facing the problem

Zend’s proposal was something similar:

1
2
3
4
5
6
7
8
9
10
11
12
13

The conception is nice, the base implementation of findByPk() finds out from the name of the child class the name of the table on which it should be operate. There is only one (huge) problem with this code, when findByPk() is called it can’t determines the name of the class on which it was called. There was an ugly workaround using debug_backtrace(), but its performance was quite poor, so finally it was not used in ZF.

After the late static binding introduction you may come up with the following code in PHP 5.3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Running this code the value of $calledClass will be “Blog”. This is great, but it would be very annoying if we have to add the getClass() method to every child class. Fortunately with the late static binding we get a great new function too: get_called_class(), which returns the name of the current calling scope. Using this function we get a nifty code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

This works very well, but unfortunately we can’t be absolutely happy, because there is a big flaw (I believe it is) in the current implementation of late static binding. Michael Lively pointed to this problem on the internal list and on his blog. How does this problem affect our example? Imagine that we want a simple logging functionality only in the Blog class. Consider the following code (it seems to a logical and suitable solution for this task):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

If you try to run this program maybe you will surprise, because the value of the $calledClass variable will be “ActiveRecord”. OOPS! What here happens: parent will resolve to ActiveRecord and this breaks late static binding. From the manual: “Late static bindings’ reslution will stop at a fully resolved static call with no fallback”. It is possible that this explanation is not completely exact (maybe somebody from the internal list can explain it more precisely), but the substance is that this is a legitimate usage of late static binding and is not currently supported. I hope it will be fixed/supported in the final version of PHP 5.3.

I believe that this feature holds a lot of potential, for example you should check Joshua Thompson’s very interesting post: Return to Prototype Based Programming in PHP.

Namespaces basic

Namespace support in PHP was a long-felt want feature. In PHP the main motivation behind adding namespace support to the language was to solve the problem of long class names. If you develop a bigger library, you have to use long class names to avoid naming conflicts, for example look at this monster: Zend_Search_Lucene_Analysis_Analyzer_Common_Text_CaseInsensitive.

From the version 5.3 you can group your code into namespaces. Different namespaces can contains classes, functions, constants with the same name. Defining a namespace is very straightforward, you should use the namespace statement in the very beginning of the file, for example:

1
2
3
4
5
6
7
8
9
10
11
12

You have a lot of options to use items defined in this namespace:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Only namespaces and classes can be imported with the use statement, for example you can’t say: use my::foo::MY_CONST;. A use statement takes effect from its definition to the end of the file, you can use it everywhere in the global scope. You can use the same namespace in more files, but one file should contain only one namespace (this behavior maybe will changed in the final version, or the maybe the namespace keyword will be replaced with package ). While you can’t import a function or a constant, you should always use some kind of prefix if you want to access any of them from a namespace. In the earlier versions of PHP 5.3 the import keyword was used insted of use, but few weeks ago it was changed.

The “empty” namespace (::)

If you use the :: prefix by function and class names, they are interpreted as global independently from the current import rules. This is useful inside a namespace.

Life with namesapces (porting code to PHP 5.3)

If you decide to use namespaces there are some pitfalls you should pay attention.

Class naming convention

You should forget to use reserved words in you class names. Consider the following code:

1
2
3
4

The equivalent would be this using namespace:

1
2
3
4
5

But DateStatic is a reserved word (and an existent internal class) so this code ends in fatal error. This could be a bad news if you have a lot of similar classes.

Autoloading

From PHP 5.3 __autoload() will get the fully qualified class name. This mean that you have to modify you __autoload funciton if you have used one. A basic example:

1
2
3
4
5
6
7
8
9

Or you prefer the SPL way:

1
2
3
4
5
6
7
8
9

1
2
3

get_class(), get_parent_class(), etc.

When you use these type of functions you should take into consideration that they returns fully qualified class names too.

Reflection API

The Reflection API should reflect (;)) to this new language feature. The plan is the following:

• Create a new ReflectionNamespace class with the following methods: getName(), getClasses(), getFunctions(), getFiles()
• Extend the ReflectionClass and ReflectionFunction classes with a new getNamespace() method.

Life inside a namespace

There is some special knowledge you should be familiar with, if you want to write codes in namespaces.

The __NAMESPACE__ constant

There is a new special constant: __NAMESPACE__, which contains the name of the current namespace. For example you can write the SPL autoloader in the following way:

1
2
3
4
5
6
7
8
9

Resolving names inside a namespace

I don’t want to describe the complete rule set here, you can read it in the PHP namespaces README. The main point is, that PHP try to resolve a name first according to the current namesapce. Let’s see some example:

1
2
3
4
5
6
7

When you call bar() then PHP try to find the function in the my::foo namespace. If it finds it will call it, if not it will try to call the internal bar() function, so it is important to notice, that using this notation, you can’t call user defined function inside a namespace. Using the ::bar() form PHP will call the bar() function in the global namespace, so it could be an internal or a user defined function. This logic is true when you try to create a new object.

1
2
3
4
5
6
7

In this case of core::bar() PHP first tries to call function bar() from namespace my::foo::core then calls method bar() of internal class core. In the case of ::core::bar() it first tries to call function bar() from namespace core then calls method bar() of class core from global scope.

The namespace support in PHP is not yet finished, it is possible some modifications in the future.

Beautiful code with AOP and DI – Robert Lemke
This was a really great presentation, watch out: you will be infected! Robert shows us advanced programming concepts such as DDD (Domain Driven Design), AOP (Aspect-Oriented Programming), DI (Dependency Injection). This concepts serves a common aims to produce higher quality, maintainable, flexible software. Robert is the member of the Typo3 5.0 development team, and they are using this methods in their every day work. If you are interested in this topic you can find useful information in their home page or you should read the Bibles :

Enhanced StreamWrappers – Frank Kleine
This talk is about a really cool and unfortunately rarely used PHP feature: PHP streams. Frank will shows you how you can create custom stream wrappers, and some useful and advanced examples how you can use them.

Eclipse Hands On to development – Bastian Feder
Bastian’s mini talk is about how to integrate external tool to Eclipse. He is now setting up his blog, so you can download his presentation from my blog.

Tales from the eXtreme side | Lars Jankowfsky
Lars give us useful practical advices how to organize a team if you want to use extreme programming practices: ideal number of a team, office layout, daily tasks/routine, refactoring tips. He emphasizes the importance of writing always tests even for JavaScript codes. He talks about Continuous Integration and mentions useful tools to assure code quality: PHPUnit PMD (Project Mess Detector), CodeSniffer, Software Metrics, xDebug’s code coverage.

Practising Agile Development for Beginners | Lars Jankowfsky
Lars had an other interesting session about agile development. If you are interested in this topic you should look over the slides because they contain a lot of great information and resources.

Testing with PHPUnit and Selenium | Sebastian Bergmann, Max Horváth

This is a comprehensive talk about testing web applications. You can get information about the different type of tests, in which situation are they usable. It shows you the evolution from inline test codes to using complex testing tools and running the test automatically. Sebastian and Max present a very detailed example (a bowling game) how to develop an application using the TDD (Test Driven Development) methodology, how to organize your test suites. Then they talk about more advanced topics: software metrics, Selenium, testing object interaction (mock objects), database testing.

PHP Design Patterns | Stephan Schmidt, Frank Kleine
Unfortunately the slides are in German, but I think it would be a great workshop, you can through the slides and maybe you will find some interesting information crumbs as I did.

Common challenges in SQL apps | Lukas Smith
Lukas Smith (PEAR::MDB2) talks about general database and SQL (un)patterns. His presentation touches on topics like: schema design (data types, normalization, trees, queues etc.), indexes and constraints (over indexing, covering indexes, full text indexes, foreign key etc.), SELECT magic (optimization, using CASE statement, pivot tables, random ordering, ranking etc.), data changes (SQL injection, optimistic locking, MVCC, smart transactions, CSV import/export etc.) It is worth studying this presentation I am sure that you will find a lot of interesting points (which maybe will you guide to further reading/research).

Putting Phing to Work for You | Hans Lellelid (Propel, Phing)
Hans talks about Phing (what a surprise about the title ). He deal with the following topics in his presentation: phing basics, creating a first build file, transforming directories and files, performing PDO tasks, gathering user input, building phpdoc, running unit tests, integrating with Continuous Integration tools, using PHP code in a build file, building a simple task, writing more complex task, creating a shared type, custom filters, custom selectors, custom loggers/listeners, input handlers.

Test Driven Development | Derick Rethans
This talks is about TDD too, this topic is getting more and more important in the PHP world too.

IBM Project Zero | Rob Nicholson (Project Zero)
Unfortunately the URL of the slides are dead, but I put a comment at IBM website, and I’ll update the post, if anything is happen.

PHP6 – A look ahead | Stefan Priebsch
Stefan talks about the new features of the upcoming PHP 6. It is worth running trough the slides, because a lot of feature originally planned for PHP 6 will be part of PHP 5.3 which will be released in early 20072008.

PHP Tools and Automation | Stefan Priebsch
This talks enumerate a lot of tools which a developer may need to working effectively and to automating repetitive tasks: Subversion, Webdevloper Toolbar, Firebug, xDebug (KCachegrind), Eclipse – PDT, PHPDocumentor, PHPUnit, Selenium, XPather, PHP CodeSniffer, PHP CompatInfo, PHP Beautifier, phing, Virtual Machines, CruiseControl.

RegExp – Magic with text | Kore Nordmann
Support for regular expressions advanced a lot with PCRE 6 and 7. After an introduction into the basics of regular expressions this session covers the recent additions like recursive patterns and conditional subpatterns.

Diving into symfony | Dustin Whittle
This is a talk about the symfony framework, which is a full featured PHP application framework, supports the full development lifecycle. You can get an in-depth introduction about all parts of symfony.

Propel Your PHP Applications | Hans Lellelid (Propel, Phing)
This talk introduces the Propel PHP ORM tool. It shows you an overview of Propel, a typical work cycle, then you can get some more in-depth usage and advanced features.

Phing: Building with PHP | Hans Lellelid (Propel, Phing)
Hans talks about why can be useful a build tool. Todays application is getting more complex, you have to do a lot of CLI task related to your project: run unit tests, build API docs, install and package. Even deploying the application can be a complex task: setting permission, running generator, validating the contents of files (for example JavaScript, XML, PHP), etc., Phing can help you on these tasks.

Generating PDF using XSLT and FPDF | Thomas Weinert
Generate PDFs from XML content using XSLT/FPDF gives you several new features. You can add covers, create multicolumn pages, change the page orientation depending on the content and more. All in your corporate design.

A JSR-283 CR in pure PHP | Karsten Dambekalns
A Content Repository (CR) allows the storage and retrieval of arbitrary content as nodes and properties in a tree structure. The API for using a CR is standardized in the JSR-170 and JSR-283 specifications. The Typo3 team decided to port the JSR-283 specification as a part of the new Typo3 5.0 project. You can read about this work in this presentation.

Webdav with eZ Components | Tobias Schlitt
This talk gives us a little introduction to eZ Components, then it introduces WebDAV and the eZ webdav component.

Hands on eZ Components | Tobias Schlitt
If you follow this slides you can get an impression of the power of eZ Components. It is worth being familiar with possibilities of this library, any time you could need them.

A Workflow Engine for PHP 5 | Sebastian Bergmann
Workflow Management (WfM) is becoming more and more important. For the development and maintainance of software that supports workflows, a new layer on top of the base programming language is needed. Graph-Oriented Programming (GOP) is such a layer. This session presents the eZ Components’ workflow engine, its possible applications and the underlying principles and techniques.

To get WordPress to insert the title attribute automatically to a tag we had to modify the wp-includes/js/quicktags.js file by adding a few lines of code to the edInsertTag function at two places:

341
342
343

357
358
359

You can download the fully modified version from here (this file contains my former modifications).

The keyboard layout when no modifier pressed:

The keyboard layout when SHIFT is pressed:

The keyboard layout when ALT is pressed:

The keyboard layout when FN is pressed:

If you like it you can download it here.

The name of the compiled template file

By default the name of the compiled template file is the encoded version of the original template file. If turn off this behavior by setting the $encode_file_name variable to false. The problem is, that in this case Template Lite does not include into the name of the compiled file the $template_dir variable. Consider the following situation:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

The code looks good, but there is a big problem. If you get the index page on domain1.com, and then the index page on domain2.com, the secondly generated compiled file will overwrite the first one. To solve this problem you should modify the source code in the following way:

1
2
3

This modification should be done in several places in the source code. To find all the places you should search for the “encode_file_name” string.

Writing out the compiled template file

Template Lite by default opens a new file, and writes the compiled template content to it. This is not a good solution if the site has high traffic, because in the time of writing out the file it is not accessible for other processes which will cause error. A better solution is if you write to a temporary file, and when you finish it rename the temporary file to the final name. The name of the temporary file should be unique, you can achieve this by using a suffix like this: getmypid()."_".microtime(TRUE). Now if we have multiple request on the same time, and there isn’t a compiled version of the template, every request starts to generate the compiled version. The renames will be atomic and are ordered by the OS, so this way we can eliminate this type of error. The only drawback is that in Windows we can’t rename to an existing file, but usually you won’t serve a high traffic site on a Windows machine with PHP, so this is not a big problem.

To get Template Lite to work in this way, we should slightly modify its source (class.template.php) in the following way:

776
777
778
779
780
781
782
783
784
785
786
787
788
789
790

The value of the $this->_file variable

The Template_Lite class holds in this variable the name of the currently used template file. If the currently processed template includes an other template, Template Lite stops the processing of the current template and starts to process the included one (it works like a function call). At this stage the value of the $this->_file will be the name of the included template. Unfortunately when the processing step back to the original template, the value of $this->_file won’t change back. Generally this has no effect, but I sucked a little through it when I tried to extend Template Lite (you can read about this soon).

To correct this issue you should modify the class.template.php file on two places:

749
750

796
797

Some other little typos

The following snippet comes from the original template.class.php file:

689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716

Maybe you notice, that no file is opened in the else statement, but fclose($f) is always called. You should move this command to the if and else if statement.

Another little typo is here:

257
258
259
260
261

You can download the corrected version. The comments are in Hungarian, but after reading the article you won’t need them, and anyway it is a beautiful language.

Smarty resources

Smarty supports several type of plug-ins including resource plug-ins. Resource plug-ins allow you to change the way Smarty looks for templates. For example you can create a db resource plug-in, which allows you to store your templates in database. To use this plug-in you should refer to the templates with a db: prefix. For example $smarty->display('db:login.tpl'); or in templates {include file='db:header.tpl'}. The plug-in will find the template in the database, and return it.

Register a Smarty resource plug-in

You can register a custom Smarty resource plug-in with theregister_resource() method:

1
2
3
4
5
6
7
8

The first parameter is the name of the resource (should be at least two characters in length) and the second is an array with four function name which implement the plug-in. Every function will receive the requested resource as the first parameter and the Smarty object as the last parameter. The rest of parameters depend on the function.

From the Smarty manual:

1
2
3
4
5
6
7

• The first function, source() is supposed to retrieve the resource. Its second parameter $source is a variable passed by reference where the result should be stored. The function is supposed to return TRUE if it was able to successfully retrieve the resource and FALSE otherwise.

• The second function, timestamp() is supposed to retrieve the last modification time of the requested resource, as a UNIX timestamp. The second parameter $timestamp is a variable passed by reference where the timestamp should be stored. The function is supposed to return TRUE if the timestamp could be successfully determined, or FALSE otherwise.
• The third function, secure()is supposed to return TRUE or FALSE, depending on whether the requested resource is secure or not. This function is used only for template resources but should still be defined.
• The fourth function, trusted() is supposed to return TRUE or FALSE, depending on whether the requested resource is trusted or not. This function is used for only for PHP script components requested by {include_php} tag or {insert} tag with the src attribute. However, it should still be defined even for template resources.

You can find on the manual page a possible implementation of the db resource plugin.

Solution for our original problem: text resource

We can create a custom text resource to solve the problem mentioned in the introduction. The necessary code will be very straightforward:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Smarty resources could be very useful in some situations, keep in mind this feature!