480 lines
11 KiB
PHP
480 lines
11 KiB
PHP
<?php namespace Laravel; use FilesystemIterator as fIterator; use Closure;
|
|
|
|
class Blade {
|
|
|
|
/**
|
|
* All of the compiler functions used by Blade.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected static $compilers = array(
|
|
'extensions',
|
|
'layouts',
|
|
'comments',
|
|
'echos',
|
|
'forelse',
|
|
'empty',
|
|
'endforelse',
|
|
'structure_openings',
|
|
'structure_closings',
|
|
'else',
|
|
'unless',
|
|
'endunless',
|
|
'includes',
|
|
'render_each',
|
|
'render',
|
|
'yields',
|
|
'yield_sections',
|
|
'section_start',
|
|
'section_end',
|
|
);
|
|
|
|
/**
|
|
* An array of user defined compilers.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected static $extensions = array();
|
|
|
|
/**
|
|
* Register the Blade view engine with Laravel.
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function sharpen()
|
|
{
|
|
Event::listen(View::engine, function($view)
|
|
{
|
|
// The Blade view engine should only handle the rendering of views which
|
|
// end with the Blade extension. If the given view does not, we will
|
|
// return false so the View can be rendered as normal.
|
|
if ( ! str_contains($view->path, BLADE_EXT))
|
|
{
|
|
return;
|
|
}
|
|
|
|
$compiled = Blade::compiled($view->path);
|
|
|
|
// If the view doesn't exist or has been modified since the last time it
|
|
// was compiled, we will recompile the view into pure PHP from it's
|
|
// Blade representation, writing it to cached storage.
|
|
if ( ! file_exists($compiled) or Blade::expired($view->view, $view->path))
|
|
{
|
|
file_put_contents($compiled, Blade::compile($view));
|
|
}
|
|
|
|
$view->path = $compiled;
|
|
|
|
// Once the view has been compiled, we can simply set the path to the
|
|
// compiled view on the view instance and call the typical "get"
|
|
// method on the view to evaluate the compiled PHP view.
|
|
return $view->get();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Register a custom Blade compiler.
|
|
*
|
|
* <code>
|
|
* Blade::extend(function($view)
|
|
* {
|
|
* return str_replace('foo', 'bar', $view);
|
|
* });
|
|
* </code>
|
|
*
|
|
* @param Closure $compiler
|
|
* @return void
|
|
*/
|
|
public static function extend(Closure $compiler)
|
|
{
|
|
static::$extensions[] = $compiler;
|
|
}
|
|
|
|
/**
|
|
* Determine if a view is "expired" and needs to be re-compiled.
|
|
*
|
|
* @param string $view
|
|
* @param string $path
|
|
* @param string $compiled
|
|
* @return bool
|
|
*/
|
|
public static function expired($view, $path)
|
|
{
|
|
return filemtime($path) > filemtime(static::compiled($path));
|
|
}
|
|
|
|
/**
|
|
* Compiles the specified file containing Blade pseudo-code into valid PHP.
|
|
*
|
|
* @param string $path
|
|
* @return string
|
|
*/
|
|
public static function compile($view)
|
|
{
|
|
return static::compile_string(file_get_contents($view->path), $view);
|
|
}
|
|
|
|
/**
|
|
* Compiles the given string containing Blade pseudo-code into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @param View $view
|
|
* @return string
|
|
*/
|
|
public static function compile_string($value, $view = null)
|
|
{
|
|
foreach (static::$compilers as $compiler)
|
|
{
|
|
$method = "compile_{$compiler}";
|
|
|
|
$value = static::$method($value, $view);
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade "@layout" expressions into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_layouts($value)
|
|
{
|
|
// If the Blade template is not using "layouts", we'll just return it
|
|
// unchanged since there is nothing to do with layouts and we will
|
|
// just let the other Blade compilers handle the rest.
|
|
if ( ! starts_with($value, '@layout'))
|
|
{
|
|
return $value;
|
|
}
|
|
|
|
// First we'll split out the lines of the template so we can get the
|
|
// layout from the top of the template. By convention, it must be
|
|
// located on the first line of the template contents.
|
|
preg_replace_callback(
|
|
'/^@layout(\s*?\(.+?\))(\r?\n)?/',
|
|
function($matches) use (&$value)
|
|
{
|
|
$value = substr( $value, strlen( $matches[0] ) ).CRLF.'@include'.$matches[1];
|
|
},
|
|
$value
|
|
);
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Extract a variable value out of a Blade expression.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function extract($value, $expression)
|
|
{
|
|
if ( preg_match("/@layout\s*?\(\s*?'(.+?)'\s*?\)/", $value, $matches))
|
|
{
|
|
return trim( $matches[1] );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade comments into PHP comments.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_comments($value)
|
|
{
|
|
$value = preg_replace('/\{\{--(.*?)--\}\}/', "<?php // $1 ?>", $value);
|
|
|
|
return preg_replace('/\{\{--(.*?)--\}\}/s', "<?php /* ?>$1<?php */ ?>", $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade echo statements into PHP echo statements.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_echos($value)
|
|
{
|
|
return preg_replace('/\{\{(.+?)\}\}/s', '<?php echo $1; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade "for else" statements into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_forelse($value)
|
|
{
|
|
preg_match_all('/@forelse\s*?\(\s*?\$(.+?)\s*?as\s*?\$(.+?)\s*?\)/', $value, $matches, PREG_SET_ORDER );
|
|
|
|
if ( count($matches) < 1 ) return $value;
|
|
|
|
foreach ($matches as $forelse)
|
|
{
|
|
// Once we have extracted the variable being looped against, we can add
|
|
// an if statement to the start of the loop that checks if the count
|
|
// of the variable being looped against is greater than zero.
|
|
$replace = '<?php if (count($'.$forelse[1].') > 0): foreach ($'.$forelse[1].' as $'.$forelse[2].'): ?>';
|
|
|
|
// Finally, once we have the check prepended to the loop we'll replace
|
|
// all instances of this forelse syntax in the view content of the
|
|
// view being compiled to Blade syntax with real PHP syntax.
|
|
$value = str_replace($forelse[0], $replace, $value);
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade "empty" statements into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_empty($value)
|
|
{
|
|
return str_replace('@empty', '<?php endforeach; else: ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade "forelse" endings into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_endforelse($value)
|
|
{
|
|
return str_replace('@endforelse', '<?php endif; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade structure openings into PHP structure openings.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_structure_openings($value)
|
|
{
|
|
preg_replace_callback(
|
|
'/@(if|elseif|foreach|for|while)(\s*?)(\([^\n\r\t]+\))/',
|
|
function($matches) use (&$value)
|
|
{
|
|
if(count( $matches ) === 4)
|
|
{
|
|
$open = 0;
|
|
$close = 0;
|
|
$cut = 0;
|
|
$len = strlen($matches[3]);
|
|
for($i = 0; $i < $len; $i++)
|
|
{
|
|
if($matches[3][$i] === '(' )
|
|
{
|
|
$open++;
|
|
}
|
|
if($matches[3][$i] === ')' )
|
|
{
|
|
$close++;
|
|
}
|
|
if($open !== 0 && ($open === $close))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
$condition = substr($matches[3], 0, ($i + 1));
|
|
$value = str_replace(
|
|
'@'.$matches[1].$matches[2].$condition,
|
|
'<?php '.$matches[1].$condition.': ?>',
|
|
$value
|
|
);
|
|
}
|
|
},
|
|
$value
|
|
);
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade structure closings into PHP structure closings.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_structure_closings($value)
|
|
{
|
|
$pattern = '/@(endif|endforeach|endfor|endwhile|break|continue)/';
|
|
|
|
return preg_replace($pattern, '<?php $1; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade else statements into PHP else statements.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_else($value)
|
|
{
|
|
return str_replace( '@else', '<?php else: ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade "unless" statements into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_unless($value)
|
|
{
|
|
$pattern = static::matcher('unless');
|
|
|
|
return preg_replace($pattern, '<?php if( ! ($1)): ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade "unless" endings into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_endunless($value)
|
|
{
|
|
return str_replace('@endunless', '<?php endif; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade @include statements into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_includes($value)
|
|
{
|
|
$pattern = static::matcher('include');
|
|
|
|
return preg_replace($pattern, '<?php echo view$1->with(get_defined_vars())->render(); ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade @render statements into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_render($value)
|
|
{
|
|
$pattern = static::matcher('render');
|
|
|
|
return preg_replace($pattern, '<?php echo render$1; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade @render_each statements into valid PHP.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_render_each($value)
|
|
{
|
|
$pattern = static::matcher('render_each');
|
|
|
|
return preg_replace($pattern, '<?php echo render_each$1; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade @yield statements into Section statements.
|
|
*
|
|
* The Blade @yield statement is a shortcut to the Section::yield method.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_yields($value)
|
|
{
|
|
$pattern = static::matcher('yield');
|
|
|
|
return preg_replace($pattern, '<?php echo \\Laravel\\Section::yield$1; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade yield section statements into valid PHP.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected static function compile_yield_sections($value)
|
|
{
|
|
return str_replace('@yield_section', '<?php echo \\Laravel\\Section::yield_section(); ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade @section statements into Section statements.
|
|
*
|
|
* The Blade @section statement is a shortcut to the Section::start method.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_section_start($value)
|
|
{
|
|
$pattern = static::matcher('section');
|
|
|
|
return preg_replace($pattern, '<?php \\Laravel\\Section::start$1; ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Rewrites Blade @endsection statements into Section statements.
|
|
*
|
|
* The Blade @endsection statement is a shortcut to the Section::stop method.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_section_end($value)
|
|
{
|
|
return str_replace('@endsection', '<?php \\Laravel\\Section::stop(); ?>', $value);
|
|
}
|
|
|
|
/**
|
|
* Execute user defined compilers.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected static function compile_extensions($value)
|
|
{
|
|
foreach (static::$extensions as $compiler)
|
|
{
|
|
$value = $compiler($value);
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Get the regular expression for a generic Blade function.
|
|
*
|
|
* @param string $function
|
|
* @return string
|
|
*/
|
|
public static function matcher($function)
|
|
{
|
|
return '/@'.$function.'\s*?(\(.+?\))/';
|
|
}
|
|
|
|
/**
|
|
* Get the fully qualified path for a compiled view.
|
|
*
|
|
* @param string $view
|
|
* @return string
|
|
*/
|
|
public static function compiled($path)
|
|
{
|
|
return path('storage').'views/'.md5($path);
|
|
}
|
|
|
|
}
|