Blame view

mustache/php/vendor/Mustache/Loader/InlineLoader.php 3.73 KB
5a739853   patrick.he   commit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
  <?php
  
  /*
   * This file is part of Mustache.php.
   *
   * (c) 2010-2014 Justin Hileman
   *
   * For the full copyright and license information, please view the LICENSE
   * file that was distributed with this source code.
   */
  
  /**
   * A Mustache Template loader for inline templates.
   *
   * With the InlineLoader, templates can be defined at the end of any PHP source
   * file:
   *
   *     $loader  = new Mustache_Loader_InlineLoader(__FILE__, __COMPILER_HALT_OFFSET__);
   *     $hello   = $loader->load('hello');
   *     $goodbye = $loader->load('goodbye');
   *
   *     __halt_compiler();
   *
   *     @@ hello
   *     Hello, {{ planet }}!
   *
   *     @@ goodbye
   *     Goodbye, cruel {{ planet }}
   *
   * Templates are deliniated by lines containing only `@@ name`.
   *
   * The InlineLoader is well-suited to micro-frameworks such as Silex:
   *
   *     $app->register(new MustacheServiceProvider, array(
   *         'mustache.loader' => new Mustache_Loader_InlineLoader(__FILE__, __COMPILER_HALT_OFFSET__)
   *     ));
   *
   *     $app->get('/{name}', function ($name) use ($app) {
   *         return $app['mustache']->render('hello', compact('name'));
   *     })
   *     ->value('name', 'world');
   *
   *     // ...
   *
   *     __halt_compiler();
   *
   *     @@ hello
   *     Hello, {{ name }}!
   *
   */
  class Mustache_Loader_InlineLoader implements Mustache_Loader
  {
      protected $fileName;
      protected $offset;
      protected $templates;
  
      /**
       * The InlineLoader requires a filename and offset to process templates.
       * The magic constants `__FILE__` and `__COMPILER_HALT_OFFSET__` are usually
       * perfectly suited to the job:
       *
       *     $loader = new Mustache_Loader_InlineLoader(__FILE__, __COMPILER_HALT_OFFSET__);
       *
       * Note that this only works if the loader is instantiated inside the same
       * file as the inline templates. If the templates are located in another
       * file, it would be necessary to manually specify the filename and offset.
       *
       * @param string $fileName The file to parse for inline templates
       * @param int    $offset   A string offset for the start of the templates.
       *                         This usually coincides with the `__halt_compiler`
       *                         call, and the `__COMPILER_HALT_OFFSET__`.
       */
      public function __construct($fileName, $offset)
      {
          if (!is_file($fileName)) {
              throw new Mustache_Exception_InvalidArgumentException('InlineLoader expects a valid filename.');
          }
  
          if (!is_int($offset) || $offset < 0) {
              throw new Mustache_Exception_InvalidArgumentException('InlineLoader expects a valid file offset.');
          }
  
          $this->fileName = $fileName;
          $this->offset   = $offset;
      }
  
      /**
       * Load a Template by name.
       *
       * @throws Mustache_Exception_UnknownTemplateException If a template file is not found.
       *
       * @param string $name
       *
       * @return string Mustache Template source
       */
      public function load($name)
      {
          $this->loadTemplates();
  
          if (!array_key_exists($name, $this->templates)) {
              throw new Mustache_Exception_UnknownTemplateException($name);
          }
  
          return $this->templates[$name];
      }
  
      /**
       * Parse and load templates from the end of a source file.
       */
      protected function loadTemplates()
      {
          if ($this->templates === null) {
              $this->templates = array();
              $data = file_get_contents($this->fileName, false, null, $this->offset);
              foreach (preg_split("/^@@(?= [\w\d\.]+$)/m", $data, -1) as $chunk) {
                  if (trim($chunk)) {
                      list($name, $content)         = explode("\n", $chunk, 2);
                      $this->templates[trim($name)] = trim($content);
                  }
              }
          }
      }
  }