[RESOLVED] Best Practice Question - Generating HTML with PHP functions

[ncracraf]

Hi Everyone,

Wanted to get anyone's thougths who had time to spare on the practice of "functionalizing" HTML page creation with PHP. The website project I'm working on has three primary page layouts that repeat over and over. These layouts are 1) A search form (members, listings, requests, products, etc.), 2) Listing results (lists results from the search form), and 3) Basic content (legal, privacy policy, contact us, etc).

All 1) Search and 2) Results pages have the same styles; however the fields and field types change depending on the object they represent. This is probably obvious...the fields on a member search form are different than those on the product search form.

My basic question is, has anyone out there adopted a purely functionalized approach to generating HTML code with PHP? And what is your experience with this approach? Any tips on books, guides, etc? Just to clarify, I'm not asking about encapsulating HTML in PHP (echo "<tr><td>Hello World</td></tr>") as I know most of you do this anyway. I'm talking about calling a few PHP functions to build the entire HTML code and being able to reuse these functions across the majority of the site.

I've seen some PEAR functions that come close to this but before I revamp my design approach, thought I'd check in to get your thoughts.

Thanks very much.

[bpat1434]

I think you are talking about a templating system right? Something where you can just use the same pages multiple times and call a class or function once and it generates the information, right?

Easy enough. I read an article over at DevShed on Building a Template Parser Class

[ncracraf]

Thanks Brett. Your link gets me closer than where I was. The template I get - what's difficult for me to envision is how to define functions or classes to bridge the database table definitions and web page construction.

For example, let's say you have a table with four columns...

ID INT(11)
COL_A TINYINT
COL_A VARCHAR(100)
COL_B BLOB

Using this information, you need three web pages - a search page, a new/update page and a results page.

I'm trying to find examples of any constructors that define the data elements (database elements) and corresponding presentation logic (check box or radio button, single line edit or multiline, etc) and business rules (required or not, masked or not, etc...). You could then pass this object instance to your template code that would then know not only how to form the page but also how to display and manage the field level elements.

Right now I'm sort of doing this with multi-dimensional arrays; however, it's starting to get a little cumbersome trying to remember what data definition element is in what column. And arrays aren't really too flexible.

Anyway, I may be getting a little too abstract for this thread. I'll keep it open for a little bit longer and then wrap it up.

Thanks again,

Nathan

[jazz_snob]

I am finally getting around to implementing a View class. I think trying to write a class that can generate all the possible HTML markup is not a good idea. Templates are great. So I am trying to find a middle ground (ok not in the middle, more leaning to template side).

I basically made a wrapper around a templating class (Xtemplate to be precise, because it seems light and fast). Here's the basic outline. I think the next step will be to write TransformViews . The biggest benefit I found is I can make fewer Xtemplate files because I can reuse them. For example, I reused the same template for browsing records that I used to search records and to display search results.

/**
 * I work up a basic Xtemplate .xtpl file and pass it as argument 
 * to the constructor.
 */
class View( $template, $template_directory, $title, $css ) {}
/**
 * send output to browser
 */
function display() {}
/**
 * the xtpl file I gave in the constructor has a table in it; this func
 * will populate it; the xtpl contains mark up like this:
 * <td>{DATA.name}</td> so the associative array
 * is used to connect value to the right column
 */
function tableFromArray($assoc_array) {} 
/**
 * or populate from a result set
 */
function tableFromResultSet( $res ) {}
/**
 * Setting individual values in xtemplate that aren't in a table
 * eg $assoc_array = array( 'name'=>$name, 'email'=>$email, etc...)
 * will fill in {name} {email} and other replacements in the template.
 */
function update($assoc_array) {}
/**
 * wrapper around the Xtemplate assign() func
 */
function assign( $key, $value ) {}
/**
 * Add paging functionality to the display
 * @param int $page the current page #
 * @param int $limit how many rows to display,
 * @param int $total  total # of rows
 * @param string $href my hack because sometimes you have
 * other params in the query string...usually its  just ''
 */
function addPager( $page, $limit, $total, $href ) {}
/**
 * @param string $block a section in the xtpl file, for example, I might
 * not want to display the search form on some page, so I only parse it
 * (ie display it) when I need to...its a cludge for now
 */
function parseBlock($block) {}

[Plasma]

Objects.

Create objects to represent your html code, for example, if you have a generic table format:

$table =& new TableObject();

$table->AddRow();
$table->AddColumn("Search Result");
$table->AddColumn("Search Rating");

foreach ($results As $result)
{
$table->AddRow();
$table->AddColumn($result['name']);
$table->AddColumn($result['rating']);
}

$table->Render();

Basic example.

We construct a TableObject. We call the AddColumn and AddRow methods of the object to add new rows/columns to our result set, finally, we call the objects Render method to output the HTML to the page.

The object is responsible for rendering.

This also means, you can use this object anywhere on your website - If you change the style of all table objects, you can just edit the render method of the table object, and have the changes reflect all over your site!

Same goes for creating other objects (Stuff like TextControl, SearchBox perhaps etc).

Basically, since using a template may be too restrictive, you can build your pages using objects as mentioned and be able to easily update the code.

Another tip is to have all your web objects inherit a basic component class:

class TableObject extends WebComponent

WebComponent may have simple properties such as Visible and Name.

Therefore, each object that inherits component, you can set a Visible on/off, and in your Render classes decide (depending if visible is on or not) whether you really do want to render the object or not.

Just an example, but im sure you would find using objects to be a lot easier.

[ncracraf]

Perfect. Thanks for the feedback - these pointers are exactly what I was looking for.

Thanks again.