/**
* Execute the console command.
*
* @return mixed
*/
public function fire()
{
$topics = Topic::all();
$markdown = new Markdown();
$transfer_count = 0;
$convert_count = 0;
foreach ($topics as $topic) {
if (empty($topic->body_original)) {
// store the original data
$topic->body_original = $topic->body;
// convert to markdown
$topic->body = $markdown->convertMarkdownToHtml($topic->body);
$topic->save();
$transfer_count++;
} else {
// convert to markdown
$topic->body = $markdown->convertMarkdownToHtml($topic->body_original);
$topic->save();
$convert_count++;
}
}
$this->info("Transfer old data count: " . $transfer_count);
$this->info("Convert original to body count: " . $convert_count);
$this->info("It's Done, have a good day.");
}
public function testDecoding()
{
$formatter = new Markdown();
$data = array('name' => 'Joe', 'age' => 21, 'employed' => true, 'body' => "Lorem ipsum dolor\nsit amet");
$raw = file_get_contents(__DIR__ . '/fixtures/joe.md');
$this->assertEquals($data, $formatter->decode($raw));
}
/**
* Añade el producto a la base de datos con el nombre, medida, descripcion, rutaimagen, categoria y familia.
*
* @param $nombreprod string.
* @param $precioprod string.
* @param $medidas string.
* @param $descripcionprod string.
* @param $rutaimagen string.
* @param $idcategoria int.
* @param $idfamilia int.
* @return boolean.
*/
public function agregarProducto($nombreprod, $precioprod, $medidas, $descripcionprod, $rutaimagen, $idcategoria, $idfamilia)
{
$Markdown = new Markdown();
$my_html = $Markdown->transform($descripcionprod);
$query = "INSERT INTO producto(nombreprod, precioprod, medidas, descripcionprod, rutaimagen, categoria_idcategoria, categoria_familia_idfamilia)" . "VALUES('{$nombreprod}', '{$precioprod}', '{$medidas}','{$my_html}', '{$rutaimagen}', '{$idcategoria}', '{$idfamilia}');";
$this->logger->getLogger($query);
$result = $this->connection->query($query);
return $result;
}
public function testTablesHaveTableClass()
{
$parser = new Markdown();
$content = <<<'MARKDOWN'
|Tables|Is|
|------|--|
|OK |? |
MARKDOWN;
$result = $parser->text($content);
$this->assertEquals("<table class=\"table\">\n<thead>\n<tr>\n<th>Tables</th>\n<th>Is</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>OK</td>\n<td>?</td>\n</tr>\n</tbody>\n</table>", $result);
}
function markdown($string)
{
#
# Initialize the parser and return the result of its transform method.
#
# Setup static parser variable.
static $parser;
if (!isset($parser)) {
$parser = new Markdown();
}
# Transform text using parser.
return $parser->transform($string);
}
public function update($id)
{
$topic = Topic::findOrFail($id);
$data = Input::only('title', 'body', 'node_id');
$this->authorOrAdminPermissioinRequire($topic->user_id);
$markdown = new Markdown();
$data['body_original'] = $data['body'];
$data['body'] = $markdown->convertMarkdownToHtml($data['body']);
$data['excerpt'] = Topic::makeExcerpt($data['body']);
// Validation
App::make('Phphub\\Forms\\TopicCreationForm')->validate($data);
$topic->update($data);
Flash::success(lang('Operation succeeded.'));
return Redirect::route('topics.show', $topic->id);
}
/**
* Encodes the content into HTML based on Markdown
*
* @return void
*/
protected function _cache_content()
{
$this->cached_content = Markdown::encode($this->content);
if (preg_match_all('/<p>(.*)<\\/p>/', $this->cached_content, $matches)) {
$this->description = substr(strip_tags($matches[1][0]), 0, 500);
}
}
/**
* @inheritDoc
*/
protected function identifyLine($lines, $current)
{
if (isset($lines[$current]) && strncmp($lines[$current], '```', 3) === 0) {
return 'fencedCode';
}
return parent::identifyLine($lines, $current);
}
/**
* Returns a function converting Markdown into HTML but only parsing inline elements.
* @return \Closure A function converting Markdown into HTML but only parsing inline elements.
*/
public function getMarkdownParagraph() : \Closure
{
return function ($value, \Mustache_LambdaHelper $helper) {
$args = $this->parseArguments($helper->render($value), 'markdown', ['flavor' => Markdown::$defaultFlavor]);
return Markdown::processParagraph($args['markdown'], $args['flavor']);
};
}
/**
* compile markdown to html and render as text
*
* @return Illuminate\View\View
*/
public function previewNoEnclosingPage()
{
$markdown = Markdown::defaultTransform(e(Input::get('data')));
$response = Response::make($markdown);
$response->header('Content-Type', 'text/html');
return $response;
}
/**
* Sets the renderer for markdown fields to use
* @param {string} $renderer Class Name of an implementation of IMarkdownRenderer
*/
public static function setRenderer($renderer)
{
if (ClassInfo::classImplements($renderer, 'IMarkdownRenderer')) {
self::$renderer = $renderer;
} else {
user_error('The renderer ' . $renderer . ' does not implement IMarkdownRenderer', E_USER_ERROR);
}
}
/**
* @inheritdocs
*
* Parses a newline indicated by two spaces on the end of a markdown line.
*/
protected function renderText($text)
{
if ($this->enableNewlines) {
return preg_replace("/( \n|\n)/", $this->html5 ? "<br>\n" : "<br />\n", $text[1]);
} else {
return parent::renderText($text);
}
}
private function get_how_to_use_content($f3)
{
$content = "How to use content.";
$file = F3::instance()->read('help/README.md');
$html = Markdown::instance()->convert($file);
$f3->set('how_to_use_content', $html);
return $content;
}
/**
* Get the given documentation page.
*
* @param string $manual
* @param string $version
* @param string $page
* @return string
*/
public function get($manual, $version, $page)
{
$pageFile = $this->storagePath . '/' . $manual . '/' . $version . '/' . $page . '.md';
if ($this->files->exists($pageFile)) {
return $this->cached("{$manual}.{$version}.{$pageFile}", Markdown::parse($this->files->get($pageFile), $manual . '/' . $version . '/' . dirname($page)));
} else {
App::abort(404);
}
}
private function updateExportSettings()
{
$input = Input::only($this->export_features);
$input['ex_disclaimer_html'] = Markdown::string($input['ex_disclaimer']);
foreach ($input as $key => $value) {
Setting::set($key, $value);
}
return true;
}
/**
* Generate a preview
*
* @param array $input
* @param $user
* @return \Illuminate\View\View
*/
public function generatePost($input, $user)
{
// Generate preview post
$post = $this->postRepo->getEmptyPost();
$post->author = $user;
$post->markdown = $input['content'];
$post->html = \Purifier::clean(\Markdown::text($input['content']));
return $post;
}
public function testFacadeRoot()
{
$class = get_class(Markdown::getFacadeRoot());
if ('sundown' == Conf::get('markdown')) {
$this->assertEquals('Pochika\\Markdown\\Sundown', $class);
} else {
$this->assertEquals('Pochika\\Markdown\\PHPMarkdownExtra', $class);
}
}
/**
* @inheritdocs
*
* Parses a newline indicated by two spaces on the end of a markdown line.
*/
protected function renderText($text)
{
if ($this->enableNewlines) {
$br = $this->html5 ? "<br>\n" : "<br />\n";
return strtr($text[1], [" \n" => $br, "\n" => $br]);
} else {
return parent::renderText($text);
}
}
/**
* convert
*
* @param string $text
* @return string
*/
public static function convert($text)
{
if (empty(self::$parser)) {
self::$parser = new HyperDown();
self::$parser->hook('afterParseCode', array('Markdown', 'transerCodeClass'));
self::$parser->hook('beforeParseInline', array('Markdown', 'transerComment'));
}
return self::$parser->makeHtml($text);
}
function parse($str, $markdown = true)
{
// process tags
$pattern = '/[\\{\\{]{1}([a-z]+)[\\}\\}]{1}/i';
if (preg_match_all($pattern, $str, $matches)) {
list($search, $replace) = $matches;
foreach ($replace as $index => $key) {
$replace[$index] = Config::meta($key);
}
$str = str_replace($search, $replace, $str);
}
$str = html_entity_decode($str, ENT_NOQUOTES, System\Config::app('encoding'));
// Parse Markdown as well?
if ($markdown === true) {
$md = new Markdown();
$str = $md->transform($str);
}
return $str;
}
public function preview()
{
$md = $this->request->get('md');
if (!empty($md)) {
$html = Markdown::convert($md);
echo $html;
}
echo '';
exit;
}
/**
* Create post
*
* @param array $input
* @param $topic
* @param $user
* @param bool $add
* @return \Illuminate\Http\RedirectResponse|object
*/
public function create($input, $topic, $user, $add = true)
{
// Create post
$data = ['markdown' => $input['content'], 'html' => \Purifier::clean(\Markdown::text($input['content'])), 'topic_id' => $topic->id, 'user_id' => $user->id];
if (\Bouncer::hasPermission('devresponse') and \Input::get('devresponse') == 1) {
$data['developer_response'] = true;
}
$post = $this->postRepo->create($data);
return $post;
}
public static function getReadme($owner, $repo)
{
$token = self::getAccessToken();
$readmeUrl = 'https://api.github.com/repos/' . $owner . '/' . $repo . '/readme?access_token=' . $token;
$client = self::getClient();
$res = $client->get($readmeUrl, []);
$readmeHash = json_decode($res->getBody(), true);
$readme = ['readme' => \Markdown::convertToHtml(imap_base64($readmeHash['content']))];
return $readme;
}
public function setTemplateFilters()
{
//markdown
$this->template->addFilter('md', function ($s) {
return \Michelf\Markdown::defaultTransform($s);
});
//inline markdown
$this->template->addFilter('imd', function ($s) {
return strip_tags(Markdown::defaultTransform($s), '<a><strong><em>');
});
}
public function format($value)
{
$flag = $this->module->flag;
if ($flag == "L") {
return Markdown::defaultTransform(Str::limit($value, $this->listLimit));
}
if ($flag == "R") {
return Markdown::defaultTransform($value);
}
return $value;
}
public function code($code, $lang = null, $escaped = null)
{
if ($this->options['highlight']) {
$out = $this->options['highlight']($code, $lang);
if ($out != null && $out !== $code) {
$escaped = true;
$code = $out;
}
}
$class = $lang ? ' class="' . $this->options['langPrefix'] . Markdown::escape($lang, true) . '"' : '';
$code = $escaped ? $code : Markdown::escape($code, true);
return "<pre><code{$class}>{$code}\n</code></pre>\n";
}
public function toHtml(array $data)
{
$text = $data['text'];
$html = '<blockquote>';
$html .= Markdown::defaultTransform($text);
// Add the cite if necessary
if (isset($data['cite']) && !empty($data['cite'])) {
// remove the indent thats added by Sir Trevor
$cite = ltrim($data['cite'], '>');
$html .= '<cite>' . Markdown::defaultTransform($cite) . '</cite>';
}
$html .= '</blockquote>';
return $html;
}
public static function value($extend, $value = null)
{
switch ($extend->field) {
case 'text':
if (!empty($extend->value->text)) {
$value = $extend->value->text;
}
break;
case 'html':
if (!empty($extend->value->html)) {
$md = new Markdown();
$value = $md->transform($extend->value->html);
}
break;
case 'image':
case 'file':
if (!empty($extend->value->filename)) {
$value = asset('content/' . $extend->value->filename);
}
break;
}
return $value;
}
protected function readDoc($fileName)
{
// Key for cache
$cacheKey = md5('docs.' . $fileName);
// use cache if exist
if ($this->cache->has($cacheKey)) {
return $this->cache->get($cacheKey);
}
$getContent = $this->file->get(base_path('docs/' . $fileName));
$doc = \Markdown::text($getContent);
// Put it in cache
$this->cache->put($cacheKey, $doc, 10080);
return $doc;
}
function showMarkitupPreview($txtData, $type = "markitup")
{
$htmlData = "";
switch ($type) {
case 'markitup':
require dirname(__FILE__) . "/Michelf/Markdown.inc.php";
//require dirname(__FILE__)."/Michelf/MarkdownExtra.inc.php";
$htmlData = Markdown::defaultTransform($txtData);
break;
default:
$htmlData = $txtData;
break;
}
return $htmlData;
}
