Changeset 2604

Timestamp:

12/06/07 13:17:29 (5 years ago)

Author:

tasuku

Message:

r332@dhcp158 (orig r75): tasuku | 2007-09-17 03:12:21 +0900
cache with include/extends properlly refreshed

Files:

• lang/php/mumu/trunk/mumu.php (modified) (25 diffs)

lang/php/mumu/trunk/mumu.php

@@ -206 +206 @@
 }
 
-class MuNode {
-  public function _render() {
-    return '';
-  }
+interface MuNode {
+  public function _render($context);
 }
 
@@ -229 +227 @@
 }
 
-class MuErrorNode extends MuNode {
+class MuErrorNode implements MuNode {
   private $errorMsg;
   private $filename;
@@ -278 +276 @@
 
 // 1�ĤΥƥ�졼�Ȥ������������
-class MuFile extends MuNode {
+class MuFile implements MuNode {
   public $nodelist;        // �ե������ѡ�������NodeList
-  private $block_dict;      // nodelist�������ock̾ => MuBlockNode(�λ���
-  private $parent_tfile;    // extends���������ƥƥ�졼��  function __construct($nodelist, $block_dict, $parentPath = null, $path = null) {
+  private $block_dict;     // nodelist�������ock̾ => MuBlockNode(�λ���
+  public $include_paths;   // include�����ե��������ʥ�����������ǻȤ���  public $path;            // ��ʬ�Υե�����
+  private $parent_path;    // extends�Υե�����
+  private $parent_tfile;   // extends���������ƥƥ�졼��  function __construct($nodelist, $block_dict, $include_paths,
+                       $path = null, $parent_path = null) {
     $this->nodelist = $nodelist;
     $this->block_dict = $block_dict;
-    if ($parentPath && $path) {
-      if (($epath = MuUtil::getpath($path, $parentPath)) === false
-          || ($this->parent_tfile = MuParser::parse_from_file($epath)) === false) {
+    $this->include_paths = $include_paths;
+    $this->path = $path;
+    if ($parent_path && $path) {
+      if (($this->parent_path = MuUtil::getpath($path, $parent_path)) === false
+          || ($this->parent_tfile = MuParser::parse_from_file($this->parent_path)) === false) {
         throw new MuParserException('invalid filename specified on extends');
       }
@@ -327 +330 @@
   }
   public function is_child() {
-    return ($parent_tfile !== false);
-  }
-}
-
-class MuTextNode extends MuNode {
+    return (isset($this->parent_tfile));
+  }
+  // extends��clude���Ƥ��������뤬��������������Ȥ˹����������뤫
+  public function check_cache_mtime($cache_mtime) {
+    foreach ($this->include_paths as $inc_path) {
+      if ($cache_mtime < filemtime($inc_path)) {
+        return false;
+      }
+    }
+    if (isset($this->parent_path)) {
+      if ($cache_mtime < filemtime($this->parent_path)) {
+        return false;
+      }
+      // check parent
+      return $this->parent_tfile->check_cache_mtime($cache_mtime);
+    }
+    return true;
+  }
+}
+
+class MuTextNode implements MuNode {
   private $text;
   function __construct($text) {
@@ -341 +360 @@
 }
 
-class MuVariableNode extends MuNode {
+class MuVariableNode implements MuNode {
   private $filter_expression;
   function __construct($filter_expression) {
@@ -356 +375 @@
 }
 
-class MuIncludeNode extends MuNode {
+class MuIncludeNode implements MuNode {
   private $tplfile;
-  function __construct($includePath, $path) {
-    if (($epath = MuUtil::getpath($path, $includePath)) === false
+  function __construct($include_path, $path) {
+    if (($epath = MuUtil::getpath($path, $include_path)) === false
         || ($this->tplfile = MuParser::parse_from_file($epath)) === false) {
       throw new MuParserException('include filename is invalid');
@@ -367 +386 @@
     return $this->tplfile->_render($context);
   }
-}
-
-class MuBlockNode extends MuNode {
+  public function get_tplfile() {
+    return $this->tplfile;
+  }
+}
+
+class MuBlockNode implements MuNode {
   public $name;
   public $nodelist;
@@ -404 +426 @@
 }
 
-class MuCycleNode extends MuNode {
+class MuCycleNode implements MuNode {
   private $cyclevars;
   private $cyclevars_len;
@@ -426 +448 @@
 }
 
-class MuDebugNode extends MuNode {
+class MuDebugNode implements MuNode {
   function _render($context) {
     ob_start();
@@ -445 +467 @@
 }
 
-class MuFilterNode extends MuNode {
+class MuFilterNode implements MuNode {
   private $filter_expr;
   private $nodelist;
@@ -465 +487 @@
 }
 
-class MuForNode extends MuNode {
+class MuForNode implements MuNode {
   private $loopvar;
   private $sequence;
@@ -513 +535 @@
 }
 
-class MuIfNode extends MuNode {
+class MuIfNode implements MuNode {
   private $bool_exprs;
   private $nodelist_true;
@@ -559 +581 @@
 }
 
-class MuIfEqualNode extends MuNode {
+class MuIfEqualNode implements MuNode {
   private $var1;
   private $var2;
@@ -589 +611 @@
 }
 
-class MuSpacelessNode extends MuNode {
+class MuSpacelessNode implements MuNode {
   private $nodelist;
   function __construct($nodelist) {
@@ -599 +621 @@
 }
 
-class MuTemplateTagNode extends MuNode {
+class MuTemplateTagNode implements MuNode {
   private $tagtype;
   // TODO: php5 don't support array as const...
@@ -620 +642 @@
 }
 
-class MuWidthRatioNode extends MuNode {
+class MuWidthRatioNode implements MuNode {
   private $val_expr;
   private $max_expr;
@@ -643 +665 @@
 }
 
-class MuNowNode extends MuNode {
+class MuNowNode implements MuNode {
   private $format_string;
   function __construct($format_string) {
@@ -653 +675 @@
 }
 
-class MuFirstOfNode extends MuNode {
+class MuFirstOfNode implements MuNode {
   private $vars;
   function __construct($vars) {
@@ -974 +996 @@
 
 class MuParser {
-  private $template;             // �ѡ�����Υƥ�졼����� private $template_len;         // �ƥ�졼�����Ĺ��
-  private $template_path;         // �ƥ�졼�ȤΥѥ�(����)
-  private $block_dict = array(); // block���� => block�ؤλ���  private $extends = false;      // extends�ξ��Υե�����
-  private $spos = 0;             // ���ߥѡ�����ΰ��
+  private $template;                // �ѡ�����Υƥ�졼����� private $template_len;            // �ƥ�졼�����Ĺ��
+  private $template_path;           // �ƥ�졼�ȤΥѥ�(����)
+  private $serialize_path;          // �ѡ����ѤߤΥƥ�졼�Ȥ򥷥ꥢ�饤����������ݴ�ath
+  private $block_dict = array();    // block���� => block�ؤλ���  private $extends;                 // extends�Υե�����
+  private $include_paths = array(); // include���Ƥ����������ΰ�
+  private $spos = 0;                // ���ߥѡ�����ΰ��
   # template syntax constants
   const FILTER_SEPARATOR = '|';
@@ -992 +1016 @@
   // FIXME: ����������Ǥ������ѡ�����������äƤޤ�
 
-  function __construct($template, $template_path = null) {
+  function __construct($template, $template_path = null, $serialize_path = null) {
     $this->template = $template;
     $this->template_len = strlen($template);
     $this->template_path = $template_path;
+    $this->serialize_path = $serialize_path;
   }
 
@@ -1134 +1159 @@
     switch ($in[0]) {
       // TODO: ���������      case 'extends':
-        if ($this->extends !== false) {
+        if (isset($this->extends)) {
           return $this->make_errornode('multiple_extends_tag');
         }
@@ -1157 +1182 @@
         $this->spos = $lpos + 2;
         $node = new MuIncludeNode($param[1], $this->template_path);
+        $tplfile = $node->get_tplfile();
+        $this->include_paths[] = $tplfile->path;
+        unset($tplfile->path);
+        // ���󥯥롼�ɤΥ��󥯥롼��褬�������줿�饭����������
+        if (isset($tplfile->include_paths)) {
+          $this->include_paths = array_merge($this->include_paths, $tplfile->include_paths);
+          unset($tplfile->include_paths);
+        }
         break;
       case 'block': // endblock
@@ -1361 +1394 @@
   }
 
-  static public function parse_from_file($template_path, $serialize_path = null) {
-    if (($t = file_get_contents($template_path)) === false) {
-      return false;
-    }
-    // check cache
-    $cachePath = $template_path.'.cache';
-    if ($useSerialize &&
-        file_exists($cachePath) &&
-        filemtime($template_path) <= filemtime($cachePath)) {
-      $mf = MuUtil::unserialize_from_file($cachePath);
-    } else {
-      $p = new MuParser($t, $template_path);
+  static public function parse_from_file($template_path, $serialize_store = null) {
+    // ������������å�
+    if (isset($serialize_store)) {
+      if (stristr($serialize_store, 'file://') == 0) {
+        // TODO: check whether absolute path or not
+        if (($spath = realpath(substr($serialize_store, 7))) === false) {
+          return false;
+        }
+        $sfpath = $spath . '/' . basename($template_path) . '.cache';
+        if (file_exists($sfpath)) {
+          if (($sfmtime = filemtime($sfpath)) === false) {
+            return false;
+          }
+          if (filemtime($template_path) <= $sfmtime) {
+            $mf = MuUtil::unserialize_from_file($sfpath);
+            if (!$mf->check_cache_mtime($sfmtime)) {
+              unset($mf);
+            }
+          }
+        }
+      } else {
+        // TODO: now file cache only
+        return false;
+      }
+    }
+    if (!isset($mf)) {
+      if (($t = file_get_contents($template_path)) === false) {
+        return false;
+      }
+      $p = new MuParser($t, $template_path, $serialize_path);
       try {
         list($nl) = $p->_parse(array());
@@ -1379 +1430 @@
         $nl->push($p->make_errornode($e->getMessage()));
       }
-      $mf = new MuFile($nl, $p->block_dict, $p->extends, $template_path);
-      MuUtil::serialize_to_file($mf, $cachePath);
+      $mf = new MuFile($nl, $p->block_dict, $p->include_paths, $template_path, $p->extends);
+      if (isset($sfpath)) {
+        MuUtil::serialize_to_file($mf, $sfpath);
+      }
     }
     return $mf;
@@ -1393 +1446 @@
       $nl->push($p->make_errornode($e->getMessage()));
     }
-    return new MuFile($nl, $p->block_dict);
+    return new MuFile($nl, $p->block_dict, $p->include_paths);
   }