/** * Create and return a CommonMark environment * * @return Environment CommonMark environment */ protected function environment() { // Obtain a pre-configured Environment with all the CommonMark parsers/renderers ready-to-go $environment = Environment::createCommonMarkEnvironment(); // Custom environment initialization return $this->initializeEnvironment($environment); }
/** * @param string $markdown * @param string $expected * @dataProvider e2eProvider */ public function testFullRender($markdown, $expected) { $factory = new CliRendererFactory(); $renderer = $factory->__invoke(); $parser = new DocParser(Environment::createCommonMarkEnvironment()); $this->assertEquals($expected, $renderer->renderBlock($parser->parse($markdown))); }
public function testExerciseRendererSetsCurrentExerciseAndRendersExercise() { $menu = $this->getMockBuilder(CliMenu::class)->disableOriginalConstructor()->getMock(); $item = $this->getMock(MenuItemInterface::class); $item->expects($this->any())->method('getText')->will($this->returnValue('Exercise 2')); $menu->expects($this->once())->method('getSelectedItem')->will($this->returnValue($item)); $menu->expects($this->once())->method('close'); $exercise1 = $this->getMock(ExerciseInterface::class); $exercise2 = $this->getMock(ExerciseInterface::class); $exercises = [$exercise1, $exercise2]; $exerciseRepository = $this->getMockBuilder(ExerciseRepository::class)->disableOriginalConstructor()->getMock(); $userState = $this->getMock(UserState::class); $userStateSerializer = $this->getMockBuilder(UserStateSerializer::class)->disableOriginalConstructor()->getMock(); $exerciseRepository->expects($this->once())->method('findByName')->with('Exercise 2')->will($this->returnValue($exercise2)); $exerciseRepository->expects($this->once())->method('findAll')->will($this->returnValue($exercises)); $userState->expects($this->once())->method('setCurrentExercise')->with('Exercise 2'); $userStateSerializer->expects($this->once())->method('serialize')->with($userState); $problemFile = sprintf('%s/%s/problem.md', sys_get_temp_dir(), $this->getName()); $exercise2->expects($this->once())->method('getProblem')->will($this->returnValue($problemFile)); if (!is_dir(dirname($problemFile))) { mkdir(dirname($problemFile), 0775, true); } file_put_contents($problemFile, '### Exercise Content'); $markdownRenderer = new MarkdownRenderer(new DocParser(Environment::createCommonMarkEnvironment()), (new CliRendererFactory())->__invoke()); $color = new Color(); $color->setForceStyle(true); $exerciseRenderer = new ExerciseRenderer('phpschool', $exerciseRepository, $userState, $userStateSerializer, $markdownRenderer, $color, new StdOutput($color, $this->getMock(TerminalInterface::class))); $this->expectOutputString(file_get_contents(__DIR__ . '/res/exercise-help-expected.txt')); $exerciseRenderer->__invoke($menu); unlink($problemFile); }
public function setCommonMarkEnvironment(Environment $environment = null) { if (is_null($environment)) { $environment = Environment::createCommonMarkEnvironment(); } $this->_cmEnvironment = $environment; }
public function setUp() { $environment = Environment::createCommonMarkEnvironment(); $environment->addInlineParser(new MentionParser()); $parser = new DocParser($environment); $renderer = new HtmlRenderer($environment); $this->service = new CommonMarkParser($environment, $parser, $renderer); }
/** * Convert body to html */ public function markdown($description) { $environment = Environment::createCommonMarkEnvironment(); $parser = new DocParser($environment); $htmlRenderer = new HtmlRenderer($environment); $markdown = $this->description; $documentAST = $parser->parse($markdown); return $htmlRenderer->renderBlock($documentAST); }
public function testRender() { $docParser = new DocParser(Environment::createCommonMarkEnvironment()); $cliRenderer = (new CliRendererFactory())->__invoke(); $renderer = new MarkdownRenderer($docParser, $cliRenderer); $markdown = "### HONEY BADGER DON'T CARE"; $expected = "\n[90m###[0m [36m[1mHONEY BADGER DON'T CARE[0m[0m\n\n"; $this->assertSame($expected, $renderer->render($markdown)); }
public function getArticle($uri) { $environment = Environment::createCommonMarkEnvironment(); $environment->addExtension(new TableExtension()); $converter = new Converter(new DocParser($environment), new HtmlRenderer($environment)); $contents = \Storage::get($uri . '.md'); preg_match('/^.*$/m', $contents, $matches); return view('portal', array('body' => $converter->convertToHtml($contents), 'title' => substr($matches[0], 2))); }
private function parseCode($string) { $environment = Environment::createCommonMarkEnvironment(); $environment->addInlineParser(new MentionParser()); $parser = new DocParser($environment); $renderer = new HtmlRenderer($environment); $this->service = new CommonMarkParser($environment, $parser, $renderer); return $this->service->render($string); }
protected function newCommonMarkConverter(RootConfig $config) { $environment = Environment::createCommonMarkEnvironment(); foreach ($config->getCommonMarkExtensions() as $extension) { if (!class_exists($extension)) { throw new \RuntimeException(sprintf('CommonMark extension class "%s" does not exists. You must use a FCQN!', $extension)); } $environment->addExtension(new $extension()); } return new \League\CommonMark\Converter(new DocParser($environment), new HtmlRenderer($environment)); }
/** * Creates a new article object from its values. */ public function __construct(array $metatdata, string $text, string $slug) { $this->metatdata = $metatdata; $this->date = new Carbon($this->metatdata['date'] ?? 'now'); $this->slug = $slug; // Parse the Markdown document. $environment = Environment::createCommonMarkEnvironment(); $parser = new DocParser($environment); $this->renderer = new HtmlRenderer($environment); $this->document = $parser->parse($text); }
public function toHtml($content) { $environment = \League\CommonMark\Environment::createCommonMarkEnvironment(); $environment->mergeConfig([]); $environment->addExtension(new \Webuni\CommonMark\TableExtension\TableExtension()); $converter = new \League\CommonMark\Converter(new \League\CommonMark\DocParser($environment), new \League\CommonMark\HtmlRenderer($environment)); $content = $converter->convertToHtml($content); // strip comment marks $markdownContent = preg_replace("/\n\\-\\-[\\ ]*/s", "\n", $content); return $markdownContent; }
public function htmlIntroduction($before = '', $after = '') { $introduction = trim($this->introduction); if (empty($introduction)) { return; } $environment = Environment::createCommonMarkEnvironment(); $parser = new DocParser($environment); $htmlRenderer = new HtmlRenderer($environment); $text = $parser->parse($introduction); return $before . $htmlRenderer->renderBlock($text) . $after; }
/** * Create a new commonmark converter instance. * * @param array $config */ public function __construct(array $config = array()) { $environment = Environment::createCommonMarkEnvironment(); $environment->mergeConfig($config); $environment->addExtension(new TableExtension()); $this->extendEnvironment($environment); if (array_key_exists('processor_instance', $config['daux'])) { $config['daux']['processor_instance']->extendCommonMarkEnvironment($environment); } $this->docParser = new DocParser($environment); $this->htmlRenderer = new HtmlRenderer($environment); }
/** * @param string $string * @param string $expected * @return void * * @dataProvider dataForIntegrationTest */ public function testStrikethrough($string, $expected) { $environment = Environment::createCommonMarkEnvironment(); $environment->addInlineParser(new StrikethroughParser()); $environment->addInlineRenderer('CommonMarkExt\\Strikethrough\\Strikethrough', new StrikethroughRenderer()); $parser = new DocParser($environment); $renderer = new HtmlRenderer($environment); $document = $parser->parse($string); $html = $renderer->renderBlock($document); // // $converter = new CommonMarkConverter($environment->getConfig()); // $html = $converter->convertToHtml($string); $this->assertSame($expected, $html); }
/** * Returns rendered view * * @return string */ public function render() { if ($this->isMarkdown()) { $environment = Environment::createCommonMarkEnvironment(); $environment->addInlineParser(new TwitterHandleParser()); $parser = new DocParser($environment); $htmlRenderer = new HtmlRenderer($environment); $document = $parser->parse(file_get_contents($this->filename)); return $htmlRenderer->renderBlock($document); } ob_start(); extract($this->vars); require $this->filename; return ob_get_clean(); }
/** * Register the environment class. * * @return void */ protected function registerEnvironment() { $this->app->singleton('markdown.environment', function (Container $app) { $environment = Environment::createCommonMarkEnvironment(); $environment->addExtension(new TableExtension()); $environment->addExtension(new AttributesExtension()); $config = $app->config->get('markdown'); $environment->mergeConfig(array_except($config, ['extensions', 'views'])); foreach ((array) array_get($config, 'extensions') as $extension) { $environment->addExtension($app->make($extension)); } return $environment; }); $this->app->alias('markdown.environment', Environment::class); }
public function transform($markdownText) { $environment = Environment::createCommonMarkEnvironment(); $beforeParseEvent = Croogo::dispatchEvent('Helper.Markdown.beforeMarkdownParse', $this->_View, array('environment' => $environment, 'markdown' => $markdownText)); $markdownText = $beforeParseEvent->data['markdown']; $environment = $beforeParseEvent->data['environment']; $parser = new DocParser($environment); $htmlRenderer = new HtmlRenderer($environment); $documentAST = $parser->parse($markdownText); $beforeRenderEvent = Croogo::dispatchEvent('Helper.Markdown.beforeMarkdownRender', $this->_View, array('ast' => $documentAST)); $documentAST = $beforeRenderEvent->data['ast']; $rendered = $htmlRenderer->renderBlock($documentAST); $afterRenderEvent = Croogo::dispatchEvent('Helper.Markdown.afterMarkdownRender', $this->_View, array('rendered' => $rendered)); return $afterRenderEvent->data['rendered']; }
/** * Register the CommonMark Environment. * * @return void */ protected function registerMarkdownEnvironment() { $app = $this->app; $app->singleton('commonmark.environment', function ($app) { $config = $app['config']['markdown']; $environment = Environment::createCommonMarkEnvironment(); if ($config['configurations']) { $environment->mergeConfig($config['configurations']); } foreach ($config['extensions'] as $extension) { if (class_exists($extension)) { $environment->addExtension(new $extension()); } } return $environment; }); $app->alias('commonmark.environment', Environment::class); }
public function init() { $this->markdown = new CommonMarkConverter(apply_filters('cws_markdown_config', []), apply_filters('cws_markdown_environment', Environment::createCommonMarkEnvironment())); load_plugin_textdomain('markdown-on-save', NULL, basename(dirname(__FILE__))); add_filter('wp_insert_post_data', array($this, 'wp_insert_post_data'), 10, 2); // add_action( 'do_meta_boxes', array( $this, 'do_meta_boxes' ), 20, 2 ); add_action('post_submitbox_misc_actions', array($this, 'submitbox_actions')); add_filter('edit_post_content', array($this, 'edit_post_content'), 10, 2); add_filter('edit_post_content_filtered', array($this, 'edit_post_content_filtered'), 10, 2); add_action('load-post.php', array($this, 'load')); add_action('load-post.php', array($this, 'enqueue')); add_action('load-post-new.php', array($this, 'enqueue')); add_action('xmlrpc_call', array($this, 'xmlrpc_actions')); add_action('init', array($this, 'maybe_remove_kses'), 99); add_action('set_current_user', array($this, 'maybe_remove_kses'), 99); add_action('wp_insert_post', array($this, 'wp_insert_post')); add_action('wp_restore_post_revision', array($this, 'wp_restore_post_revision'), 10, 2); add_filter('_wp_post_revision_fields', array($this, '_wp_post_revision_fields')); }
private function createEnvironment() { $this->environment = Environment::createCommonMarkEnvironment(); $this->addInlineRenderers(); }
}, RealPathListener::class => object(), FileExistsCheck::class => object(), PhpLintCheck::class => object(), CodeParseCheck::class => function (ContainerInterface $c) { return new CodeParseCheck($c->get(Parser::class)); }, FunctionRequirementsCheck::class => function (ContainerInterface $c) { return new FunctionRequirementsCheck($c->get(Parser::class)); }, DatabaseCheck::class => object(), ComposerCheck::class => object(), Filesystem::class => object(), Parser::class => function () { $parserFactory = new ParserFactory(); return $parserFactory->create(ParserFactory::PREFER_PHP7); }, CodePatcher::class => function (ContainerInterface $c) { $patch = (new Patch())->withInsertion(new Insertion(Insertion::TYPE_BEFORE, 'ini_set("display_errors", 1);'))->withInsertion(new Insertion(Insertion::TYPE_BEFORE, 'error_reporting(E_ALL);'))->withInsertion(new Insertion(Insertion::TYPE_BEFORE, 'date_default_timezone_set("Europe/London");')); return new CodePatcher($c->get(Parser::class), new Standard(), $patch); }, FakerGenerator::class => function () { return FakerFactory::create(); }, RequestRenderer::class => object(), TerminalInterface::class => factory([TerminalFactory::class, 'fromSystem']), 'menu' => factory(MenuFactory::class), MenuFactory::class => object(), ExerciseRenderer::class => function (ContainerInterface $c) { return new ExerciseRenderer($c->get('appName'), $c->get(ExerciseRepository::class), $c->get(UserState::class), $c->get(UserStateSerializer::class), $c->get(MarkdownRenderer::class), $c->get(Color::class), $c->get(OutputInterface::class)); }, MarkdownRenderer::class => function (ContainerInterface $c) { $docParser = new DocParser(Environment::createCommonMarkEnvironment()); $cliRenderer = (new MarkdownCliRendererFactory())->__invoke($c); return new MarkdownRenderer($docParser, $cliRenderer); }, UserStateSerializer::class => function (ContainerInterface $c) { return new UserStateSerializer(getenv('HOME'), $c->get('workshopTitle'), $c->get(ExerciseRepository::class)); }, UserState::class => function (ContainerInterface $c) { return $c->get(UserStateSerializer::class)->deSerialize(); }, SyntaxHighlighter::class => factory(PsxFactory::class), PsxFactory::class => object(), ResetProgress::class => function (ContainerInterface $c) { return new ResetProgress($c->get(UserStateSerializer::class)); }, ResultRendererFactory::class => function (ContainerInterface $c) { $factory = new ResultRendererFactory(); $factory->registerRenderer(FunctionRequirementsFailure::class, FunctionRequirementsFailureRenderer::class); $factory->registerRenderer(Failure::class, FailureRenderer::class); $factory->registerRenderer(CgiResult::class, CgiResultRenderer::class, function (CgiResult $result) use($c) { return new CgiResultRenderer($result, $c->get(RequestRenderer::class)); });
/** * Create a new instance of commonMark with some custom parser rules * * @param string $mediaRoot * @return \League\CommonMark\Environment */ protected function initializeCommonMark($mediaRoot) { $environment = Environment::createCommonMarkEnvironment(); $environment->addInlineParser(new MediaParser($mediaRoot)); return $environment; }
/** * @return DocParser */ protected static function getParser() { if (static::$parser === null) { $environment = Environment::createCommonMarkEnvironment(); $environment->addExtension(new TableExtension()); static::$parser = new DocParser($environment); } return static::$parser; }
/** * Register the environment class. * * @param \Illuminate\Contracts\Foundation\Application $app * * @return void */ protected function registerEnvironment(Application $app) { $app->singleton('markdown.environment', function ($app) { $environment = Environment::createCommonMarkEnvironment(); $config = array_only($app->config->get('markdown'), ['renderer', 'enable_em', 'enable_strong', 'use_asterisk', 'use_underscore', 'safe']); $environment->mergeConfig($config); return $environment; }); $app->alias('markdown.environment', Environment::class); }
* Builds static pages from README and code samples. */ use Aura\Cli\CliFactory; require_once 'vendor/autoload.php'; //cli setup $factory = new CliFactory(); $cli = $factory->newContext($GLOBALS); $io = $factory->newStdio(); $getop = $cli->getopt(['b,build:', 'p,path:', 'e,env:']); //config $buildDir = $getop->get('--build', __DIR__ . '/_build'); $webPath = $getop->get('--path', '/Quickstarts'); $environment = $getop->get('--env', 'development'); //markdown $io->out('setting up markdown...'); $env = \League\CommonMark\Environment::createCommonMarkEnvironment(); $exampleParser = new ExampleParser(); $exampleRenderer = new ExampleRenderer(); $linkRenderer = new LinkRenderer(['nexmo.github.io', 'nexmo.com', 'docs.nexmo.com', 'dashboard.nexmo.com', 'help.nexmo.com']); $io->out('adding custom parsers/renderers...'); $env->addBlockParser($exampleParser); $env->addBlockRenderer('ExampleElement', $exampleRenderer); $env->addInlineRenderer('League\\CommonMark\\Inline\\Element\\Link', $linkRenderer); $parser = new \League\CommonMark\DocParser($env); $renderer = new \League\CommonMark\HtmlRenderer($env); $io->outln('done'); //mustache $io->out('setting up mustache template loader...'); $mustache = new Mustache_Engine(['loader' => new Mustache_Loader_FilesystemLoader(__DIR__ . '/_templates')]); $io->outln('done'); $io->out('checking for index README.md...');
/** * Register the environment class. * * @param \Illuminate\Contracts\Foundation\Application $app * * @return void */ protected function registerEnvironment(Application $app) { $app->singleton('markdown.environment', function ($app) { return Environment::createCommonMarkEnvironment(); }); $app->alias('markdown.environment', Environment::class); }
/** * Process the payload of an object * * @param string $payload Payload * @return string Processed payload */ public function processPayload($payload) { // Reset all relevant relations $this->resetRefersToRelations(); $this->resetEmbedsRelations(); $env = Environment::createCommonMarkEnvironment(); $env->addDocumentProcessor($this); // Parse and process the object payload /** @var DocParser $docParser */ $docParser = Kernel::create(DocParser::class, [$env]); $docParser->parse($payload); return $payload; }
/** * Extract the title and abstract out of the payload * * @param string $markdownPayload Markdown payload * @return array Titel and abstract */ protected function extractTitleAndAbstract($markdownPayload) { $abstract = trim($markdownPayload); if (preg_match('%^(.+?)\\R%', $markdownPayload, $firstParagraph)) { $abstract = trim($firstParagraph[1]); } // Strip formatting if (strlen($abstract)) { $environment = Environment::createCommonMarkEnvironment(); /** @var CommonMarkConverter $converter */ $converter = Kernel::create(CommonMarkConverter::class, [[], $environment]); $abstract = trim(strip_tags($converter->convertToHtml($abstract))); } $title = $abstract; return [$title, $abstract]; }