PEPr: Latest proposals with status Draft

PEPr Proposal [711]: Web Services::Services_Hatena

2025-02-18T17:47:19-05:00

Proposed package: Web Services::Services_Hatena

Proposer: Makoto Tanaka

Interface to Hatena's XML-API.

feature, follows:

(1).

It provides objects to operate Hatena's Bookmark or Fotolife service.

For example, add your URL to social bookmark,

or delete image file from foto service

(2).

It provides objects to get information from Hatena Web Site.

For example, search, number of registrated bookmark,

and autolinked keyword.

"AutoLink" function is interesting. If your keyword is popular in Hatena,

you will get the autolinked keyword string.

-- example --

Before)

"I like PHP."

After)

"I like <a class="keyword" target="_blank" href="http://d.hatena.ne.jp/keyword/PHP">PHP</a>."

--

The Hatena's explanation is,

please read here :

http://news.php.net/php.pear.dev/41531

Please give me a lot of opinions,

The dynamic atmosphere vulkan 777 opens the world of bright casino-games in front of the players, offering a wide selection of slots, roulette, poker and other gambling entertainments. Here everyone can experience luck, plunging into the atmosphere of a real game holiday, where excitement and the possibility of winning are always in the foreground.

PEPr Proposal [710]: HTML::Template_Savant

2025-02-18T17:30:45-05:00

Proposed package: HTML::Template_Savant

Proposer: Paul Jones

HTML_Template_Savant

Table of Contents

Other Reasons For Savant

Possible Enhancements

An Overview

Savant is a powerful but lightweight template system for PHP. It is primarily for PHP developers, not HTML designers, although anyone with any amount of PHP knowledge can use it.

Savant uses PHP itself as its template language so you don't need to learn a new markup system (c.f. comments and explanation from Harry Fuecks and Brian Lozier). Savant leverages the existing strengths of PHP to create the most effective template system possible.

Savant is not Xipe-lite, becuase Savant is not a compiling template engine. All compiling template engines have an inherent security risk of requiring a writable directory, as well as making re-distributable templates very difficult to maintain. Savant does not carry this risk or diffuculty.

Unlike other non-compiling template engines, Savant has no need for complex template parsing logic, and is therefore lightweight, faster than any existing template engine, and has the capability to generate binary files as well as text files. Savant could be used to generate customized images, for instance. No HTML_Template_* engine has this kind of power. In fact, a better top-level category for Savant would be just "Template" (for "Template_Savant").

Savant has an object-oriented system of template plugins and output filters, so it sports almost all of the power and flexibility of Smarty with almost none of the overhead.

Provides

Savant...

assigns variable copies (scalar, array, or object) and variable references for parsing through to a PHP-based template script via the methods assign() and assignRef() (there is an assignObject() method specifically for assigning object references)

includes then displays or returns the template script output via the display() and fetch() methods

provides an object-oriented system of plugins that add "convenience functions" for your display logic using plugin() and splugin() methods

provides an object-oriented system of output filters to automatically process the parsed output of the template script via the setFilter() and mapFilter() functions.

provides a simple path management system through addPath(), getPath(), and findTemplate() that allows you mix and match locations for plugins, filters, and templates, making it a great foundation for distrbuted and/or theme-aware applications.

has full documentation at http://phpsavant.com/ with examples and user comments.

Savant does not compile templates. Savant templates are written in plain, natural PHP with regular <?php ... ?> tags, so no compilation or evaluation is necessary; it just includes the template code within the Savant object context at display() or fetch() time.

Savant does not have a built-in caching mechanism. If you want to cache output, I figure you probably want your application to provide that, not the template subsystem. Use Cache or Cache_Lite if you want to cache Savant output.

Example

Logic Script

Here is an example use of Savant. The following business logic script populates and displays a Savant template (shown below).



<?php





// load the Savant class file

require_once 'Savant.php';



// generate an array of book authors and titles

$booklist = array(

    array(

        'author' => 'Stephen King',

        'title' => 'The Stand'

    ),

    array(

        'author' => 'Neal Stephenson',

        'title' => 'Cryptonomicon'

    ),

    array(

        'author' => 'Milton Friedman',

        'title' => 'Free to Choose'

    )

);



// generate a list of some other variables

$varlist = array(

    'var1' => 'some value',

    'var2' => 'some other value',

    'var3' => 'yet another value'

);



// create a title for the page

$title = "My Page Title";



// create a Savant object

$savant =& new Savant();



// assign values to the template variables

$savant->assign('book', $booklist);

$savant->assign('title', $title);

$savant->assign($varlist);



// display the template with the assigned values

$savant->display('example.tpl.php');



?>

In the above example, we use an array to assign a number of template variable tokens at once; it is just as easy to assign an object instead of an array, and the object properties will be assigned to the template.

Template Script

Here is the Savant template script, called example.tpl.php. Note how we use the alternative syntax for control structures here; it's not required, but it can be easier to read in many cases.

<html>



    <head>

        <title><?php echo $title ?></title>

    </head>



    <body>

        

        <p>These variables were set as an array where the array key 

        was the variable name and the array value was the variable 

        value.</p>

        

        <ul>

            <li><?php echo $var1 ?></li>

            <li><?php echo $var2 ?></li>

            <li><?php echo $var3 ?></li>

        </ul>

        

        <?php if (is_array($book)): ?>

            

            <table>

                <tr>

                    <th>Author</th>

                    <th>Title</th>

                </tr>

                

                <?php foreach ($book as $key => $val): ?>

                    <tr>

                        <td><?php echo $val['author'] ?></td>

                        <td><?php echo $val['title'] ?></td>

                    </tr>

                <?php endforeach; ?>

                

            </table>

            

        <?php else: ?>

            

            <p>There are no books to display.</p>

            

        <?php endif; ?>

        

    </body>

</html>

Note that the template language is natural PHP without any special markup or "helpful" shortcuts.

Because the template is in natural PHP, any errors in processing the template are immediately transparent, as they are reported on the actual source template script and not an intermediary cached or compiled script.

Plugins and Filters

You can use the standard Savant plugins within your Savant template, and you can write your own. Savant plugins are comparable to Smarty plugins. Please see http://phpsavant.com/index.php?page=SavantPlugins for more information.

You can use the standard Savant output filters on the displayed or fetched template output, and you can write your own. Please see http://phpsavant.com/index.php?page=SavantFilters for more information.

Caching

Here is a simple example of how to cache output with Savant and Cache_Lite.



<?php



// assume existence of Cache_Lite object called $cache

// and a unique page ID called $id.  hit the cache.

$output = $cache->get($id);



// was there cached output?

if (! $output) {

    // no, generate and save it

    $savant =& new Savant();

    $savant->assign(...); // whatever

    $output = $savant->fetch('template.tpl.php');

    $cache->save($output, $id);

}



echo $output;

?>

Other Packages

Why does PEAR need another template system? Why not contribute to another package?

All of the PEAR template packages do some form of template compiling and evaluation, and they all (with one exception, sort of) use a custom template language. Savant does neither: no compiling, and no special markup.

IT, PHPLIB, Sigma

These template engines are not directly comparable to Savant for various reasons.

IT -- Evaluates templates with regular expressions. A holdover from PHP3 and early PHP4 days.

PHPLIB -- Evaluates templates with regular expressions. A holdover from an earlier framework system.

Sigma -- Evaluates templates with regular expressions, and optionally caches the evaluated template code.

Flexy, Xipe

These template engines are comparable to Savant because of the power and flexibility they provide.

Flexy -- Compiles to PHP from custom markup. No comparable plugin or output filter system.

Xipe -- Compiles to PHP from custom markup. No comparable plugin or output filter system.

Again, Savant is already in PHP, so no compilation is necessary. Although Xipe supports pre- and post-filters, they apply to the compiled PHP code, not the generated output.

Of these template systems in PEAR, the one that is brought up most often form comparison is Xipe. This came up on the Savant website; the question is verbatim, but I have updated and edited the answer for use in this proposal (it is substantially the same answer as on the website).

Question:

Could you please outline the major differences of Savant compared to

HTML_Template_Xipe? To me it seems these two projects have the same goals

but Xipe is easier to use (no need for <?php ... ?> and automatic echoing

of values). I am referring to Xipe using the SimpleTag language here.What does Savant offer over Xipe?

My answer:

Among other things, Xipe compiles its templates, and Savant does not.
Even though Xipe uses PHP as its language, it still compiles the

templates, which adds to time and overhead on the first processing pass

(and perhaps subsequent passes). Savant uses plain PHP and does not need

to compile.

Xipe uses variables directly from the script, without a step for

"assigning" them to the template; Savant uses an explicit "assign()"

method to push variables to the template.

...

The documentation for Xipe is not complete, although it does come in three

flavors (.html, .sxw, and .pdf); Savant docs are complete and online with

comments enabled. :-)

Xipe does not appear to have a plugin system like Savant, although it does

have a similar filter system (but there's no documentation on how to write

your own filters). ...

Xipe tries to add new template language elements (the SimpleTag language),

tries to interpret indents, and so on. Yes, you can "turn off" those

features but you have to know about them to do that. Savant uses PHP, all

of PHP, and nothing but PHP, in normal PHP format (ugly long tags and

everything ;-).

In short, the "simplicity" of Xipe takes some time to learn and get used

to; Savant is just PHP right out of the box.

None of this is to say that Xipe is bad; it is certain that it appeals to

many developers (e.g., its translation routines look quite nice).

Other Reasons For Savant

Savant templates are easy for new and experienced PHP developers to comprehend, modify, and debug, becuase templates are already in PHP (no need to learn a new template markup)

Savant templates, because they are already in PHP, can be documented with phpDocumentor.

Savant templates can be used for anything: HTML, RSS, XML, PDF, RTF, any kind of binary or text file.

Savant does not attempt to impose on your coding style any more than minimally necessary, and at the same time it tries to operate as intelligently and transparently as possible. For example, if you like assigning individual scalar elements, assign() works for you; if you prefer to assign by associative array, assign() works for you too; finally, if object properties are your thing, assign() still works for you.

Savant is perfect for distributed applications. Among other things, the end user does not have to worry about compile-directory or cache-directory permissions, because Savant does not compile templates. Because of the path management utilities in Savant, developers can make their applications theme-aware with little effort.

Savant is STABLE at version 1.5 and in production at many high-traffic sites, although the package file linked in this proposal is 0.0.x-devel due to refactoring based on proposal commentary.

Harry Fuecks notes:

...it's "low risk" for users - there's minimal lock in to the template syntax - if someone decides to ditch Savant at a later date, the templates can, more or less, still be used.

And finally, in reference to a recent PEAR-QA thread, it appears that Wolfram Kriesing is orphaning Xipe. Because Flexy is the natural successor of Xipe, Xipe may eventually be deprecated.

Possible Enhancements

Add I18N plugins or filters

When PHP5 is widely available, use __call() overloading to call plugins instead of $this->plugin()

Casino Vavada welcomes new players with several exciting bonuses. Get 100 free spins as a gift to start your journey in the world of slots, and also enjoy a 100% bonus on your first deposit.

PEPr Proposal [708]: RFC::KeyCDN_API

2014-12-16T14:08:02-05:00

Proposed package: RFC::KeyCDN_API

Proposer: Peter Meyer

PHP Library for the KeyCDN REST API. The KeyCDN API allows you to manage zones, zonealiases, zonereferrers or generate reports. JSON will be returned in all responses from the API, including errors.

Create CDN Account

PEPr Proposal [696]: System::Net_Syslog

2013-09-18T20:40:57-05:00

Proposed package: System::Net_Syslog

Proposer: Laurent Vromman

The Syslog class is a syslog client implementation in PHP following the RFC 3164, 5424, 5425, 5426 rules.

This class is compatible with PHP logger constants for serverity and facility.

Default value are UDP connection with RFC3164 mode

PEPr Proposal [695]: PHP::BreakpointDebugging_PHPUnit

2013-09-16T19:34:58-05:00

Proposed package: PHP::BreakpointDebugging_PHPUnit

Proposer: Hidenori Wasa

Executes unit test files continuously, and debugs with IDE.

Also, creates code coverage report, then displays in browser.

PEPr Proposal [686]: Date and Time::Date_Holidays_Serbia-0.1.0

2012-12-19T03:28:18-05:00

Proposed package: Date and Time::Date_Holidays_Serbia-0.1.0

Proposer: Boban Acimovic

Date_Holidays helps you calculate the dates and titles of holidays and other special celebrations. This is the driver for calculating holidays in Serbia.

PEPr Proposal [684]: File Formats::PCB

2012-12-03T20:20:52-05:00

Proposed package: File Formats::PCB

Proposer: Matt Jenkins

Collection of nested classes to interact with and manipulate gEDA PCB files. Provides a single coherent parent object for an entire PCB with a tree of sub objects within it for every structure within the file. Objects can be manipulated within the tree, and the whole tree can be output again in gEDA PCB format.

PEPr Proposal [680]: Mail::Mail_AmazonSES

2012-09-13T23:48:14-05:00

Proposed package: Mail::Mail_AmazonSES

Proposer: Gregorio Hernandez Caso

Amazon SES implementation of the PEAR Mail:: interface

PEPr Proposal [677]: Payment::Balanced

2012-04-03T01:39:34-05:00

Proposed package: Payment::Balanced

Proposer: mahmoud abdelkader

Balanced PHP client for payments

PEPr Proposal [676]: Semantic Web::FourStore

2012-03-12T16:32:47-05:00

Proposed package: Semantic Web::FourStore

Proposer: Daniel O'Connor

Fourstore (4store-php) is a library to interact with the 4store datastore.

It provides a thin wrapper around a SPARQL endpoint, and provides methods to add information, update information, remove information, etc from the store.

While the library itself has been published previously, it hasn't had many improvements. One particular fork has added a number of enhancements, but not in a fashion suitable for others to reuse (ie:custom implementations of Net_Ping, inclusion of other external libraries in the core source, etc).

Likely future steps for this package would include taking the "best of" from other forks, but ensuring they are implemented in a reusable PEAR-friendly fashion.