PHP helpers\Markdown类代码示例

 public function actionBlog()
 {
     $id = Yii::$app->request->get('id');
     $data = TblBlog::find()->joinwith('category')->where([TblBlog::tableName() . '.id' => $id])->asArray()->one();
     $data['text'] = Markdown::process($data['text'], 'gfm');
     return $this->render('article', ['data' => $data]);
 }

 public function actionRss()
 {
     /** @var News[] $news */
     $news = News::find()->where(['status' => News::STATUS_PUBLIC])->orderBy('id DESC')->limit(50)->all();
     $feed = new Feed();
     $feed->title = 'YiiFeed';
     $feed->link = Url::to('');
     $feed->selfLink = Url::to(['news/rss'], true);
     $feed->description = 'Yii news';
     $feed->language = 'en';
     $feed->setWebMaster('sam@rmcreative.ru', 'Alexander Makarov');
     $feed->setManagingEditor('sam@rmcreative.ru', 'Alexander Makarov');
     foreach ($news as $post) {
         $item = new Item();
         $item->title = $post->title;
         $item->link = Url::to(['news/view', 'id' => $post->id], true);
         $item->guid = Url::to(['news/view', 'id' => $post->id], true);
         $item->description = HtmlPurifier::process(Markdown::process($post->text));
         if (!empty($post->link)) {
             $item->description .= Html::a(Html::encode($post->link), $post->link);
         }
         $item->pubDate = $post->created_at;
         $item->setAuthor('noreply@yiifeed.com', 'YiiFeed');
         $feed->addItem($item);
     }
     $feed->render();
 }

 /**
  * Process $text using settings without explode \n to <p>
  * $ntext = true change \n to <br>
  * @param $text
  * @param bool $ntext
  * @return string
  */
 public function directTypo($text)
 {
     $t = $this->Setup();
     $text = Markdown::processParagraph($text, $this->markdownType);
     $t->set_text($text);
     return $t->apply();
 }

 public function actionTest()
 {
     echo \yii\helpers\Markdown::process('**strong text***emphasized text*');
     exit;
     //        echo Yii::getAlias('@yii/storage');
     return $this->render('test');
 }

 public static function prepareForSave($model)
 {
     list($model->PostText, $imgs, $urls) = self::parseText($model->PostText);
     $model->PostTextParsed = Markdown::process($model->PostText);
     $model->PostHeader = self::createHeader(strip_tags($model->PostText));
     return [$model, $imgs, $urls];
 }

 protected function parseData($path)
 {
     preg_match('~guide-?(.*)/(.+)\\.md$~', $path, $matches);
     $language = $matches[1] ? $matches[1] : Yii::$app->sourceLanguage;
     $language = Locale::getPrimaryLanguage($language);
     $slug = strtolower($matches[2]);
     $doc = file_get_contents($path);
     $doc = Markdown::process($doc, 'gfm');
     $html = new HTMLDocument();
     @$html->loadHTML($doc);
     $html->addPrefix("/{lang}/", 'a', 'href');
     $imgPath = dirname($path) . '/images';
     $imgPath = $this->publishImages($imgPath);
     if ($imgPath) {
         $html->addPrefix(function ($src) use($imgPath) {
             return $imgPath . '/' . basename($src);
         }, 'img', 'src');
     }
     foreach (['h1', 'h2', 'h3', 'h4'] as $tag) {
         /** @var \DOMElement $item */
         foreach ($html->getElementsByTagName($tag) as $item) {
             /** @var \DOMElement $span */
             if ($span = $item->getElementsByTagName('span')[0]) {
                 $item->setAttribute('id', $span->getAttribute('id'));
             }
         }
     }
     /** @var DOMElement $title */
     $title = $html->getElementsByTagName('h1')[0];
     return ['language' => $language, 'slug' => $slug, 'title' => $title->textContent, 'description' => $html->saveHTML()];
 }

 /**
  * @inheritdoc
  */
 public function behaviors()
 {
     return [TimestampBehavior::className(), ['class' => AttributeBehavior::className(), 'attributes' => [ActiveRecord::EVENT_BEFORE_INSERT => 'alias'], 'value' => function ($event) {
         return Inflector::slug($event->sender->title);
     }], ['class' => AttributeBehavior::className(), 'attributes' => [ActiveRecord::EVENT_AFTER_FIND => 'body'], 'value' => function ($event) {
         return HtmlPurifier::process(Markdown::process($event->sender->content, 'gfm'));
     }]];
 }

 public function beforeSave($insert)
 {
     parent::beforeSave($insert);
     $this->historyTemp = new History();
     $this->historyTemp->attributes = ['title' => $this->title, 'content' => $this->content, 'user_id' => 1];
     $this->content = Markdown::process($this->content, 'gfm');
     if (!$this->isNewRecord) {
         $this->historyTemp->renderDiff($this->lastEdit);
     }
     return true;
 }

 public function up()
 {
     $works = Work::find()->all();
     foreach ($works as $work) {
         if ($work->description && strpos('<p>', $work->description) === false) {
             echo "Convert  {$work->id} 's description...\n";
             $work->description = Markdown::process($work->description, 'gfm');
             $work->save(false);
         }
     }
     echo "DOne\n";
 }

 /**
  * Converts markdown into HTML
  *
  * @param string $content
  * @param TypeDoc $context
  * @param boolean $paragraph
  * @return string
  */
 public static function process($content, $context = null, $paragraph = false)
 {
     if (!isset(Markdown::$flavors['api-latex'])) {
         Markdown::$flavors['api-latex'] = new static();
     }
     if (is_string($context)) {
         $context = static::$renderer->apiContext->getType($context);
     }
     Markdown::$flavors['api-latex']->renderingContext = $context;
     if ($paragraph) {
         return Markdown::processParagraph($content, 'api-latex');
     } else {
         return Markdown::process($content, 'api-latex');
     }
 }

 public function run()
 {
     if ($this->hasModel()) {
         $tagOptions = ArrayHelper::merge($this->options, ['id' => $this->targetId, 'class' => $this->clientOptions['class'] ?: '', 'data' => ['target' => $this->options['id']]]);
         if (isset($this->clientOptions['inline'])) {
             $value = Markdown::processParagraph(Html::getAttributeValue($this->model, $this->attribute));
             echo Html::tag($this->clientOptions['tag'] ?: 'p', $value, $tagOptions);
         } else {
             $value = MarkdownExtra::defaultTransform(Html::getAttributeValue($this->model, $this->attribute));
             echo Html::tag('section', Html::tag($this->clientOptions['tag'] ?: 'p', $value), $tagOptions);
         }
         echo Html::activeHiddenInput($this->model, $this->attribute);
     }
     $this->registerPlugin();
 }

 /**
  * @inheritdoc
  * @throws \InvalidArgumentException when params are not empty
  */
 public function render($view, $file, $params)
 {
     if (!empty($params)) {
         throw new \InvalidArgumentException('MdViewRenderer does not support params.');
     }
     if ($this->cache) {
         $key = self::CACHE_PREFIX . $file;
         $result = $this->cache->get($key);
         if ($result === false) {
             $result = Markdown::process(file_get_contents($file), $this->flavor);
             $this->cache->set($key, $result, 0, new FileDependency(['fileName' => $file]));
         }
     } else {
         $result = Markdown::process(file_get_contents($file), $this->flavor);
     }
     return $result;
 }

 /**
  * Helper function for the docs action
  * @return string
  */
 private function createHtml($file, $useRootPath = false)
 {
     \Yii::trace("Creating HTML for '{$file}'", __METHOD__);
     try {
         $filePath = \Yii::getAlias($this->module->markdownUrl) . '/' . $file;
         $markdown = file_get_contents($filePath);
         \Yii::trace("Loaded markdown for '{$filePath}'", __METHOD__);
     } catch (\Exception $e) {
         \Yii::$app->session->addFlash("error", "File '{$file}' not found,");
         return false;
     }
     $_slash = $useRootPath ? '' : '/';
     $html = Markdown::process($markdown, 'gfm');
     $html = preg_replace('|<a href="(?!http)' . $_slash . '(.+\\.md)">|U', '<a href="__INTERNAL_URL__$1">', $html);
     $dummyUrl = Url::to(['/' . $this->module->id . '/default/index', 'file' => '__PLACEHOLDER__']);
     $html = strtr($html, ['__INTERNAL_URL__' => $dummyUrl]);
     $html = strtr($html, ['__PLACEHOLDER__' => '']);
     return $html;
 }

<?php

use yii\helpers\Markdown;
$NodeLink = \common\models\NodeLink::NodeLink($node);
if (!empty($NodeLink)) {
    ?>
<section>
    <div class="block-content markdown-content">
        <?php 
    foreach ($NodeLink as $link) {
        ?>
        <?php 
        echo Markdown::process($link['content'], 'gfm');
        ?>
        <?php 
    }
    ?>
    </div>
</section>
<?php 
}

 public static function markdown2html($str)
 {
     return Markdown::process($str);
 }