public function testAutoloader()
 {
     $loader = new Mustache_Autoloader(dirname(__FILE__) . '/../../fixtures/autoloader');
     $this->assertNull($loader->autoload('NonMustacheClass'));
     $this->assertFalse(class_exists('NonMustacheClass'));
     $loader->autoload('Mustache_Foo');
     $this->assertTrue(class_exists('Mustache_Foo'));
     $loader->autoload('\\Mustache_Bar');
     $this->assertTrue(class_exists('Mustache_Bar'));
 }

 function build_templates()
 {
     global $LANG;
     if (!$this->build_language_file()) {
         return false;
     }
     Model::load_library('mustache.php/src/Mustache/Autoloader');
     Mustache_Autoloader::register();
     $m = new Mustache_Engine();
     $base_template_dir = APP_ROUTE . "/templates/app";
     $template = file_get_contents("{$base_template_dir}/all-templates.mustache");
     $rendered = $m->render($template, $LANG);
     // "Hello, world!"
     $template_directory = $base_template_dir . "/{$this->language_code}/build/";
     $template_name = 'all-templates.html';
     $template_full_path = $template_directory . $template_name;
     if (!is_writable($template_directory)) {
         AppMessage::set('Template directory is not writable. Please make sure to read the instructions in the Translation section of the documentation before using this functionality');
         return false;
     }
     $this->version_existing_file($template_full_path, $template_directory, $template_name);
     $build = fopen($template_full_path, 'w');
     if ($build) {
         fwrite($build, "<script type=\"text/x-templates\">\n\n");
         fwrite($build, '<!-- ' . date('F j, Y, g:i:s a', time()) . " -->\n\n");
         fwrite($build, $rendered);
         fwrite($build, '</script>');
         return true;
     } else {
         AppMessage::set('Error building template file');
         return false;
     }
 }

 public function __construct(Filesystem $file)
 {
     require __DIR__ . '/../../vendor/mustache/mustache/src/Mustache/Autoloader.php';
     \Mustache_Autoloader::register();
     $this->file = $file;
     $this->mustache = new Mustache();
 }

 /**
  * Creates or returns an instance of this class.
  *
  * @return  Vimeography A single instance of this class.
  */
 public static function get_instance()
 {
     if (!isset(self::$instance) and !self::$instance instanceof Vimeography) {
         self::$instance = new self();
         self::$instance->_define_constants();
         self::$instance->_include_files();
         Mustache_Autoloader::register();
         if (is_admin()) {
             new Vimeography_Admin_Scripts();
             new Vimeography_Admin_Actions();
             new Vimeography_Base();
             new Vimeography_Admin_Menu();
             new Vimeography_Admin_Welcome();
             new Vimeography_Admin_Plugins();
             self::$instance->updater = new Vimeography_Update();
         }
         // Can save these in public vars if need to access
         new Vimeography_Database();
         new Vimeography_Upgrade();
         new Vimeography_Deprecated();
         new Vimeography_Init();
         new Vimeography_Ajax();
         self::$instance->addons = new Vimeography_Addons();
         new Vimeography_Robots();
         new Vimeography_Shortcode();
     }
     return self::$instance;
 }

 protected final function loadMustache()
 {
     require_once "../cls/includes/Mustache/Autoloader.php";
     Mustache_Autoloader::register();
     $this->m = new Mustache_Engine(array("loader" => new Mustache_Loader_FilesystemLoader("../tpl/html/")));
     $this->baseTpl = $this->m->loadTemplate("base");
 }

 /**
  * @param string $handle
  */
 protected function require_php_library($handle)
 {
     parent::require_php_library($handle);
     if ($handle === self::LIB_MUSTACHE) {
         Mustache_Autoloader::register();
     }
 }

 public static function showFields($mb)
 {
     $adminTemplatesFolderLocation = dirname(__FILE__) . '/admin_views/';
     Mustache_Autoloader::register();
     $template = new Mustache_Engine(array('loader' => new Mustache_Loader_FilesystemLoader($adminTemplatesFolderLocation), 'partials_loader' => new Mustache_Loader_FilesystemLoader($adminTemplatesFolderLocation)));
     $fields = $mb->fields;
     foreach ($fields as $field) {
         if (empty($field['name']) || empty($field['fieldType']) || empty($field['labelTitle'])) {
             continue;
         }
         $mb->the_field($field['name']);
         if ($field['fieldType'] == 'textarea') {
             wp_editor(html_entity_decode($mb->get_the_value()), $mb->get_the_name(), array('wpautop' => true, 'media_buttons' => false, 'textarea_rows' => get_option('default_post_edit_rows', 10), 'tabindex' => '', 'editor_css' => '', 'editor_class' => '', 'teeny' => true, 'dfw' => false, 'tinymce' => false, 'quicktags' => true));
         } else {
             switch ($field['fieldType']) {
                 case 'imageUploader':
                     $fieldHtml = self::getImageUploaderHtml($mb, $template);
                     break;
                 default:
                     $fieldHtml = $template->render('text_field', array('theValue' => $mb->get_the_value(), 'theName' => $mb->get_the_name()));
             }
             echo $template->render('field_container', array('labelText' => $field['labelTitle'], 'fieldHTML' => $fieldHtml));
         }
     }
 }

 public function __construct()
 {
     $patternPrimerViewsLocation = dirname(__FILE__) . '/templates/';
     $templatesFolderLocation = ChesterBaseController::getTemplatesFolderLocation();
     Mustache_Autoloader::register();
     $this->patternPrimerTemplateLoader = new Mustache_Engine(array('loader' => new Mustache_Loader_FilesystemLoader($patternPrimerViewsLocation), 'partials_loader' => new Mustache_Loader_FilesystemLoader($patternPrimerViewsLocation)));
     $this->coreTemplateLoader = new Mustache_Engine(array('loader' => new Mustache_Loader_FilesystemLoader($templatesFolderLocation), 'partials_loader' => new Mustache_Loader_FilesystemLoader($templatesFolderLocation)));
 }

 /**
  * Renders a template using Mustache.php.
  *
  * @see View::render()
  * @param string $template The template name specified in Slim::render()
  * @return string
  */
 public function render($template)
 {
     require_once self::$mustacheDirectory . '/Autoloader.php';
     \Mustache_Autoloader::register(dirname(self::$mustacheDirectory));
     $m = new \Mustache_Engine();
     $contents = file_get_contents($this->getTemplatesDirectory() . '/' . ltrim($template, '/'));
     return $m->render($contents, $this->data);
 }

 public function __construct(View $View, $settings = array())
 {
     parent::__construct($View, $settings);
     if (class_exists('Mustache_Autoloader', false) === false) {
         App::import('Vendor', 'Mustache_Autoloader', array('file' => 'mustache' . DS . 'mustache' . DS . 'src' . DS . 'Mustache' . DS . 'Autoloader.php'));
         Mustache_Autoloader::register();
         $this->Engine = new Mustache_Engine();
     }
 }

 /**
  * Constructor.
  */
 function auth_plugin_mcae()
 {
     global $CFG;
     require_once $CFG->dirroot . '/lib/mustache/src/Mustache/Autoloader.php';
     $this->authtype = 'mcae';
     $this->config = get_config(self::COMPONENT_NAME);
     Mustache_Autoloader::register();
     $this->mustache = new Mustache_Engine();
 }

 public static function init()
 {
     if (!class_exists('Mustache_Autoloader')) {
         require dirname(__FILE__) . '/Mustache/Autoloader.php';
     }
     Mustache_Autoloader::register();
     self::$dir = dirname(__FILE__) . '/Admin/templates';
     $m_opts = array('extension' => 'html');
     self::$engine = new Mustache_Engine(array('loader' => new Mustache_Loader_FilesystemLoader(self::$dir, $m_opts), 'partials_loader' => new Mustache_Loader_FilesystemLoader(self::$dir, $m_opts), 'helpers' => array('format_date' => array(__CLASS__, 'helper_format_date'), 'edit_link' => array(__CLASS__, 'helper_edit_link'), 'permalink' => array(__CLASS__, 'helper_permalink'))));
 }

 public static function getMustacheInstance()
 {
     if (TemplateEngine::$mustacheInstance == NULL) {
         //            $requireFolder = str_replace("app", "libs/Mustache/Autoloader.php", Utils::getUtilsFolder());
         require_once 'libs/Mustache/Autoloader.php';
         Mustache_Autoloader::register();
         TemplateEngine::$mustacheInstance = new Mustache_Engine();
     }
     return TemplateEngine::$mustacheInstance;
 }

 static function render($view, $data)
 {
     global $aplication;
     global $debugbar;
     $app = $aplication->getApp();
     $path = $app->getViews();
     Mustache_Autoloader::register();
     $options = array('extension' => '.mustache');
     $template = new Mustache_Engine(array('loader' => new Mustache_Loader_FilesystemLoader($path, $options)));
     echo $template->render($view, $data);
 }

 protected function __construct()
 {
     require_once PATH_LOCAL . '/vendor/mustache/mustache/src/Mustache/Autoloader.php';
     \Mustache_Autoloader::register();
     //mustache para o trabalhar com os templates do app_default
     $this->mustache = new \Mustache_Engine($this->getEngineData(PATH_DEFAULT . '/view'));
     //mustache para trabalhar com os templates do app
     $this->mustacheapp = new \Mustache_Engine($this->getEngineData(PATH_APP . '/' . $this->templatename));
     //mustache generico ?
     $this->mm = new \Mustache_Engine();
 }

 public function __construct()
 {
     parent::__construct('pw_' . $this->widget_id_base(), sprintf('ProteusThemes: %s', $this->widget_name()), array('description' => $this->widget_description(), 'classname' => $this->widget_class()));
     // Include PHP mustache with composer
     // require_once( get_template_directory() . '/vendor/mustache/mustache/src/Mustache/Autoloader.php' );
     Mustache_Autoloader::register();
     /*
      * Set the mustache engine
      * Learn more: https://github.com/bobthecow/mustache.php/wiki/Template-Loading
      */
     $this->mustache = new Mustache_Engine(array('loader' => new Mustache_Loader_CascadingLoader(array(new Mustache_Loader_FilesystemLoader(apply_filters('pw/widget_views_path', PW_PATH . '/widgets/views')), new Mustache_Loader_FilesystemLoader(PW_PATH . '/widgets/views'), new Mustache_Loader_StringLoader()))));
 }

 /**
  * Initialize Mustache and set defaults
  */
 public function __construct()
 {
     parent::__construct();
     $this->template_extension = 'mustache';
     require_once 'lib/Mustache/Autoloader.php';
     Mustache_Autoloader::register();
     // Init template engine.
     $options = array('loader' => new Mustache_Loader_FilesystemLoader($this->template_path));
     if (is_dir($this->template_path . 'partials/')) {
         $options['partials_loader'] = new Mustache_Loader_FilesystemLoader($this->template_path . 'partials/');
     }
     $this->engine = new Mustache_Engine($options);
 }

 protected function _loadMustache()
 {
     if (!class_exists('Mustache_Autoloader')) {
         $path = 'unit-tests/engines/mustache.php/src/Mustache/Autoloader.php';
         if (file_exists($path)) {
             require $path;
             Mustache_Autoloader::register();
         } else {
             $this->markTestSkipped('Mustache engine could not be found');
             return false;
         }
     }
     return true;
 }

 public static function init()
 {
     require_once PATH . '/app/Vendor/Mustache/Autoloader.php';
     Mustache_Autoloader::register();
     $themePath = PATH . '/themes/' . Base::$g['theme'] . '/html';
     self::$mst = new Mustache_Engine(array('loader' => new Mustache_Loader_FilesystemLoader($themePath), 'partials_loader' => new Mustache_Loader_FilesystemLoader($themePath . '/partials'), 'entity_flags' => ENT_QUOTES, 'strict_callables' => true));
     self::$tpl['url'] = URL;
     self::$tpl['link'] = URL . '/themes/' . Base::$g['theme'];
     self::$tpl['notification'] = Base::getNotification();
     // Check notifications
     self::$tpl['toes'] = Page::filter('all');
     // Get footer pages
     self::$tpl['admin'] = ADMIN;
 }

 public function construct($plugin_override = '')
 {
     $configuration = $this->configuration;
     $view_dir = $this->tplBaseDir($plugin_override);
     $domain = $this->core->activePlugin();
     if (!is_object($this->template->view)) {
         require BASEPATH . 'plugins/Mustache/resources/src/Mustache/Autoloader.php';
         Mustache_Autoloader::register();
         $loader = new Mustache_Loader_FilesystemLoader($view_dir . '/views', array('extension' => $this->extension));
         $this->view = new Mustache_Engine(array('template_class_prefix' => '__view_', 'cache' => BASEPATH . $configuration['compile_path'], 'loader' => $loader, 'helpers' => array('i' => function ($text) {
             global $domain;
             return dgettext($domain, $text);
         }), 'escape' => function ($value) {
             return htmlspecialchars($value, ENT_COMPAT);
         }, 'charset' => $configuration['charset']));
     } else {
         $this->view = $this->template->view;
     }
 }