First public release of MyAAC

system/libs/dwoo/CHANGELOG

@@ -0,0 +1,508 @@
+[2010-02-07] 1.1.1
++ Added {optional} plugin that just prints an optional var without any
+  notice if it doesn't exist
++ Added Dwoo::setTemplate() for testing purposes mostly
+* Fixed an {extends} parsing bug that prevented the use of single-quotes
+  around the parent template's filename
+* Fixed a security issue, if you didn't use a custom compiler factory but
+  passed the compiler directly to the get method with autoEscape enabled,
+  the autoEscape was disabled in included templates - Thanks to Fabien
+  Potencier for notifying me.
+* Fixed a bug in {safe} when using variable-variables it would sometimes
+  corrupt the var name resulting in blank output
+* Fixed a bug when accessing array indices that contain a minus sign, it
+  is now possible to access those using {$var[index-foo]},
+  {$var['index-foo']} or {$index="index-foo"} {$var[$index]}
+* Fixed a bug in {tif} that didn't work when 0 was given as the true or
+  false value
+* Fixed a bug when using the autoEscape feature with sub-templates (the
+  compiled sub-template couldn't access the dwoo charset property,
+  resulting in a fatal error)
+* Fixed a property reading bug on objects that implemented __get but not
+  __isset, implementing __isset is however very much recommended
+* Fixed a Dwoo_Data bug in the append method when the index didn't exist
+  yet it threw a notice
+* Fixed a bug when accessing global vars from a sub-template
+* Fixed a couple bugs in the {dynamic} plugin with regard to using plugins
+  within a dynamic block
+* Fixed a compilation bug when using a PluginProxy with highly nested calls
+* Fixed a {load_templates} bug, plugins used in external templates were not
+  loaded correctly, same for custom user plugins
+* Cached templates now check the source template for modification before
+  outputting the cached version
+* Removed a couple of @-operator calls to file_get_contents
+
+[2009-07-18] 1.1.0
+! BC Break: Dwoo::initGlobals() is only called once during the Dwoo object
+  construction. If you had overriden it and need to update global data
+  before each template is executed you should instead override
+  Dwoo::initRuntimeVars() and push stuff in the globals array there. Also
+  be aware that this means captured data, foreach values and so-on will
+  persist from a parent template to an included one (but the include's
+  changes will not be reflected on the parent), and from a template
+  to the next if you render several in series.
++ Added {template} plugin that allows you to define sub-templates and then
+  call them (works recursively too, good for menus and lists)
++ Added {load_templates} to load external sub-templates into your file
++ Allowed string concatenation assignments with {$foo.="bar"}
++ Allowed access of static properties as {Foo::$bar}
++ Plugins/Helpers that use a dynamic number of arguments through
+  func_get_args are now working since the compiler lets any arguments in
+  excess pass through
++ Adapters: CodeIgniter: the adapter by Stefan Verstege has been added to
+  core and he will be its maintainer from now on
++ Adapters: CakePHP: this adapter is now added to core and is designed to
+  work with CakePHP 1.2
+* Adapters: Zend: Denis Arh is now appointed maintainer of that part and
+  fixed a few things since 1.0.1
+* The include_path isn't altered anymore, hopefully saving some stat calls
+* User classes extending Dwoo_Template_File are now supported better with
+  regard to includes - Thanks to the Kayako.com team for the patch
+* Objects now act like arrays when you access non-existing properties on
+  them (i.e. it outputs a notice only if it's output straight, and none
+  when passed to a function)
+* For can now iterate backwards if you input numbers, it won't work with
+  variables though
+* Slight performance improvement with big inheritance trees
+* No more double-slashes in template paths since this seemed to cause
+  slight performance issues
+* Fixed a bug with parsing AND/OR keywords in conditionals when they were
+  followed by round brackets
+* Fixed assignments not handling multi-line values correctly
+* Fixed parameter parsing issue when a plugin name was all uppercased
+* Fixed assignments failing with autoEscape enabled
+* Fixed parsing of vars with string keys that was too greedy
+* Fixed an optimization causing foreach/for/loop variables not being
+  accessible when the foreach/.. name was set dynamically
+* Fixed parsing of comments that were on top of the file when there are
+  spaces at the end of it
+* Dwoo_Template::$chmod is now enforced for directories as well (#18)
+* Many new unit tests to improve code coverage and a bunch of bug fixes
+  that resulted, but I didn't really keep track of them
+
+[2008-12-24] 1.0.1
+* Direct assignments like {$foo = 5} now allow spaces around the operator
+* Fixed a {foreach} bug with the implode argument
+* Fixed modulo operator in if statements
+* Fixed date_format handling of negative and small unix timestamps
+* Fixed a weird reference bug with ZF and includes.. whatever but thanks
+  to Denis Arh for the patch
+
+[2008-10-23] 1.0.0
+! BC Break: Small one that probably won't affect anyone, but it makes the
+  PluginProxy feature much stronger. Basically if you used a custom one you
+  will get a fatal error and need to update it to conform to the new
+  IPluginProxy interface, that's it
++ Compiler: the modifier syntax (|foo) can now be applied on functions and on
+  complex variables i.e. {$obj->getStuff()|upper} or {lower('foo')|upper}
++ SmartyCompat: Added a {section} plugin but I strongly discourage using it,
+  it was really made to support legacy templates, since {for} doesn't have to
+  handle {section}-BC anymore, it has been cleaned up a lot and the last
+  $skip parameter has been dropped
+* The core Dwoo class doesn't need writable compile/cache dirs in the
+  constructor anymore so you can provide custom ones later through
+  ->setCompile(/Cache)Dir - thanks to Denis Arh for the patch
+* Adapters: Zend: major overhaul thanks to Denis Arh, templates files should
+  probably be moved in the scripts subfolder after this update though, and
+  the settings array has changed a bit, you will get warnings if you don't
+  update the code anyway
+* Plugins: improved the dump plugin, it now displays object's properties
+  and optionally public methods (if the new show_methods arg is set to true)
+  - thanks to Stephan Wentz for the patch
+* Adapters: Zend: Added parameters to provide a custom engine (extends Dwoo)
+  or a custom data class (extends Dwoo_Data) - thanks to Maxime Merian for
+  the patch
+* Compiler: added Dwoo_Compiler->setNestedCommentsHandling(true) to enable
+  parsing of nested comments (i.e. {* {* *} *} becomes a valid comment, useful
+  to comment out big chunks of code containing comments)
+* Lines containing only comments and whitespace are now entirely removed
+* Removed comments do not mess up the line count anymore (for error messages)
+* Fixed parsing bug in {func()->propertyOfReturnedObject}
+* Fixed file template class reading from the string compiler factory - thanks
+  to MrOxiMoron for the patch
+* Fixed handling of variable variables that contained non standard characters
+* Fixed a 1.0.0beta regression that messed with custom plugin directories
+  on Windows
+* SmartyCompat: Fixed a few bugs in the adapter and processor - thanks to
+  Stefan Moonen for the patches
+
+[2008-09-08] 1.0.0beta
+! Important note : Dwoo.php should not be included directly anymore, please
+  read the UPGRADE_NOTES file for more infos on the matter, if you don't
+  your Dwoo install will most likely break after the update anyway
+! BC Break: {include} and {extends} now support the include path properly,
+  which means that if you include "foo/bar.html" from _any_ template and you
+  have an include path set on your template object, it will look in all those
+  paths for foo/bar.html. If you use relative paths, for example
+  if you include "../foo/bar.html" AND have an include path set, you will now
+  have a problem, because you can't mix both approaches, otherwise you should
+  be fine, so to fix this you should convert your relative includes/extends
++ Adapters: Added the Agavi interface for Dwoo
+  (see /Dwoo/Adapters/Agavi/README)
++ API: Added Dwoo_Compilation_Exception methods getCompiler() and
+  getTemplate() so you can catch the exception and use those to build a nicer
+  error view with all the details you want
++ Plugins: Added a mode parameter to {strip} to allow stripping of javascript
+  code blocks that use "// comments", because without this special mode the
+  comments result in syntax errors
+* The Compiler now ensures that a template starting with <?xml will not
+  conflict with php using the short_open_tag=On setting
+* Complex arrays keys can be read using {$var["Long|Key*With.some)Crap"]},
+  however since it is really bad practice I won't spend time fixing edge
+  cases, which are $ and '/" characters inside the string. Those will break
+  it and that's it.. if you really care feel free to send a patch
+* Dwoo->get() is now stricter as to what it accepts as a "template", only
+  Dwoo_ITemplate objects or valid filenames are accepted
+* Foreach and other similar plugins that support "else" now only count()
+  their input before processing when an else block follows
+* Various optimizations
+* Fixed compiler bug that created a parse error when you had comments in an
+  extended template
+* Fixed extends bug when extending files in other directories using relative
+  paths
+* Fixed parsing bug with "|modifier:param|modifier2} with:colon after it"
+* Bug fixed with smarty functions called with no parameters (in compat mode)
+* Fixed Dwoo::isArray() check, objects implementing ArrayAccess are now
+  valid (thanks to Daniel Cousineau for the patch)
+* Fixed compiler warning when doing {func()->method()} or {func()->property}
+* Fixed compiled/cached files being written in the wrong place when the path
+  to the template contains "../"s
+* Fixed {if} failing with conditions using upper case operators (i.e. AND)
+
+[2008-08-03] 0.9.3
++ Adapters: Added the ZendFramework interface for Dwoo
+  (see /Dwoo/Adapters/ZendFramework/README)
++ Plugins: Added the {a} block plugin to generate <a> tags
++ Syntax: Added the ";" token that allows to group multiple instructions in one
+  single template tag, example: {if $foo; "> $foo";$bar;/} is equal to:
+  {if $foo}> {$foo}{$bar}{/} - This also allow block operations such as:
+  {a http://url.com; "Text" /} which equals to {a http://url.com}Text{/}
++ Syntax: Block plugins that you want to call without content can be
+  self-closed just like XML tags (e.g. {a "http://url.com" /} ). Be careful not
+  to close a non-block plugin like that however, since it will close it's
+  parent block
++ Syntax: Static methods can be called using {Class::method()}
++ Syntax: It is now possible to use a plugin's result as an object and call
+  a method or read a property from it, i.e. {fetchObject()->doStuff()}
++ API: Added Dwoo_Plugin::paramsToAttributes() utility function to help
+  with the creation of compilable xml/html-related plugins
++ API: Added Dwoo->setPluginProxy() and Dwoo_IPluginProxy that allow you to
+  hook into the compiler's plugin subsystem to provide your own plugin calls.
+  Thanks to Denis Arh for the patch
+   => http://forum.dwoo.org/viewtopic.php?id=70
++ API: Dwoo->addPlugin() has a third parameter to mark a plugin as compilable
++ Compiler supports method calls into a method call's parameters
+* Dwoo_Compiler::implode_r is now public/static so it can be used in other
+  places such as plugin proxies
+* Syntax: Math expressions in strings are now only allowed when the entire
+  expression is delimited, e.g. {"/$foo/$bar"} evaluates as just that while
+  {"/`$foo/$bar`"} will result in "/".($foo/$bar), therefore processing the /
+  as a division, this is better since URLs using / are far more common than
+  math in strings
+   => http://forum.dwoo.org/viewtopic.php?id=50
+* Compiler now allows the use of the right delimiter inside strings (e.g. {"}"})
+* Fixed a bug preventing if blocks containing a {elseif} followed by {else}
+* Fixed the Dwoo_ILoader interface and implemented it in Dwoo_Loader now
+   => http://forum.dwoo.org/viewtopic.php?id=70
+* Fixed a compileId auto-generation creating conflicts
+* Include allows paths going in upper levels now such as : "../foo.html"
+* Some compiler fixes regarding custom plugins
+
+[2008-06-28] 0.9.2
+! BC Break: Renamed the {strip} modifier/function to {whitespace}, this does
+  not affect the strip block, that has been moved off the compiler into a
+  plugin. Which is why the name conflict had to be resolved. Please report
+  any issue you might encounter when using the strip block
+! BC Break: Changed the function signature of Dwoo_Block_Plugin::postProcessing
+  it only affects you if you had any custom block plugins, see UPGRADE_NOTES
+  for more details
+! BC Break: Dwoo_ITemplate::cache() must now return the cached file name or
+  false if caching failed, only affects you if you had a custom template class
+  and implemented cache() yourself
+! BC Break: Dwoo_Loader is not static anymore so anything you did on it directly
+  will break. Use $dwoo->getLoader()->addDirectory() instead of
+  Dwoo_Loader::addDirectory() for example
+! BC Break: DWOO_COMPILE_DIRECTORY and DWOO_CACHE_DIRECTORY are gone, set those
+  paths in Dwoo's constructor (i.e. new Dwoo('compiledir', 'cachedir')) if you
+  need to override the default ones
++ Plugins: Added {dynamic} that allows cached templates to have dynamic
+  (non-cached) parts, when rendering a cached page, the dynamic parts can still
+  use the variables you provides
++ Plugins: Added {tif} that acts as a ternary if / allows you to use a ternary
+  operator inside it
++ API: Added a Dwoo_ILoader interface if you want to provide a custom plugin
+  loading solution (use $dwoo->setLoader($myLoader))
++ Added line numbers in compilation errors and improved several error messages
++ Added magic object-access methods to Dwoo_Data, so you can assign values by
+  doing $data->var = $val; instead of $data->assign('var', $val);
++ Added get()/unassign()/isAssigned() methods to read, remove and check for the
+  presence of a var inside a Dwoo_Data object
+* Plugins: added a fifth 'string $implode' parameter to {foreach}, it prints
+  whatever you provide it between each item of the foreach, just like implode()
+* Plugins: added a fourth 'bool $case_sensitive' parameter to {replace}
+* Plugins: added a fourth 'bool $trim' parameter to {capture} that trims
+  the captured text
+* Made the dependency on the hash extension optional
+* Fixed compiler bug that prevented method calls combined with named parameters
+* Fixed compiler bug that prevented the % shortcut for constants to work within
+  function calls (basically it only worked as {%CONST})
+* Fixed compiler bug that prevented empty() to be called
+* Fixed several modifier parsing bugs
+   => http://forum.dwoo.org/viewtopic.php?id=27
+* Fixed empty string parsing in modifier applied to variables
+* Fixed compiler handling of <?php echo "foo" ?>{template_tag} where there was
+  no ';' at the end of the php tag
+* Allowed method calls to work with named parameters
+* Removed checks for methods/properties being present on objects before calling
+  them since these can be handled by __get() and __call()
+   => http://forum.dwoo.org/viewtopic.php?id=22
+* Calling {func (params)} (with the space between function and params) is now
+  allowed
+   => http://forum.dwoo.org/viewtopic.php?id=21
+* The compiler now allows \r, \n and \t to be parameter splitters as well as
+  "," and " ". You can therefore split complex function calls on multiple lines
+* Converted most of the code to follow PEAR Coding Standards, hopefully this
+  didn't break anything that the tests missed
+* A few other minor or internal changes
+
+[2008-05-30] 0.9.1
++ API: Added Dwoo_Compiler->setAutoEscape() and getAutoEscape() to modify the
+  automatic html entity escaping setting. This is disabled by default, and when
+  enabled can be overriden with the {safe $var} plugin or the
+  {auto_escape disable} block plugin. The block plugin can also be used to
+  enable this mode from within a template
++ Syntax: Mixing named and unnamed parameters is now allowed, as long as the
+  unnamed ones appear first
++ Syntax: Added {/} shortcut that closes the last opened block
+* Optimized scope-handling functions, {loop} and {with} are now slightly faster
+* Fixed a bug in {date_format} that prevented anything but unix timestamps to
+  work
+* {literal} and {strip} now follow the LooseOpeningsHandling setting
+* Fixed complex variables (i.e. {$_root[$c[$x.0]].0}) parsing bugs
+* Fixed $dwoo->addResource() breaking if the resource class was not loaded yet,
+  autoload should now be called (thanks mike)
+* Fixed a block stack bug that messed up {textformat} and possibly usermade
+  block plugins
+
+[2008-05-10] 0.9.0
+! BC Break: changed all class names to be PEAR compliant (aka use underscores
+  to separate words/paths), sorry about that but I better do it now than in
+  six months
+! BC Break: $dwoo->output() and get() have been swapped internally, but it
+  doesn't change anything for you unless you called output(*, *, *, true)
+  directly to emulate get(). This was done to reduce some overhead
+! BC Break: $dwoo->getTemplate() changed to $dwoo->templateFactory() and
+  $dwoo->getCurrentTemplate() changed to $dwoo->getTemplate() for consistency
+  among all classes and factory functions
++ Added a compiled version of Dwoo that loads faster (especially with opcode
+  caches such as APC), include Dwoo.compiled.php instead of Dwoo.php on
+  production but if you want to file a bug use Dwoo.php please as it allows
+  you to get the proper file/line number where an error occurs. Do not remove
+  all other files however since they are not all included in the compiled
+  package
++ Plugins: Added {extends} and {block} to handle template inheritance, read
+  more about it at http://wiki.dwoo.org/index.php/TemplateInheritance
++ Plugins: Added {loop} that combines {foreach} and {with}, see
+  http://wiki.dwoo.org/index.php/Block:loop for details
++ Plugins: Added {do} that executes whatever you feed it whitout echoing the
+  result, used internally for extends but you can use it if required
++ Plugins: Added {eol} that prints an end of line character (OS-specific)
++ Syntax: Added shortcut for {$dwoo.const.*} using '%', for example you can use
+  {%FOO} instead of {$dwoo.const.FOO}
++ Syntax: When using named parameters, typing a parameter name without any
+  value is the same as typing param=true, for example {foo name="test" bar} and
+  {foo name="test" bar=true} are equals, can be useful for very complex plugins
+  with huge amounts of parameters.
++ Syntax: Added support for {$foo+=5}, {$foo="a"}, {$foo++} and {$foo--}
++ Syntax: Added shortcut for $dwoo.*, you can now use {$.foreach.foo} instead
+  of {$dwoo.foreach.foo} for example, applies to all $dwoo.* vars
++ Syntax: Added $ as a shortcut for current scope, $_ for $_parent and $__ for
+  $_root
++ API: Added getSource(), getUid() and getResourceIdentifier() to Dwoo_ITemplate
++ API: Added setSecurityPolicy() too Dwoo_ICompiler and modified the arguments
+  of its compile() method
++ API: Added a bunch of utility functions to Dwoo_Compiler, allowing compiled
+  plugins to access more of the compiler internals
++ Both cache and compile IDs can now have slashes in them to create subfolders
+  in the cache/compile dirs
++ Added a DWOO_CHMOD constant that, if set before you include Dwoo, allows you
+  to define the file mode of all the file/directories Dwoo will write, defaults
+  to 0777
++ Added a 'data' argument to {include} to be able to feed data directly into it
+* The compiler now throws Dwoo_Compilation_Exception exceptions upon failure
+  and security problems lead to a Dwoo_Security_Exception being thrown. Runtime
+  plugin errors and such trigger simple php errors to allow the template
+  execution to complete
+* Fixed a potential concurrency issue (thanks to Rasmus Schultz for the patch)
+* Moved all files to Dwoo/Class.php excepted for the core Dwoo.php file
+* Various performance improvements, including the removal of a lot of isset()
+  calls. Doing {$foo} if foo is undefined will now display a PHP warning, but
+  doing {foreach $foo}..{/foreach} will not however, that way you don't have
+  to do {if isset($foo)} before the foreach, but automated isset() calls don't
+  impact performance as much as they did before.
+* API: Dwoo_ITemplate->clearCache now requires a Dwoo instance as its first arg,
+  should not affect you unless you built a custom template class from scratch
+* Reworked Dwoo template rendering to avoid variable conflicts with plugins
+* {include} now uses the current resource if none is provided instead of using
+  file as it did before
+* Dwoo uses include path instead of absolute includes
+* Changed all line endings to Unix (line feed only) and all spaces left have
+  been converted to tabs (tabspace 4)
+* TestFest happened early for Dwoo, lots of new tests and more code covered
+* Fixed a regression in the handling of custom class plugins
+* Fixed various bugs in the Adapter class and related smarty compatibility
+  features
+* Fixed a classpath rebuilding bug that occured on some UNIX platforms due to
+  glob() returning false sometimes for empty folders
+* Fixed a bug in Dwoo_Security_Policy->getAllowedDirectories(), no security
+  issue though
+* Fixed a bug in Dwoo::setScope affecting {loop} and {with}
+* Fixed a parsing bug when doing {"string"|modifier:$var}
+
+[2008-04-09] 0.3.4
+! BC Break: DWOO_PATH constant changed to DWOO_DIRECTORY
+! BC Break: Smarty's @ operator for modifiers is now reversed, for example
+  $array|reverse will reverse the items of that array while $array|@reverse
+  will reverse each item of the given array (as if you used array_map)
++ Syntax: Added support for method calls on objects i.e. {$foo->bar()}
++ Added support for smarty security features, see the DwooSecurityPolicy class
+  and $dwoo->setSecurityPolicy()
++ API: Added a DwooCompiler->setLooseOpeningHandling() method that, if set to
+  true, allows tags to contain spaces between the opening bracket and the
+  content. Turned off by default as it allows to compile files containing
+  css and javascript without the need to escape it through {literal} or \{
++ Added DWOO_CACHE_DIRECTORY and DWOO_COMPILE_DIRECTORY constants that you can
+  set before including Dwoo.php to override the defaults (although
+  Dwoo->setCacheDir/setCompileDir() still work to change that if required)
++ Added the DwooException class
++ Smarty: Added partial support for register_object(), unregister_object() and
+  get_registered_object(). All features can not be supported by the adapter
+  though so you might get compatibility warnings
+* Fixed {elseif} bug that appeared when multiple elseif tags were used in a row
+* Syntax: Improved simple math support to work within variable variables
+  (i.e. you can do {$array[$index+1]}) and within strings as well. To prevent
+  this enclose the variables in backticks (i.e. {"$foo/$bar"} will do the math
+  while {"`$foo`/$bar"} won't as $foo is properly delimited)
+* Changed DwooLoader::addDirectory() so that it writes the class paths cache
+  into DWOO_COMPILE_DIRECTORY, that way you don't have to make your plugin
+  directory writable
+* Made all the error triggering more consistent
+* Changed automatic cacheId generation in DwooTemplateFile/String to be faster
+
+[2008-03-19] 0.3.3
++ Syntax: Added support for $dwoo.const.CONSTANT and
+  $dwoo.const.Class::CONSTANT to read PHP constants from the template
++ Syntax: Added support for on/off/yes/no, that work as aliases for true/false
++ Syntax: Added the $dwoo.charset global variable
++ Plugins: Added {withelse} and made {with} compatible with {else} also
++ API: Added left/right delimiters customization, see DwooCompiler->setDelimiters()
++ API: Added DwooCompiler->triggerError()
++ API: Added Dwoo->clearCache() and DwooITemplate->clearCache() methods
++ Smarty: The smartyCompat prefilter converts {section} tags into {for} tags on the
+  fly, however it's not guaranteed to work with *all* section tags, let me know if
+  it breaks for you
+* {with} now skips the entire block if it's variable doesn't exist, so by
+  itself it acts as if you would do {if $var}{with $var}{/with}{/if}
+* Each resource has a compiler factory function assigned to it, allowing you to
+  easily provide a custom compiler without loading it on every page
+* OutputFilters are now simply called Filters (they still use DwooFilter)
+* Pre/PostFilters have become Pre/PostProcessors (they now use DwooProcessor)
+* Compiler: Fixed parsing bug that prevented function names of 1character
+* Compiler: Changed internal handling of variables to fix some errors being
+  thrown with specific cases
+* Reorganized Dwoo/DwooCompiler and fully commented all the core classes
+  and interfaces
+
+[2008-03-09] 0.3.2
++ Added access to superglobals through $dwoo.get.value, $dwoo.post.value,
+  etc.
++ Added outputFilters to Dwoo (use Dwoo->addOutputFilter and
+  Dwoo->removeOutputFilter)
++ Added preFilters and postFilters to DwooCompiler (use
+  DwooCompiler->addPreFilter, etc)
++ Added a html_format output filter that intends properly the html code,
+  use it only on full page templates
++ Plugins: Added {for} and {forelse} which allow to loop over an array or to
+  loop over a range of numbers
++ Plugins: Added {mailto}, {counter}, {eval}, {fetch} and {include}
++ Syntax : Enhanced support for implicit math operations,
+  {$var+$var2*var3+5} now works. Operations are executed from left to right
+  though, there is no operator priority. (i.e. 1+1*2 = (1+1)*2 = 4, not 3)
++ API: Added resources support through DwooITemplate implementations and
+  Dwoo->addResource()
++ API: Added Dwoo->getTemplate() to get the currently running template object
++ API: Added DwooCompiler::getInstance() to use only one compiler object when
+  rendering from the default compiler and to provide you with a singleton if
+  it's easier, however the class is not a singleton in the sense that it can
+  be instantiated separately
++ API: Added a factory method on DwooITemplate to support resources creation
++ Added a release tag so that all compiled templates are forced to recompile
+  after an update, however it is recommended to cleanup your "compiled"
+  directory now and then as each release uses new filenames
++ Added an abstract DwooFilter class that you can extend to build filters
+* PHP function calls are now case insensitive
+* Syntax: The compiler now parses expressions before modifiers, allowing for
+  {$var/2|number_format} for example
+* DwooTemplateFile now extends DwooTemplateString instead of the other way
+  around as it was before
+* {else} is now a general purpose plugin that can act as 'else' for foreach,
+  for and if/elseif, foreachelse is still available though
+
+[2008-03-05] 0.3.1
++ Added {cycle} function
++ Syntax : Enabled support for associative arrays using
+  array(key="value", key2=5) for example, which you can assign or use in a
+  foreach directly
++ Syntax : Added support for {$var +-/*% X} (i.e. {$var + 4}), useful for
+  simple math operations without the math plugin
++ API : Added append/appendByRef to DwooData
++ Completely rebuilt DwooSmartyAdapter, it should "work" and fail silently if
+  you use a non supported function now, however you can set
+  $smarty->show_compat_errors=true; on it to receive notices about unsupported
+  features that you use
+* Bug fixed in {literal} parsing
+* Bug fixed in smarty functions handling
+* API : Moved Plugin types constants to Dwoo so the compiler doesn't have to
+  be loaded unles really required
+* API : Moved globals and var reinitialization in Dwoo into their own methods
+  so that child classes can easily add globals
+* Some improvements in the compiler output
+* Some changes in the cache handling of DwooTemplateFile
+- Special thanks to Andrew Collins that found many of the bugs fixed in this
+  release
+
+[2008-03-02] 0.3.0
++ Full template cache support
++ DwooTemplateString class to load templates from a string
++ Dwoo::VERSION constant
++ {dump} plugin to print out variables
++ Unit tests (with PHPUnit) covering 73% of the codebase right now, which
+  should help reducing regression bugs in the next versions.
++ Started commenting (with phpdocs) properly all the classes, should be
+  complete for 0.4.0
+* {capture} is now compilable and has a new boolean flag to append output into
+  the target variable instead of overwriting
+* {foreach} supports direct input (instead of only variables), allowing
+  constructs like {foreach array(a,b,c) val}{$val}{/foreach} for example that
+  would output abc.
+* pre/postProcessing functions in block plugins now receive an array of named
+  parameters instead of numbered
+* Major refactoring of DwooTemplateFile and DwooCompiler
+* Cleaned up members visibility in Dwoo/DwooCompiler
+* Fixes in the compiler parsing and general variables handling
+* Multiple bugfixes here and there thanks to the unit tests
+* Optimized {foreach} a lot
+
+[2008-02-19] 0.2.1
+* Compiler fixes for argument parsing and handling of Smarty plugins
+
+[2008-02-14] 0.2.0
++ Added support for plugins made for Smarty (that includes modifiers,
+  functions and blocks). Not thoroughly tested.
++ Major API changes in the way Dwoo must be run, it's now much more
+  flexible and should not change too much in the future.
++ Added support for custom plugins, filters should come in the next version
+  although the API to register them is already in.
+
+[2008-02-08] 0.1.0
+Initial release