createTemplate example

        $parentId = Shopware()->Shop()->getCategory()->getId();
        $categories = $this->modelManager->getRepository(Category::class)
            ->getActiveChildrenList($parentId);

        if (isset($offset, $limit)) {
            $categories = \array_slice($categories, $offset, $limit);
        }

        $template = 'string:' . $routerCategoryTemplate;
        $template = $this->template->createTemplate($template, $this->data);

        foreach ($categories as $category) {
            if (!empty($category['external'])) {
                continue;
            }

            $template->assign('sCategory', $category);
            $path = $template->fetch();
            $path = $this->sCleanupPath($path);

            if ($category['blog']) {
                

    }

    /** * @dataProvider templateProfileProvider */
    public function testCreateTemplateFromProfileMapping($profile): void
    {
        if ($profile === null) {
            $profileId = Uuid::randomHex();
            self::expectExceptionObject(new EntityNotFoundException('import_export_profile', $profileId));
            $this->mappingService->createTemplate(Context::createDefaultContext(), $profileId);
        }

        $this->profileRepository->create([$profile], Context::createDefaultContext());

        if (empty($profile['mapping'])) {
            static::expectException(\RuntimeException::class);
        }

        $fileId = $this->mappingService->createTemplate(Context::createDefaultContext(), $profile['id']);

        if (empty($profile['mapping'])) {
            

$_file = $_fileinfo->getFilename();
                if (!substr_compare($_file, $extention, - strlen($extention)) == 0) continue;
                if ($_fileinfo->getPath() == substr($_dir, 0, -1)) {
                   $_template_file = $_file;
                } else {
                   $_template_file = substr($_fileinfo->getPath(), strlen($_dir)) . DS . $_file;
                }
                echo '<br>', $_dir, '---', $_template_file;
                flush();
                $_start_time = microtime(true);
                try {
                    $_tpl = $smarty->createTemplate($_template_file,null,null,null,false);
                    if ($_tpl->mustCompile()) {
                        $_tpl->compileTemplateSource();
                        $_count++;
                        echo ' compiled in ', microtime(true) - $_start_time, ' seconds';
                        flush();
                    } else {
                        echo ' is up to date';
                        flush();
                    }
                }
                catch (Exception $e) {
                    

$name = basename($file);

    try {
      $this->twig->load($name);
    }
    catch (Error $error) {
      $this->assertEquals($line, $error->getTemplateLine());
    }

    // Ensure string based templates work too.     try {
      $this->twig->createTemplate($source)->render();
    }
    catch (Error $error) {
      $this->assertEquals($line, $error->getTemplateLine());
    }
  }

}

/** * Loads a template from a string. * * {{ include(template_from_string("Hello {{ name }}")) }} * * @param string $template A template as a string or object implementing __toString() * @param string $name An optional name of the template to be used in error messages */
function twig_template_from_string(Environment $env, $template, string $name = null): TemplateWrapper
{
    return $env->createTemplate((string) $template, $name);
}
}

    public function compileSmartyString($value, $context)
    {
        $templateEngine = $this->getView();

        try {
            $template = $templateEngine->createTemplate('string:' . $value);
            $template->assign($context);
            $template = $template->fetch();
        } catch (SmartyCompilerException $e) {
            $errorMessage = $e->getMessage();

            if (stripos($errorMessage, 'Syntax Error in template') === 0) {
                // Strip away filepath which is a md5sum                 $errorMessage = sprintf('Syntax Error %s', substr($errorMessage, 69));
            }

            throw new \Enlight_Exception($errorMessage, 0, $e);
        }

$voucherDetails['value'] *= $factor;
        }

        $basketValue = ($amount['totalAmount'] ?? 0) / $factor;
        // Check if the basket's value is above the voucher's         if ($basketValue < $voucherDetails['minimumcharge']) {
            $snippet = $this->snippetManager->getNamespace('frontend/basket/internalMessages')->get(
                'VoucherFailureMinimumCharge',
                'The minimum charge for this voucher is {$sMinimumCharge|currency}'
            );
            $smarty = Shopware()->Container()->get(\Enlight_Template_Manager::class);
            $template = $smarty->createTemplate(sprintf('string:%s', $snippet));
            $template->assign('sMinimumCharge', $voucherDetails['minimumcharge']);

            $sErrorMessages[] = $template->fetch();

            return ['sErrorFlag' => true, 'sErrorMessages' => $sErrorMessages];
        }

        $timeInsert = date('Y-m-d H:i:s');

        $voucherName = $this->snippetManager
            ->getNamespace('backend/static/discounts_surcharges')
            

    #[Route(path: '/api/_action/import-export/prepare-template-file-download', name: 'api.action.import_export.template_file.prepare_download', methods: ['POST'])]     public function prepareTemplateFileDownload(Request $request, Context $context): Response
    {
        $profileId = $request->query->get('profileId');
        if (!\is_string($profileId)) {
            throw RoutingException::invalidRequestParameter('profileId');
        }
        $profileId = strtolower($profileId);

        $fileId = $this->mappingService->createTemplate($context, $profileId);
        $token = $this->downloadService->regenerateToken($context, $fileId);

        return new JsonResponse([
            'fileId' => $fileId,
            'accessToken' => $token,
        ]);
    }

    #[Route(path: '/api/_action/import-export/mapping-from-template', name: 'api.action.import_export.template_file.mapping', methods: ['POST'])]     public function mappingFromTemplate(Request $request, Context $context): JsonResponse
    {
        

    /** * Loads a template by name over the Enlight_Template_Manager. * * @param string $template_name * * @return Enlight_View_Default */
    public function loadTemplate($template_name)
    {
        $this->template = $this->engine->createTemplate($template_name, null, null, $this->engine, false);

        return $this;
    }

    /** * Creates a new template by name over the Enlight_Template_Manager. * * @param string $template_name * * @return Enlight_Template_Default */
    

  public function renderInline($template_string, array $context = []) {
    // Prefix all inline templates with a special comment.     $template_string = '{# inline_template_start #}' . $template_string;
    return Markup::create($this->createTemplate($template_string)->render($context));
  }

}

/** * Tests the twig calls to the Attribute. * @dataProvider providerTestAttributeClassHelpers * * @covers ::removeClass * @covers ::addClass */
  public function testTwigAddRemoveClasses($template, $expected, $seed_attributes = []) {
    $loader = new StringLoader();
    $twig = new Environment($loader);
    $data = ['attributes' => new Attribute($seed_attributes)];
    $result = $twig->createTemplate($template)->render($data);
    $this->assertEquals($expected, $result);
  }

  /** * Provides tests data for testEscaping. * * @return array * An array of test data each containing of a twig template string, * a resulting string of classes and an optional array of attributes. */
  public function providerTestAttributeClassHelpers() {
    

        if (!empty($cache_id) && is_object($cache_id)) {
            $parent = $cache_id;
            $cache_id = null;
        }
        if ($parent === null && ($this instanceof Smarty || is_string($template))) {
            $parent = $this;
        }
        // create template object if necessary         $_template = ($template instanceof $this->template_class)
        ? $template
        : $this->smarty->createTemplate($template, $cache_id, $compile_id, $parent, false);
        // if called by Smarty object make sure we use current caching status         if ($this instanceof Smarty) {
            $_template->caching = $this->caching;
        }
        // merge all variable scopes into template         if ($merge_tpl_vars) {
            // save local variables             $save_tpl_vars = $_template->tpl_vars;
            $save_config_vars = $_template->config_vars;
            $ptr_array = array($_template);
            $ptr = $_template;
            

    public function testLoadAdditionalExtension(): void
    {
        // extension loaded via custom tag in src/Core/Framework/DependencyInjection/seo_test.xml         static::assertIsObject($this->environment->getExtension(LastLetterBigTwigFilter::class));

        $template = '{% autoescape \''
            . SeoUrlGenerator::ESCAPE_SLUGIFY
            . '\' %}{{ product.name|lastBigLetter }}{% endautoescape %}';

        $twig = $this->environment->createTemplate($template);
        $rendered = $twig->render(['product' => ['name' => 'hello world']]);

        static::assertSame('hello-worlD', $rendered);
    }
}