/**
  * 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);
     }
 }

 /**
  * 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);
     }
 }

 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);
     }
 }

 /**
  * 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;
 }