public function __construct()
{
$this->instance('container', $this);
$this->singleton('events', function () {
return new Dispatcher();
});
$this->singleton('files', function () {
return new Filesystem();
});
$this->singleton('blade.compiler', function () {
return new BladeCompiler($this['files'], $this['view.compiled']);
});
$this->singleton('view.engine.resolver', function () {
$resolver = new EngineResolver();
$resolver->register('blade', function () {
return new CompilerEngine($this['blade.compiler'], $this['files']);
});
$resolver->register('php', function () {
return new PhpEngine();
});
return $resolver;
});
$this->singleton('view.finder', function () {
return new FileViewFinder($this['files'], $this['view.paths']);
});
$this->singleton('view', function () {
$env = new Factory($this['view.engine.resolver'], $this['view.finder'], $this['events']);
$env->setContainer($this['container']);
return $env;
});
}
/**
* Register the engine resolver instance.
*
* @return EngineResolver
*/
public function getEngineResolver()
{
$resolver = new EngineResolver();
// Add PhpEngine
$resolver->register('php', function () {
return new PhpEngine();
});
// Add Blade compiler engine
$resolver->register('blade', function () {
$compiler = new BladeCompiler($this->files, $this->cachePath);
return new CompilerEngine($compiler);
});
return $resolver;
}
/**
* Template constructor.
*
* @param Container $container
*/
public function __construct(Container $container)
{
$settings = $container->get('settings');
$compiledPath = $settings['storagePath'] . DIRECTORY_SEPARATOR . 'views';
$resolver = new EngineResolver();
$resolver->register('blade', function () use($compiledPath, &$settings) {
$bladeCompiler = new BladeCompiler(new Filesystem(), $compiledPath);
// Add the @webroot directive.
$bladeCompiler->directive('webroot', function ($expression) use(&$settings) {
$segments = explode(',', preg_replace("/[\\(\\)\\\"\\']/", '', $expression));
$path = rtrim($settings['webrootBasePath'], '/') . '/' . ltrim($segments[0], '/');
$path = str_replace("'", "\\'", $path);
return "<?= e('{$path}') ?>";
});
// Add the @route directive.
$bladeCompiler->directive('route', function ($expression) use(&$settings) {
$segments = explode(',', preg_replace("/[\\(\\)\\\"\\']/", '', $expression));
$path = rtrim($settings['routeBasePath'], '/') . '/' . ltrim($segments[0], '/');
$path = str_replace("'", "\\'", $path);
return "<?= e('{$path}') ?>";
});
return new CompilerEngine($bladeCompiler);
});
$finder = new FileViewFinder(new Filesystem(), [$settings['templatePath']]);
$factory = new ViewFactory($resolver, $finder, new Dispatcher());
$this->factory = $factory;
$this->container = $container;
}
/**
* Register a valid Markdown extension and its engine.
*
* @param string $extension
* @param string $engine
* @param Closure $resolver
* @return void
*/
public function addExtension($extension, $engine, $resolver = null)
{
$this->finder->addExtension($extension);
if (isset($resolver)) {
$this->engines->register($engine, $resolver);
}
$this->extensions[$extension] = $engine;
}
/**
* Register a valid view extension and its engine.
*
* @param string $extension
* @param string $engine
* @param \Closure $resolver
* @return void
*/
public function addExtension($extension, $engine, $resolver = null)
{
$this->finder->addExtension($extension);
if (isset($resolver)) {
$this->engines->register($engine, $resolver);
}
unset($this->extensions[$extension]);
$this->extensions = array_merge([$extension => $engine], $this->extensions);
}
/**
* Register the Twig engine to the EngineResolver.
*
* @param string $engine
* @param EngineResolver $resolver
*/
protected function registerTwigEngine($engine, EngineResolver $resolver)
{
$container = $this->app;
$resolver->register($engine, function () use($container) {
// Set the loader main namespace (paths).
$container['twig.loader']->setPaths($container['view.finder']->getPaths());
return new TwigEngine($container['twig'], $container['view.finder']);
});
}
/**
* Method to get property Resolver
*
* @return EngineResolver
*/
public function getResolver()
{
if (!$this->resolver) {
$self = $this;
$this->resolver = new EngineResolver();
$this->resolver->register('blade', function () use($self) {
return $self->getCompiler();
});
}
return $this->resolver;
}
/**
* Constructor.
*
* @param Factory $renderer Rendering engine
*
* @since __DEPLOY_VERSION__
*/
public function __construct(Factory $renderer = null)
{
if (!$renderer) {
$filesystem = new Filesystem();
$resolver = new EngineResolver();
$resolver->register('blade', function () use($filesystem) {
return new CompilerEngine(new BladeCompiler($filesystem, getcwd() . '/cache'));
});
$renderer = new Factory($resolver, new FileViewFinder($filesystem, []), new Dispatcher());
}
$this->renderer = $renderer;
}
/**
* Register the Jade engine implementation.
*
* @param \Illuminate\View\Engines\EngineResolver $resolver
*/
public function registerJadeEngine(EngineResolver $resolver)
{
$app = $this->app;
$app->singleton('jade.compiler', function ($app) {
$cache = $app['config']['view.compiled'];
return new JadeCompiler($app['files'], $cache);
});
$resolver->register('jade', function () use($app) {
return new CompilerEngine($app['jade.compiler'], $app['files']);
});
$app['view']->addExtension('jade.php', 'jade');
}
public function __construct($viewsDir, $cacheDir)
{
$filesystem = new Filesystem();
$engineResolver = new EngineResolver();
$engineResolver->register('blade', function () use($filesystem, $cacheDir) {
return new CompilerEngine(new BladeCompiler($filesystem, $cacheDir));
});
$factory = new Factory($engineResolver, new FileViewFinder($filesystem, [$viewsDir]), new Dispatcher());
$this->factory = $factory;
$this->viewsDir = $viewsDir;
$this->filesystem = $filesystem;
}
/**
* Register the Blade engine implementation.
*
* @param \Illuminate\View\Engines\EngineResolver $resolver
* @return void
*/
public function registerBladeEngine($resolver)
{
$app = $this->app;
$resolver->register('blade', function () use($app) {
$cache = $app['path.storage'] . '/views';
// The Compiler engine requires an instance of the CompilerInterface, which in
// this case will be the Blade compiler, so we'll first create the compiler
// instance to pass into the engine so it can compile the views properly.
$compiler = new BladeCompiler($app['files'], $cache);
return new CompilerEngine($compiler, $app['files']);
});
}
/**
* Register the Markdown engine implementation.
*
* @param EngineResolver $resolver
* @return void
*/
public function registerMarkdownEngine($resolver)
{
$app = $this->app;
$resolver->register('markdown', function () use($app) {
$cache = storage_path() . '/markdown';
if (!File::isDirectory($cache)) {
File::makeDirectory($cache);
}
$compiler = new MarkdownCompiler($app['files'], $cache);
$compiler->setOptions(Config::get('markdown.options'));
return new CompilerEngine($compiler, $app['files']);
});
}
/**
* Register the application services.
*
* @return void
*/
public function register()
{
$this->app->bind('minit', function () {
return new \Minit\Engine();
});
$this->app->singleton('view.engine.resolver', function () {
$resolver = new EngineResolver();
$resolver->register('php', function () {
return new \Minit\Engine();
});
return $resolver;
});
}
/**
* Create a new Blade Factory instance
*
* @param array $view_paths
* @param mixed $view_cache_path
*/
public function __construct(array $view_paths, $view_cache_path = null)
{
$resolver = new EngineResolver();
$finder = new FileViewFinder(new Filesystem(), $view_paths);
$dispatcher = new Dispatcher();
$resolver->register("blade", function () use($view_cache_path) {
if (!is_dir($view_cache_path)) {
mkdir($view_cache_path, 0777, true);
}
$blade = new BladeCompiler(new Filesystem(), $view_cache_path);
return new CompilerEngine($blade);
});
parent::__construct($resolver, $finder, $dispatcher);
}
/**
* Register the Blade engine implementation.
*
* @param \Illuminate\View\Engines\EngineResolver $resolver
* @return void
*/
public function registerBladeEngine($resolver)
{
$app = $this->app;
// The Compiler engine requires an instance of the CompilerInterface, which in
// this case will be the Blade compiler, so we'll first create the compiler
// instance to pass into the engine so it can compile the views properly.
$app->singleton('blade.compiler', function ($app) {
$cache = $app['config']['view.compiled'];
return new BladeCompiler($app['files'], $cache);
});
$resolver->register('blade', function () use($app) {
return new CompilerEngine($app['blade.compiler']);
});
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param Container $pimple A container instance
*/
public function register()
{
/*
* application default view
*
* @param $c container
* @return Factory view Factory
*/
$this->app['view'] = function ($c) {
$viewResolver = new EngineResolver();
$compiler = new BladeCompiler($c['filesystem'], $this->app->basePath() . '/storage/view');
$filesystem = $c['filesystem'];
$viewResolver->register('blade', function () use($compiler, $filesystem) {
return new CompilerEngine($compiler, $filesystem);
});
$viewResolver->register('php', function () {
return new PhpEngine();
});
$viewFinder = new FileViewFinder($filesystem, [$this->app->path . '/View']);
$viewFactory = new Factory($viewResolver, $viewFinder, new Dispatcher());
return $viewFactory;
};
}
/**
* @param Container $app
*/
public function register(Container $app)
{
// we only need to do this if Blade views are enabled.
if ($app['config']['view.blade.enabled']) {
$app['blade.settings'] = $app['config']['view.blade.defaults'];
$app['blade.template.paths'] = $app['blade.settings']['template_paths'];
$app['files'] = function () {
return new Filesystem();
};
$app['view.finder'] = function ($app) {
return new FileViewFinder(new Filesystem(), $app['blade.template.paths']);
};
// create the Blade compiler using Filesystem and cache directory
$app['blade.compiler'] = function ($app) {
return new BladeCompiler(new Filesystem(), $app['blade.settings']['cache']);
};
// get a blade compiler engine instance
$app['blade.engine'] = function ($app) {
return new CompilerEngine($app['blade.compiler']);
};
$app['view.engine.resolver'] = function ($app) {
$resolver = new EngineResolver();
$resolver->register('php', function () {
return new PhpEngine();
});
$resolver->register('blade', function () use($app) {
return new CompilerEngine($app['blade.compiler'], $app['files']);
});
return $resolver;
};
$app['blade.factory'] = function ($app) {
$view_factory = new IlluminateViewFactory($app['view.engine.resolver'], $app['view.finder'], $app['illuminate.events']);
$view_factory->setContainer($app['nine.container']);
return $view_factory;
};
}
}
protected function makeView()
{
$app = new Container();
$resolver = new EngineResolver();
$resolver->register('php', function () {
return new PhpEngine();
});
$finder = new FileViewFinder(new Filesystem(), [realpath(__DIR__)]);
$dispatcher = (new Dispatcher($app))->setQueueResolver(function () use($app) {
return $app->make('Illuminate\\Contracts\\Queue\\Factory');
});
$env = new Factory($resolver, $finder, $dispatcher);
$env->setContainer($app);
$env->share('app', $app);
return new Illuminate($env);
}
/**
* Register the mustache engine implementation.
*
* @param \Illuminate\View\Engines\EngineResolver $resolver
* @return void
*/
public function registerHandlebarsEngine($resolver)
{
$app = $this->app;
// The Compiler engine requires an instance of the CompilerInterface, which in
// this case will be the Handlebars compiler, so we'll first create the compiler
// instance to pass into the engine so it can compile the views properly.
$app->singleton('handlebars.lightncandy', function ($app) {
return new LightnCandy();
});
$app->singleton('handlebars.compiler', function ($app) {
$cache = $app['config']['view.compiled'];
return new HandlebarsCompiler($app['files'], $app['handlebars.lightncandy'], $cache);
});
$resolver->register('handlebars', function () use($app) {
return new HandlebarsEngine($app['handlebars.compiler']);
});
}
/**
* Get the laravel view factory.
*
* @return Factory
*/
protected function getViewFactory()
{
if ($this->factory) {
return $this->factory;
}
$resolver = new EngineResolver();
$resolver->register("blade", function () {
if (!is_dir($this->cache)) {
mkdir($this->cache, 0777, true);
}
$blade = new BladeCompiler(new Filesystem(), $this->cache);
Blade::registerDirectives($blade);
return new CompilerEngine($blade);
});
$this->factory = new Factory($resolver, $this->getViewFinder(), new Dispatcher());
return $this->factory;
}
/**
* Create the view factory with a Blade Compiler.
*
* @return Factory
*/
private function createViewFactory()
{
$resolver = new EngineResolver();
$bladeCompiler = $this->createBladeCompiler();
$resolver->register('blade', function () use($bladeCompiler) {
return new CompilerEngine($bladeCompiler);
});
$dispatcher = new Dispatcher();
$dispatcher->listen('creating: *', function () {
/**
* On rendering Blade views we will mute error reporting as
* we don't care about undefined variables or type
* mistakes during compilation.
*/
error_reporting(error_reporting() & ~E_NOTICE & ~E_WARNING);
});
return new Factory($resolver, new FileViewFinder($this->filesystem, [KATANA_CONTENT_DIR]), $dispatcher);
}
/**
* Register the Blade engine implementation.
*
* @param \Illuminate\View\Engines\EngineResolver $resolver
* @return void
*/
public function registerBladeEngine(EngineResolver $resolver)
{
$container = $this->getContainer();
$container->bindShared('blade.compiler', function () {
return new BladeCompiler($this->getFilesystem(), $this->getStoragePath());
});
$resolver->register('blade', function () use($container) {
return new CompilerEngine($container['blade.compiler'], $this->getFilesystem());
});
}
$transport = SmtpTransport::newInstance(getenv('SMTP_HOST'), getenv('SMTP_PORT'));
// $transport = MailTransport::newInstance();
// $transport = SendmailTransport::newInstance('/usr/sbin/sendmail -bs');
// $transport = new MailgunTransport(getenv('MAILGUN_SECRET'), getenv('MAILGUN_DOMAIN'));
// $transport = new MandrillTransport(getenv('MANDRILL_SECRET'));
// $transport = new LogTransport($logger->getMonolog());
// SMTP specific configuration, remove these if you're not using SMTP
$transport->setUsername(getenv('SMTP_USERNAME'));
$transport->setPassword(getenv('SMTP_PASSWORD'));
$transport->setEncryption(true);
$swift = new SwiftMailer($transport);
$finder = new FileViewFinder(new Filesystem(), ['views']);
$resolver = new EngineResolver();
// determine which template engine to use
$resolver->register('php', function () {
return new PhpEngine();
});
$view = new Factory($resolver, $finder, new Dispatcher());
$mailer = new Mailer($view, $swift);
$mailer->setLogger($logger);
// $mailer->setQueue($app['queue']); // note: queue functionality is not available if the queue module is not set
// $mailer->setContainer($app); // note: the message builder must be a callback if the container is not set
// pretend method can be used for testing
$mailer->pretend(false);
// prepare email view data
$data = ['greeting' => 'You have arrived, girl.'];
$mailer->send('email.welcome', $data, function ($message) {
$message->from(getenv('MAIL_FROM_ADDRESS'), 'Code Guy');
$message->to(getenv('MAIL_TO_ADDRESS'), 'Keira Knightley');
$message->subject('Yo!');
});
/**
* Register the Blade engine implementation.
*
* @param EngineResolver $resolver
*
* @return void
*/
public function registerBladeEngine($resolver)
{
$me = $this;
$app = $this->container;
$this->container->singleton('blade.compiler', function ($app) use($me) {
$cache = $me->cachePath;
return new BladeCompiler($app['files'], $cache);
});
$resolver->register('blade', function () use($app) {
return new CompilerEngine($app['blade.compiler'], $app['files']);
});
}
/**
* Register the engine resolver instance.
*
* @return void
*/
private function register_engine_resolver()
{
$this->forge->add('view.engine.resolver', function () {
$resolver = new EngineResolver();
$resolver->register('php', function () {
return new PhpEngine();
});
$resolver->register('blade', function () {
/** @noinspection PhpParamsInspection - Quieten PhpStorm type complaint */
return new CompilerEngine($this->forge['blade.compiler'], $this->forge['files']);
});
return $resolver;
});
}
/**
* Method: setDefaults
* =========================================================================
* This is where we set all our defaults. If you need to customise this
* container this is a good place to look to see what can be configured
* and how to configure it.
*
* Parameters:
* -------------------------------------------------------------------------
* n/a
*
* Returns:
* -------------------------------------------------------------------------
* void
*/
protected function setDefaults()
{
$this->cachePath = '/tmp/gears-views-cache';
$this->filesystem = function () {
return new Filesystem();
};
$this->dispatcher = function () {
return new Dispatcher();
};
$this->fileViewFinder = function () {
return new FileViewFinder($this->filesystem, $this->viewsPath);
};
$this->bladeCompiler = function () {
return new BladeCompiler($this->filesystem, $this->cachePath);
};
$this->phpEngine = $this->protect(function () {
return new PhpEngine();
});
$this->bladeEngine = $this->protect(function () {
return new CompilerEngine($this->bladeCompiler, $this->filesystem);
});
$this->engineResolver = function () {
$resolver = new EngineResolver();
$resolver->register('php', $this->phpEngine);
$resolver->register('blade', $this->bladeEngine);
return $resolver;
};
$this->factory = function () {
return new Factory($this->engineResolver, $this->fileViewFinder, $this->dispatcher);
};
}
public function configView()
{
$engineResolver = new EngineResolver();
$engineResolver->register('php', function () {
return new PhpEngine();
});
$this->app->singleton('blade.compiler', function ($app) {
$cachePath = $this->basePath . "/storage/framework/views";
return new BladeCompiler(new Filesystem(), $cachePath);
});
$engineResolver->register('blade', function () {
return new CompilerEngine($this->app['blade.compiler']);
});
$fileViewFinder = new FileViewFinder(new Filesystem(), [], null);
$this->viewFactory = new Factory($engineResolver, $fileViewFinder, new Dispatcher());
$fileViewFinder->addLocation($this->basePath . "/resources/views");
}
/**
* Register the Blade engine implementation.
*
* @param \Illuminate\View\Engines\EngineResolver $resolver Engine Resolver
*
* @return void
*/
protected function registerBladeEngine(EngineResolver $resolver)
{
$container = $this->container;
// The Compiler engine requires an instance of the CompilerInterface, which in
// this case will be the Blade compiler, so we'll first create the compiler
// instance to pass into the engine so it can compile the views properly.
$container->singleton('blade.compiler', function ($container) {
return new BladeCompiler($container['files'], $container['cache.path']);
});
$resolver->register('blade', function () use($container) {
return new CompilerEngine($container['blade.compiler'], $container['files']);
});
}
/**
* Register the Blade engine implementation.
*
* @param \Illuminate\View\Engines\EngineResolver $resolver
* @return void
*/
public function registerBladeEngine($resolver)
{
$me = $this;
$app = $this->container;
// The Compiler engine requires an instance of the CompilerInterface, which in
// this case will be the Blade compiler, so we'll first create the compiler
// instance to pass into the engine so it can compile the views properly.
$this->container->bindShared('blade.compiler', function ($app) use($me) {
$cache = $me->cachePath;
return new BladeCompiler($app['files'], $cache);
});
$resolver->register('blade', function () use($app) {
return new CompilerEngine($app['blade.compiler'], $app['files']);
});
}
public static function blade(array $data, $debug = true)
{
$resolver = new EngineResolver();
$files = new Filesystem();
$compiler = new BladeCompiler($files, static::$cacheDirectory);
$engine = new CompilerEngine($compiler);
$resolver->register('blade', function () use($engine) {
return $engine;
});
/** @var Restler $restler */
$restler = Scope::get('Restler');
//Lets expose shortcuts for our classes
spl_autoload_register(function ($className) use($restler) {
if (isset($restler->apiMethodInfo->metadata['scope'][$className])) {
return class_alias($restler->apiMethodInfo->metadata['scope'][$className], $className);
}
if (isset(Scope::$classAliases[$className])) {
return class_alias(Scope::$classAliases[$className], $className);
}
return false;
}, true, true);
$viewFinder = new FileViewFinder($files, array(static::$viewPath));
$factory = new Factory($resolver, $viewFinder, new Dispatcher());
$path = $viewFinder->find(self::$view);
$view = new View($factory, $engine, self::$view, $path, $data);
$factory->callCreator($view);
return $view->render();
}