Feedback på ny type template

Jeg synes det er alt for besværligt/grimt at have php tags over det hele. Så når du f.eks. skriver <h1><?php $page->header->title() ?></h1>
vil jeg normalt sige <h1>{{header.title}}</h1>.

Det tager selvfølgelig lidt længere tid at parse så, men til gengæld kan jeg så også smide alle mulige andre smarte features ind som f.eks. at templates kan nedarve fra hinanden (i modsætning til de gængse template engines hvor du inkluderer templates i hinanden).

Hvis jeg skal bruge en foreach løkke eller noget andet mere avanceret bruger jeg dog helt almindelig php ligesom du gør i dit eksempel.

Umiddelbart er der vel ikke videre svært at skrive en funktion der konvertere fra JSON til XML som du så kan give til XSLT.

Mig bekendt er JSON syntaksen ikke tilladt i PHP, men du kunne vel bare bruge array syntaks:

JSON

{
     "firstName": "John",
     "lastName": "Smith",
     "age": 25,
     "address": {
         "streetAddress": "21 2nd Street",
         "city": "New York",
         "state": "NY",
         "postalCode": "10021"
     },
     "phoneNumbers": [
         { "home": "212 555-1234" },
         { "fax":"646 555-4567" }
     ]
 }

PHP

[
     "firstName" => "John",
     "lastName" => "Smith",
     "age" => 25,
     "address" => [
         "streetAddress" => "21 2nd Street",
         "city" => "New York",
         "state" => "NY",
         "postalCode" => "10021"
     ],
     "phoneNumbers" => [
         [ "type"=>"home", "number" => "212 555-1234" ],
         [ "type"=>"fax", "number"=> "646 555-4567" ]
     ]
]

Eneste forskel er at du skal skrive =>,[,] i stedet for :,{,}

Godt nok skal du så teste om et array har string eller number keys, under antagelse at folk er fornuftige og ikke blander dem i samme array og, at et tomt array er et number keyed array, så burde det her fortælle typen:

function is_num_array(&$arr){
  if(count($arr)==0){
    return true;
  }
  $k=key($arr)
  if($k===null){
    prev($arr);
    $k=key($arr);
    next($arr);
  }
  return is_int($key);
}

Og konverterings funktionen kunne se ud nogenlunde som det her:

function php2xslt($nodename,$data){
  $str='';
  if(is_num_array($data)){
    foreach($data as $value){
      $str.=php2xlt($nodename,$value);
    }
  }else{
    $str.='<'.$nodename;
    $childs='';
    foreach($data as $key=>$value){        
      if(is_array($value)){
        $childs.=php2xslt($key,$value);
      }else{
        $str.=' '.$key.'="'.$value."'";
      }
    }
    if($childs!=''){
      $str.='/>'
    }else{
      $str.='>'.$childs.'</'.$nodename.'>';
    }
  }
  return $str;
}

Personligt foretrækker jeg at bruge "rigtig" PHP. Altså med tags, som du gør.
Jeg føler at det giver mig større handlefrihed, og flere muligheder for at ændre i layoutet ved forskellige værdier.
(Som fx, hvis man skal udskrive tags til en blog, og der skal være en speciel handling ved kun 1 tag)

EDIT: Tjek evt. 'export' funktionen ud. Det sparer dig for din $page variable.

@Jonas: jeg er til dels enig med dig langt hen ad vejen. Men hvis man skal lave en logisk template løsning, så skal det være med eller uden PHP tags. I princippet skal man jo undgå det, da en template/et view ikke skal indeholde PHP kode i nogen form.

@Sæbekassebil: jeg er bekendt med export. Men trods export giver mere handlefrihed giver den også et større rod af unødvendige variabler. Derudover benytter jeg et dataobject der rekursivt kan gennemløbe et array af værdier, og imitere XSL failsafe kode ved ikke at smide fejl, når man looper en variabel der ikke er et array (ligesom en alm. foreach loop ).

Jeg er stor fan af XSLT som er klart den bedste form for template engine jeg har set. XSLT er dog kun til XML. Men hvis man nu kunne portere denne engine til at bruge JSON.

Til de interesserede så er her et ny eksempel. Dette er er en overbygning på første klump kode fra tidligere indlæg.

 <!-- 
  @template JSON Object model Template test
  @version 0.1
 -->
 <template name="Master3">
     <h2>Template Master3</h2>
     <div class="{/page/settings/title}">
         <for-each select="/page/content/body" as="el">
             <div>
                 <value-of select="el/content" />
                 <for-each select="el/content" as="subel">
                     <div><value-of select="subel" /></div>
                 </for-each>
             </div>
         </for-each>
     </div>
 </template>
 
 <template name="Master2">
     <h2>Template Master2</h2>
     <value-of select="/page/settings/title" />
     <call-template name="Master3" />
 </template>
 
 <html>
     <head>
         <title><value-of select="/page/settings/title" /></title>
         <meta name="keywords" content="{/page/settings/title}" />
         <meta name="description" content="{/page/settings/description}" />
     </head>
     <body class="{/page/settings/title}">
         <value-of select="/page/settings/title" />
         <if test="/page/settings/teee = true()">
             <div class="{/page/settings/title}">
                 <for-each select="/page/content/body" as="el">
                     <div>
                         <value-of select="el/content" />
                         <for-each select="el/content" as="subel">
                             <div><value-of select="subel" /></div>
                         </for-each>
                     </div>
                 </for-each>
             </div>
             <call-template name="Master2" />
         </if>
         <call-template name="Master2">
             <with-param name="el" select="/page/content/body" />
         </call-template>
     </body>
 </html>

Når du bruger {} klammer, er det så fordi det skal konverteres af PHP engine, og i så fald, hvorfor bruger du ikke også XSLT til det?

@Nørden: ved ikke hvor du har hørt at JSON ikke skulle være tilladt i PHP. Ligeledes ved jeg heller ikke hvorfor det ikke skulle være det. Da det efterhånden er blevet til en anerkendt datastruktur. Ydermere må jeg henlede opmærksomheden på http://www.php.net/manual/en/ref.json.php

Der er ingen pointe i at lave flere lag end højst nødvendigt. At konvertere JSON til XML er et lag for meget. XSLT til PHP er lækkert at arbejde i, men er desværre ikke blevet opgraderet til den eksisterende v2.0 som findes i dag.

@Saebkassebil: {} klammerne er til udtræk af værdier, og fungerere i princippet som et "value-of"-tag. Det kan bedst beskrives til inline brug, f.eks når du skal indsætte værdier i HTML attributter.

@Michael:
Inspireret af din idé, og at jeg altid har elsket XML (og derved og XSL(T)), så lavede jeg mig selv en simpel template class:

 <?php if(!defined('BASE_PATH')) exit('No direct script access allowed');
     class Template {
         private $templatePath, $xsl, $processor, $emptyDocument;
         private $templateParameters = array();
         
         public function __construct($path) {
             if(!isset($path) || !file_exists($path)) {
                 throw new Exception('TEMPLATE_INVALID_PATH');
             }
             
             $this->templatePath = $path;
             $this->xsl = new DOMDocument();
             $this->processor = new XSLTProcessor();
             $this->emptyDocument = new DOMDocument();
         }
         
         public function render($return = false) {
             $this->xsl->load($this->templatePath);
             $this->processor->importStyleSheet($this->xsl);
             $this->processor->setParameter('', $this->templateParameters);
             $output = $this->processor->transformToXML($this->emptyDocument);
             
             if($return) {
                 return $output;
             } else {
                 echo $output;
             }
         }
         
         public function setParameters($params, $namespace = 'page') {
             if(!is_array($params)) {
                 throw new Exception('TEMPLATE_INVALID_ARGUMENT');
             }
             
             $namespace = (empty($namespace)) ? '' : $namespace.'.';
             
             $mappedArray = array();
             foreach($params as $key => $value) {
                 if(is_array($value)) {
                     foreach($value as $xKey => $xValue) {
                         $mappedArray[$key.'.'. $xKey] = $xValue;
                     }
                 } else {
                     $mappedArray[$namespace.$key] = $value;
                 }
             }
 
             $this->templateParameters = array_merge($this->templateParameters, $mappedArray);
             
         }
     }
 ?>

Og en simpel XSL fil:

 <?xml version="1.0" ?>
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
     <xsl:output method='html' encoding='utf-8' />
     
     <xsl:template match='/'>
     <xsl:text disable-output-escaping="yes">&lt;</xsl:text>!DOCTYPE html<xsl:text disable-output-escaping="yes">&gt;</xsl:text>
         <html>
             <head>
                 <title><xsl:value-of select='$page.title' /></title>
                 <link rel="stylesheet" type="text/css" href="/spot/style/style.css" />
                 <script type="text/javascript" src="/spot/script/frozen.js"></script>
                 <script type="text/javascript" src="/spot/script/spot.js"></script>
             </head>
             <body>
                 <div id='topbar'>
                     <h1>// spot</h1>
                     <form action="" method='post'>
                         <input id="spotter" name="spotter" type="text" size="30" />
                     </form>
                     <br style="clear: both" />
                 </div>
                 <div id="wrapper">
                     <div id='vertical-aligner'>
                         <div id='header'>
                         </div>
                         <div id='resultbox'>
                             
                         </div>
                     </div>
                 </div>
             </body>
         </html>
     </xsl:template>
 </xsl:stylesheet>

Hvad synes du? Er LIGE startet på XSL, så måske er syntaxen ikke så smuk? Og hvad med klassen? Det er længe siden jeg har udviklet i PHP...

Der er en væsentlig forskel på, at skrive en streng som er JSON encoded, og på, at skrive JSON i php.

JSON encoded streng:

<?php
$k = '{"name":"peter"}';
?>

JSON i PHP:

<?php
$k = {"name":"peter"};
?>

Jeg holder stadigvæk på at det ikke er lovligt at skrive JSON i PHP.

Der er en væsentlig forskel på, at skrive en streng som er JSON encoded, og på, at skrive JSON i php.

JSON encoded streng:

Kode 

<?php
$k = '{"name":"peter"}';
?>

JSON i PHP:

Kode 

<?php
$k = {"name":"peter"};
?>

Jeg holder stadigvæk på at det ikke er lovligt at skrive JSON i PHP.

Men at bruge det, som transportering til data, er helt fint...

Der er vel ca. 3 muligheder:

1. Løse templaten til HTML på serveren med PHP og sende HTML, i dette tilfælde ser jeg ikke stor grund til at encode data til json med php for at en template engine i php så kan decode det, og dermed er mit forslag met at bruge et array i stedet for JSON vel ligeså godt.

2. Lad browserens indlæser visualiser templaten, så skal browseren både have templaten(XSLT) og dataerne(XML). Ud fra Gnu's post antager jeg at XSLT ikke kan læse JSON, derfor igen ikke meget ide i at sende JSON til XSLT, og min ide med at bruge et array på serveren og xml genereringsfunktioner virker. Den anden mulighed ville være at skrive en engine og få den implementeret i alle browsere til filer i json formatet (Og med en .json endelse eller noget.)

3. Mulighed sende JSON, Template og Template Engine til browseren som javascripts i en HTML fil. Template Engine læser JSON filen og templaten og danner HTML. Denne sidste mulighed har dog den lille fordel at den formentlig kunne kombineres med AJAX på skumle og uforudsete måder.


Det kan selvfølgelig være at der er andre muligheder.