├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── LICENSE
├── README.md
├── composer.json
├── phpunit.xml
├── src
    ├── Converter.php
    ├── ConverterExtra.php
    └── Parser.php
└── test
    ├── ConverterExtraTest.php
    ├── ConverterTest.php
    └── ConverterTestCase.php


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Editor config
 2 | .idea
 3 | 
 4 | # Dependencies
 5 | vendor
 6 | composer.lock
 7 | 
 8 | # Local test files
 9 | test.html
10 | test.php


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | before_script:
 3 |   - wget http://getcomposer.org/composer.phar
 4 |   - php composer.phar install
 5 | php:
 6 |   - 7.3
 7 |   - 7.2
 8 |   - 7.1
 9 |   - 7.0
10 |   - 5.6
11 |   - 5.5
12 |   - 5.4
13 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | CHANGELOG
 2 | ==============
 3 | 
 4 | 
 5 | 22/01/2019 v2.3.1
 6 | --------------
 7 | 
 8 |  * Fix: PHP 7.3 support (#36)
 9 | 
10 | 
11 | 27/03/2018 v2.3.0
12 | --------------
13 | 
14 |  * Support: Remove PHP5.3 & hhvm support
15 |  * Fix: inline spacing and empty tag (#33)
16 |  * Fix: aside element conversion (#33) 
17 |  * License: use the MIT license for now 
18 |  * Refactor: use brackets notation for array (#28) 
19 | 
20 | 
21 | 22/12/2017 v2.2.2
22 | --------------
23 | 
24 |  * Fix: Allow to strip `<u>` tags (#25)
25 | 
26 | 
27 | 21/09/2016 v2.2.1
28 | --------------
29 | 
30 |  * Fix: Moving trailing whitespace from inline elements outside of the element
31 |  * Feature: Use PSR-4
32 |  * Feature: PHP 7.0 support in continuous integration
33 |  * Doc: Update of the README
34 | 
35 | 
36 | 07/09/2016 v2.2.0
37 | --------------
38 | 
39 |  * Fix: Reset state between each parsing
40 | 
41 | 
42 | 19/02/2016 v2.1.11
43 | --------------
44 | 
45 |  * Fix: Empty table cell conversion
46 | 
47 | 
48 | 10/02/2016 v2.1.10
49 | --------------
50 | 
51 |  * Fix: Handle nested table.
52 | 
53 | 
54 | 01/04/2015 v2.1.9
55 | --------------
56 | 
57 |  * Fix: Handle HTML breaks & spaces in a less destructive way.
58 | 
59 | 
60 | 26/03/2015 v2.1.8
61 | --------------
62 | 
63 |  * Fix: Use alternative italic character
64 |  * Fix: Handle HTML breaks inside another tag
65 |  * Fix: Handle HTML spaces around tags
66 | 
67 | 
68 | 07/11/2014 v2.1.7
69 | --------------
70 | 
71 |  * Change composer name to "elephant418/markdownify"
72 | 
73 | 
74 | 14/07/2014 v2.1.6
75 | --------------
76 | 
77 |  * Fix: Simulate a paragraph for inline text preceding block element
78 |  * Fix: Nested lists
79 |  * Fix: setKeepHTML method
80 |  * Feature: PHP 5.5 & 5.6 support in continuous integration
81 | 
82 | 
83 | 16/03/2014 v2.1.5
84 | --------------
85 | 
86 | Add display settings
87 | 
88 |  * Test: Add tests for footnotes after every paragraph or not
89 |  * Feature: Allow to display link reference in paragraph, without footnotes
90 | 
91 | 
92 | 27/02/2014 v2.1.4
93 | --------------
94 | 
95 | Improve how ConverterExtra handle id & class attributes:
96 | 
97 |  * Feature: Allow id & class attributes on links
98 |  * Feature: Allow class attributes on headings


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2008-2019 Milian Wolff, Thomas Zilliox
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | 
 7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 8 | 
 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Markdownify
 2 | 
 3 | [![Build Status](https://travis-ci.org/Elephant418/Markdownify.png?branch=master)](https://travis-ci.org/Elephant418/Markdownify?branch=master)
 4 | [![Total Downloads](https://poser.pugx.org/pixel418/markdownify/downloads)](https://packagist.org/packages/pixel418/markdownify)
 5 | [![MIT](https://poser.pugx.org/pixel418/markdownify/license)](https://opensource.org/licenses/MIT)
 6 | 
 7 | The HTML to Markdown converter for PHP
 8 | 
 9 | [Code example](#code-example) | [How to Install](#how-to-install) | [How to Contribute](#how-to-contribute) | [Author & Community](#author--community)
10 | 
11 | 
12 | 
13 | Code example
14 | --------
15 | 
16 | ### Markdown
17 | 
18 | ```php
19 | $converter = new Markdownify\Converter;
20 | $converter->parseString('<h1>Heading</h1>');
21 | // Returns: # Heading
22 | ```
23 | 
24 | ### Markdown Extra [as defined by @michelf](http://michelf.ca/projects/php-markdown/extra/)
25 | 
26 | ```php
27 | $converter = new Markdownify\ConverterExtra;
28 | $converter->parseString('<h1 id="md">Heading</h1>');
29 | // Returns: # Heading {#md}
30 | ```
31 | 
32 | 
33 | 
34 | How to Install
35 | --------
36 | 
37 | This library package requires `PHP 5.4` or later.<br>
38 | Install [Composer](http://getcomposer.org/doc/01-basic-usage.md#installation) and run the following command to get the latest version:
39 | 
40 | ```sh
41 | composer require pixel418/markdownify
42 | ```
43 | 
44 | 
45 | 
46 | How to Contribute
47 | --------
48 | 
49 | 1. Fork the Markdownify repository
50 | 2. Create a new branch for each feature or improvement
51 | 3. Send a pull request from each feature branch to the **v2.x** branch
52 | 
53 | If you don't know much about pull request, you can read [the Github article](https://help.github.com/articles/using-pull-requests)
54 | 
55 | 
56 | 
57 | Author & Community
58 | --------
59 | 
60 | Markdownify is under [MIT License](https://opensource.org/licenses/MIT)<br>
61 | It was created by [Milian Wolff](http://milianw.de)<br>
62 | It was converted to a Symfony Bundle by [Peter Kruithof](https://github.com/pkruithof)<br>
63 | It is maintained by [Thomas ZILLIOX](https://tzi.fr)
64 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "pixel418/markdownify",
 3 |     "type": "lib",
 4 |     "description": "The HTML to Markdown converter for PHP ",
 5 |     "keywords": ["markdown", "html", "converter", "markdownify"],
 6 |     "license": "MIT",
 7 |     "homepage": "https://github.com/elephant418/Markdownify",
 8 |     "authors": [
 9 |         {
10 |             "name": "Milian Wolff",
11 |             "email": "mail@milianw.de",
12 |             "homepage": "http://milianw.de"
13 | 
14 |         },
15 |         {
16 |             "name": "Thomas Zilliox",
17 |             "email": "hello@tzi.fr",
18 |             "homepage": "https://tzi.fr"
19 |         }
20 |     ],
21 |     "require": {
22 |         "php": ">=5.4.0"
23 |     },
24 |     "require-dev": {
25 |         "phpunit/phpunit": "^4.8"
26 |     },
27 |     "autoload": {
28 |         "psr-4": {
29 |             "Markdownify\\": "src",
30 |             "Test\\Markdownify\\": "test"
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
1 | <phpunit colors="true">
2 |     <testsuite name="Markdownify">
3 |         <directory>./test/</directory>
4 |     </testsuite>
5 | </phpunit>


--------------------------------------------------------------------------------
/src/Converter.php:
--------------------------------------------------------------------------------
   1 | <?php
   2 | 
   3 | namespace Markdownify;
   4 | 
   5 | /**
   6 |  * default configuration
   7 |  */
   8 | define('MDFY_BODYWIDTH', false);
   9 | define('MDFY_KEEPHTML', true);
  10 | 
  11 | /**
  12 |  * HTML to Markdown converter class
  13 |  */
  14 | class Converter
  15 | {
  16 |     /**
  17 |      * html parser object
  18 |      *
  19 |      * @var parseHTML
  20 |      */
  21 |     protected $parser;
  22 | 
  23 |     /**
  24 |      * markdown output
  25 |      *
  26 |      * @var string
  27 |      */
  28 |     protected $output;
  29 | 
  30 |     /**
  31 |      * stack with tags which where not converted to html
  32 |      *
  33 |      * @var array<string>
  34 |      */
  35 |     protected $notConverted = [];
  36 | 
  37 |     /**
  38 |      * skip conversion to markdown
  39 |      *
  40 |      * @var bool
  41 |      */
  42 |     protected $skipConversion = false;
  43 | 
  44 |     /* options */
  45 | 
  46 |     /**
  47 |      * keep html tags which cannot be converted to markdown
  48 |      *
  49 |      * @var bool
  50 |      */
  51 |     protected $keepHTML = false;
  52 | 
  53 |     /**
  54 |      * wrap output, set to 0 to skip wrapping
  55 |      *
  56 |      * @var int
  57 |      */
  58 |     protected $bodyWidth = 0;
  59 | 
  60 |     /**
  61 |      * minimum body width
  62 |      *
  63 |      * @var int
  64 |      */
  65 |     protected $minBodyWidth = 25;
  66 | 
  67 |     /**
  68 |      * position where the link reference will be displayed
  69 |      *
  70 |      *
  71 |      * @var int
  72 |      */
  73 |     protected $linkPosition;
  74 |     const LINK_AFTER_CONTENT = 0;
  75 |     const LINK_AFTER_PARAGRAPH = 1;
  76 |     const LINK_IN_PARAGRAPH = 2;
  77 | 
  78 |     /**
  79 |      * stores current buffers
  80 |      *
  81 |      * @var array<string>
  82 |      */
  83 |     protected $buffer = [];
  84 | 
  85 |     /**
  86 |      * stores current buffers
  87 |      *
  88 |      * @var array<string>
  89 |      */
  90 |     protected $footnotes = [];
  91 | 
  92 |     /**
  93 |      * tags with elements which can be handled by markdown
  94 |      *
  95 |      * @var array<string>
  96 |      */
  97 |     protected $isMarkdownable = [
  98 |         'p' => [],
  99 |         'ul' => [],
 100 |         'ol' => [],
 101 |         'li' => [],
 102 |         'br' => [],
 103 |         'blockquote' => [],
 104 |         'code' => [],
 105 |         'pre' => [],
 106 |         'a' => [
 107 |             'href' => 'required',
 108 |             'title' => 'optional',
 109 |         ],
 110 |         'strong' => [],
 111 |         'b' => [],
 112 |         'em' => [],
 113 |         'i' => [],
 114 |         'img' => [
 115 |             'src' => 'required',
 116 |             'alt' => 'optional',
 117 |             'title' => 'optional',
 118 |         ],
 119 |         'h1' => [],
 120 |         'h2' => [],
 121 |         'h3' => [],
 122 |         'h4' => [],
 123 |         'h5' => [],
 124 |         'h6' => [],
 125 |         'hr' => [],
 126 |     ];
 127 | 
 128 |     /**
 129 |      * html tags to be ignored (contents will be parsed)
 130 |      *
 131 |      * @var array<string>
 132 |      */
 133 |     protected $ignore = [
 134 |         'html',
 135 |         'body',
 136 |     ];
 137 | 
 138 |     /**
 139 |      * html tags to be dropped (contents will not be parsed!)
 140 |      *
 141 |      * @var array<string>
 142 |      */
 143 |     protected $drop = [
 144 |         'script',
 145 |         'head',
 146 |         'style',
 147 |         'form',
 148 |         'area',
 149 |         'object',
 150 |         'param',
 151 |         'iframe',
 152 |     ];
 153 | 
 154 |     /**
 155 |      * html block tags that allow inline & block children
 156 |      *
 157 |      * @var array<string>
 158 |      */
 159 |     protected $allowMixedChildren = [
 160 |         'li'
 161 |     ];
 162 | 
 163 |     /**
 164 |      * Markdown indents which could be wrapped
 165 |      * @note: use strings in regex format
 166 |      *
 167 |      * @var array<string>
 168 |      */
 169 |     protected $wrappableIndents = [
 170 |         '\*   ', // ul
 171 |         '\d.  ', // ol
 172 |         '\d\d. ', // ol
 173 |         '> ', // blockquote
 174 |         '', // p
 175 |     ];
 176 | 
 177 |     /**
 178 |      * list of chars which have to be escaped in normal text
 179 |      * @note: use strings in regex format
 180 |      *
 181 |      * @var array
 182 |      *
 183 |      * TODO: what's with block chars / sequences at the beginning of a block?
 184 |      */
 185 |     protected $escapeInText = [
 186 |         '\*\*([^*]+)\*\*' => '\*\*$1\*\*', // strong
 187 |         '\*([^*]+)\*' => '\*$1\*', // em
 188 |         '__(?! |_)(.+)(?!<_| )__' => '\_\_$1\_\_', // strong
 189 |         '_(?! |_)(.+)(?!<_| )_' => '\_$1\_', // em
 190 |         '([-*_])([ ]{0,2}\1){2,}' => '\\\\$0', // hr
 191 |         '`' => '\`', // code
 192 |         '\[(.+)\](\s*\()' => '\[$1\]$2', // links: [text] (url) => [text\] (url)
 193 |         '\[(.+)\](\s*)\[(.*)\]' => '\[$1\]$2\[$3\]', // links: [text][id] => [text\][id\]
 194 |         '^#(#{0,5}) ' => '\#$1 ', // header
 195 |     ];
 196 | 
 197 |     /**
 198 |      * wether last processed node was a block tag or not
 199 |      *
 200 |      * @var bool
 201 |      */
 202 |     protected $lastWasBlockTag = false;
 203 | 
 204 |     /**
 205 |      * name of last closed tag
 206 |      *
 207 |      * @var string
 208 |      */
 209 |     protected $lastClosedTag = '';
 210 | 
 211 |     /**
 212 |      * number of line breaks before next inline output
 213 |      */
 214 |     protected $lineBreaks = 0;
 215 | 
 216 |     /**
 217 |      * node stack, e.g. for <a> and <abbr> tags
 218 |      *
 219 |      * @var array<array>
 220 |      */
 221 |     protected $stack = [];
 222 | 
 223 |     /**
 224 |      * current indentation
 225 |      *
 226 |      * @var string
 227 |      */
 228 |     protected $indent = '';
 229 | 
 230 |     /**
 231 |      * constructor, set options, setup parser
 232 |      *
 233 |      * @param int $linkPosition define the position of links
 234 |      * @param int $bodyWidth whether or not to wrap the output to the given width
 235 |      *             defaults to false
 236 |      * @param bool $keepHTML whether to keep non markdownable HTML or to discard it
 237 |      *             defaults to true (HTML will be kept)
 238 |      * @return void
 239 |      */
 240 |     public function __construct($linkPosition = self::LINK_AFTER_CONTENT, $bodyWidth = MDFY_BODYWIDTH, $keepHTML = MDFY_KEEPHTML)
 241 |     {
 242 |         $this->linkPosition = $linkPosition;
 243 |         $this->keepHTML = $keepHTML;
 244 | 
 245 |         if ($bodyWidth > $this->minBodyWidth) {
 246 |             $this->bodyWidth = intval($bodyWidth);
 247 |         } else {
 248 |             $this->bodyWidth = false;
 249 |         }
 250 | 
 251 |         $this->parser = new Parser;
 252 |         $this->parser->noTagsInCode = true;
 253 | 
 254 |         // we don't have to do this every time
 255 |         $search = [];
 256 |         $replace = [];
 257 |         foreach ($this->escapeInText as $s => $r) {
 258 |             array_push($search, '@(?<!\\\)' . $s . '@U');
 259 |             array_push($replace, $r);
 260 |         }
 261 |         $this->escapeInText = [
 262 |             'search' => $search,
 263 |             'replace' => $replace
 264 |         ];
 265 |     }
 266 | 
 267 |     /**
 268 |      * parse a HTML string
 269 |      *
 270 |      * @param string $html
 271 |      * @return string markdown formatted
 272 |      */
 273 |     public function parseString($html)
 274 |     {
 275 |         $this->resetState();
 276 | 
 277 |         $this->parser->html = $html;
 278 |         $this->parse();
 279 | 
 280 |         return $this->output;
 281 |     }
 282 | 
 283 |     /**
 284 |      * set the position where the link reference will be displayed
 285 |      *
 286 |      * @param int $linkPosition
 287 |      * @return void
 288 |      */
 289 |     public function setLinkPosition($linkPosition)
 290 |     {
 291 |         $this->linkPosition = $linkPosition;
 292 |     }
 293 | 
 294 |     /**
 295 |      * set keep HTML tags which cannot be converted to markdown
 296 |      *
 297 |      * @param bool $linkPosition
 298 |      * @return void
 299 |      */
 300 |     public function setKeepHTML($keepHTML)
 301 |     {
 302 |         $this->keepHTML = $keepHTML;
 303 |     }
 304 | 
 305 |     /**
 306 |      * iterate through the nodes and decide what we
 307 |      * shall do with the current node
 308 |      *
 309 |      * @param void
 310 |      * @return void
 311 |      */
 312 |     protected function parse()
 313 |     {
 314 |         $this->output = '';
 315 | 
 316 |         // Drop tags
 317 |         $this->parser->html = preg_replace('#<(' . implode('|', $this->drop) . ')[^>]*>.*</\\1>#sU', '', $this->parser->html);
 318 |         while ($this->parser->nextNode()) {
 319 |             switch ($this->parser->nodeType) {
 320 |                 case 'doctype':
 321 |                     break;
 322 |                 case 'pi':
 323 |                 case 'comment':
 324 |                     if ($this->keepHTML) {
 325 |                         $this->flushLinebreaks();
 326 |                         $this->out($this->parser->node);
 327 |                         $this->setLineBreaks(2);
 328 |                     }
 329 |                     // else drop
 330 |                     break;
 331 |                 case 'text':
 332 |                     $this->handleText();
 333 |                     break;
 334 |                 case 'tag':
 335 |                     if (in_array($this->parser->tagName, $this->ignore)) {
 336 |                         break;
 337 |                     }
 338 |                     // If the previous tag was not a block element, we simulate a paragraph tag
 339 |                     if ($this->parser->isBlockElement && $this->parser->isNextToInlineContext && !in_array($this->parent(), $this->allowMixedChildren)) {
 340 |                         $this->setLineBreaks(2);
 341 |                     }
 342 |                     if ($this->parser->isStartTag) {
 343 |                         $this->flushLinebreaks();
 344 |                     }
 345 |                     if ($this->skipConversion) {
 346 |                         $this->isMarkdownable(); // update notConverted
 347 |                         $this->handleTagToText();
 348 |                         break;
 349 |                     }
 350 | 
 351 |                     // block elements
 352 |                     if (!$this->parser->keepWhitespace && $this->parser->isBlockElement) {
 353 |                         $this->fixBlockElementSpacing();
 354 |                     }
 355 | 
 356 |                     // inline elements
 357 |                     if (!$this->parser->keepWhitespace && $this->parser->isInlineContext) {
 358 |                         $this->fixInlineElementSpacing();
 359 |                     }
 360 | 
 361 |                     if ($this->isMarkdownable()) {
 362 |                         if ($this->parser->isBlockElement && $this->parser->isStartTag && !$this->lastWasBlockTag && !empty($this->output)) {
 363 |                             if (!empty($this->buffer)) {
 364 |                                 $str =& $this->buffer[count($this->buffer) - 1];
 365 |                             } else {
 366 |                                 $str =& $this->output;
 367 |                             }
 368 |                             if (substr($str, -strlen($this->indent) - 1) != "\n" . $this->indent) {
 369 |                                 $str .= "\n" . $this->indent;
 370 |                             }
 371 |                         }
 372 |                         $func = 'handleTag_' . $this->parser->tagName;
 373 |                         $this->$func();
 374 |                         if ($this->linkPosition == self::LINK_AFTER_PARAGRAPH && $this->parser->isBlockElement && !$this->parser->isStartTag && empty($this->parser->openTags)) {
 375 |                             $this->flushFootnotes();
 376 |                         }
 377 |                         if (!$this->parser->isStartTag) {
 378 |                             $this->lastClosedTag = $this->parser->tagName;
 379 |                         }
 380 |                     } else {
 381 |                         $this->handleTagToText();
 382 |                         $this->lastClosedTag = '';
 383 |                     }
 384 |                     break;
 385 |                 default:
 386 |                     trigger_error('invalid node type', E_USER_ERROR);
 387 |                     break;
 388 |             }
 389 |             $this->lastWasBlockTag = $this->parser->nodeType == 'tag' && $this->parser->isStartTag && $this->parser->isBlockElement;
 390 |         }
 391 |         if (!empty($this->buffer)) {
 392 |             // trigger_error('buffer was not flushed, this is a bug. please report!', E_USER_WARNING);
 393 |             while (!empty($this->buffer)) {
 394 |                 $this->out($this->unbuffer());
 395 |             }
 396 |         }
 397 |         // cleanup
 398 |         $this->output = rtrim(str_replace('&amp;', '&', str_replace('&lt;', '<', str_replace('&gt;', '>', $this->output))));
 399 |         // end parsing, flush stacked tags
 400 |         $this->flushFootnotes();
 401 |         $this->stack = [];
 402 |     }
 403 | 
 404 |     /**
 405 |      * check if current tag can be converted to Markdown
 406 |      *
 407 |      * @param void
 408 |      * @return bool
 409 |      */
 410 |     protected function isMarkdownable()
 411 |     {
 412 |         if (!isset($this->isMarkdownable[$this->parser->tagName])) {
 413 |             // simply not markdownable
 414 | 
 415 |             return false;
 416 |         }
 417 |         if ($this->parser->isStartTag) {
 418 |             $return = true;
 419 |             if ($this->keepHTML) {
 420 |                 $diff = array_diff(array_keys($this->parser->tagAttributes), array_keys($this->isMarkdownable[$this->parser->tagName]));
 421 |                 if (!empty($diff)) {
 422 |                     // non markdownable attributes given
 423 |                     $return = false;
 424 |                 }
 425 |             }
 426 |             if ($return) {
 427 |                 foreach ($this->isMarkdownable[$this->parser->tagName] as $attr => $type) {
 428 |                     if ($type == 'required' && !isset($this->parser->tagAttributes[$attr])) {
 429 |                         // required markdown attribute not given
 430 |                         $return = false;
 431 |                         break;
 432 |                     }
 433 |                 }
 434 |             }
 435 |             if (!$return) {
 436 |                 array_push($this->notConverted, $this->parser->tagName . '::' . implode('/', $this->parser->openTags));
 437 |             }
 438 | 
 439 |             return $return;
 440 |         } else {
 441 |             if (!empty($this->notConverted) && end($this->notConverted) === $this->parser->tagName . '::' . implode('/', $this->parser->openTags)) {
 442 |                 array_pop($this->notConverted);
 443 | 
 444 |                 return false;
 445 |             }
 446 | 
 447 |             return true;
 448 |         }
 449 |     }
 450 | 
 451 |     /**
 452 |      * output footnotes
 453 |      *
 454 |      * @param void
 455 |      * @return void
 456 |      */
 457 |     protected function flushFootnotes()
 458 |     {
 459 |         $out = false;
 460 |         foreach ($this->footnotes as $k => $tag) {
 461 |             if (!isset($tag['unstacked'])) {
 462 |                 if (!$out) {
 463 |                     $out = true;
 464 |                     $this->out("\n\n", true);
 465 |                 } else {
 466 |                     $this->out("\n", true);
 467 |                 }
 468 |                 $this->out(' [' . $tag['linkID'] . ']: ' . $this->getLinkReference($tag), true);
 469 |                 $tag['unstacked'] = true;
 470 |                 $this->footnotes[$k] = $tag;
 471 |             }
 472 |         }
 473 |     }
 474 | 
 475 |     /**
 476 |      * return formated link reference
 477 |      *
 478 |      * @param array $tag
 479 |      * @return string link reference
 480 |      */
 481 |     protected function getLinkReference($tag)
 482 |     {
 483 |         return $tag['href'] . (isset($tag['title']) ? ' "' . $tag['title'] . '"' : '');
 484 |     }
 485 | 
 486 |     /**
 487 |      * flush enqued linebreaks
 488 |      *
 489 |      * @param void
 490 |      * @return void
 491 |      */
 492 |     protected function flushLinebreaks()
 493 |     {
 494 |         if ($this->lineBreaks && !empty($this->output)) {
 495 |             $this->out(str_repeat("\n" . $this->indent, $this->lineBreaks), true);
 496 |         }
 497 |         $this->lineBreaks = 0;
 498 |     }
 499 | 
 500 |     /**
 501 |      * handle non Markdownable tags
 502 |      *
 503 |      * @param void
 504 |      * @return void
 505 |      */
 506 |     protected function handleTagToText()
 507 |     {
 508 |         if (!$this->keepHTML) {
 509 |             if (!$this->parser->isStartTag && $this->parser->isBlockElement) {
 510 |                 $this->setLineBreaks(2);
 511 |             }
 512 |         } else {
 513 |             // don't convert to markdown inside this tag
 514 |             /** TODO: markdown extra **/
 515 |             if (!$this->parser->isEmptyTag) {
 516 |                 if ($this->parser->isStartTag) {
 517 |                     if (!$this->skipConversion) {
 518 |                         $this->skipConversion = $this->parser->tagName . '::' . implode('/', $this->parser->openTags);
 519 |                     }
 520 |                 } else {
 521 |                     if ($this->skipConversion == $this->parser->tagName . '::' . implode('/', $this->parser->openTags)) {
 522 |                         $this->skipConversion = false;
 523 |                     }
 524 |                 }
 525 |             }
 526 | 
 527 |             if ($this->parser->isBlockElement) {
 528 |                 if ($this->parser->isStartTag) {
 529 |                     // looks like ins or del are block elements now
 530 |                     if (in_array($this->parent(), ['ins', 'del'])) {
 531 |                         $this->out("\n", true);
 532 |                         $this->indent('  ');
 533 |                     }
 534 |                     // don't indent inside <pre> tags
 535 |                     if ($this->parser->tagName == 'pre') {
 536 |                         $this->out($this->parser->node);
 537 |                         static $indent;
 538 |                         $indent = $this->indent;
 539 |                         $this->indent = '';
 540 |                     } else {
 541 |                         $this->out($this->parser->node . "\n" . $this->indent);
 542 |                         if (!$this->parser->isEmptyTag) {
 543 |                             $this->indent('  ');
 544 |                         } else {
 545 |                             $this->setLineBreaks(1);
 546 |                         }
 547 |                         $this->parser->html = ltrim($this->parser->html);
 548 |                     }
 549 |                 } else {
 550 |                     if (!$this->parser->keepWhitespace) {
 551 |                         $this->output = rtrim($this->output);
 552 |                     }
 553 |                     if ($this->parser->tagName != 'pre') {
 554 |                         $this->indent('  ');
 555 |                         $this->out("\n" . $this->indent . $this->parser->node);
 556 |                     } else {
 557 |                         // reset indentation
 558 |                         $this->out($this->parser->node);
 559 |                         static $indent;
 560 |                         $this->indent = $indent;
 561 |                     }
 562 | 
 563 |                     if (in_array($this->parent(), ['ins', 'del'])) {
 564 |                         // ins or del was block element
 565 |                         $this->out("\n");
 566 |                         $this->indent('  ');
 567 |                     }
 568 |                     if ($this->parser->tagName == 'li') {
 569 |                         $this->setLineBreaks(1);
 570 |                     } else {
 571 |                         $this->setLineBreaks(2);
 572 |                     }
 573 |                 }
 574 |             } else {
 575 |                 $this->out($this->parser->node);
 576 |             }
 577 |             if (in_array($this->parser->tagName, ['code', 'pre'])) {
 578 |                 if ($this->parser->isStartTag) {
 579 |                     $this->buffer();
 580 |                 } else {
 581 |                     // add stuff so cleanup just reverses this
 582 |                     $this->out(str_replace('&lt;', '&amp;lt;', str_replace('&gt;', '&amp;gt;', $this->unbuffer())));
 583 |                 }
 584 |             }
 585 |         }
 586 |     }
 587 | 
 588 |     /**
 589 |      * handle plain text
 590 |      *
 591 |      * @param void
 592 |      * @return void
 593 |      */
 594 |     protected function handleText()
 595 |     {
 596 |         if ($this->hasParent('pre') && strpos($this->parser->node, "\n") !== false) {
 597 |             $this->parser->node = str_replace("\n", "\n" . $this->indent, $this->parser->node);
 598 |         }
 599 |         if (!$this->hasParent('code') && !$this->hasParent('pre')) {
 600 |             // entity decode
 601 |             $this->parser->node = $this->decode($this->parser->node);
 602 |             if (!$this->skipConversion) {
 603 |                 // escape some chars in normal Text
 604 |                 $this->parser->node = preg_replace($this->escapeInText['search'], $this->escapeInText['replace'], $this->parser->node);
 605 |             }
 606 |         } else {
 607 |             $this->parser->node = str_replace(['&quot;', '&apos'], ['"', '\''], $this->parser->node);
 608 |         }
 609 |         $this->out($this->parser->node);
 610 |         $this->lastClosedTag = '';
 611 |     }
 612 | 
 613 |     /**
 614 |      * handle <em> and <i> tags
 615 |      *
 616 |      * @param void
 617 |      * @return void
 618 |      */
 619 |     protected function handleTag_em()
 620 |     {
 621 |         $this->out('_', true);
 622 |     }
 623 | 
 624 |     protected function handleTag_i()
 625 |     {
 626 |         $this->handleTag_em();
 627 |     }
 628 | 
 629 |     /**
 630 |      * handle <strong> and <b> tags
 631 |      *
 632 |      * @param void
 633 |      * @return void
 634 |      */
 635 |     protected function handleTag_strong()
 636 |     {
 637 |         $this->out('**', true);
 638 |     }
 639 | 
 640 |     protected function handleTag_b()
 641 |     {
 642 |         $this->handleTag_strong();
 643 |     }
 644 | 
 645 |     /**
 646 |      * handle <h1> tags
 647 |      *
 648 |      * @param void
 649 |      * @return void
 650 |      */
 651 |     protected function handleTag_h1()
 652 |     {
 653 |         $this->handleHeader(1);
 654 |     }
 655 | 
 656 |     /**
 657 |      * handle <h2> tags
 658 |      *
 659 |      * @param void
 660 |      * @return void
 661 |      */
 662 |     protected function handleTag_h2()
 663 |     {
 664 |         $this->handleHeader(2);
 665 |     }
 666 | 
 667 |     /**
 668 |      * handle <h3> tags
 669 |      *
 670 |      * @param void
 671 |      * @return void
 672 |      */
 673 |     protected function handleTag_h3()
 674 |     {
 675 |         $this->handleHeader(3);
 676 |     }
 677 | 
 678 |     /**
 679 |      * handle <h4> tags
 680 |      *
 681 |      * @param void
 682 |      * @return void
 683 |      */
 684 |     protected function handleTag_h4()
 685 |     {
 686 |         $this->handleHeader(4);
 687 |     }
 688 | 
 689 |     /**
 690 |      * handle <h5> tags
 691 |      *
 692 |      * @param void
 693 |      * @return void
 694 |      */
 695 |     protected function handleTag_h5()
 696 |     {
 697 |         $this->handleHeader(5);
 698 |     }
 699 | 
 700 |     /**
 701 |      * handle <h6> tags
 702 |      *
 703 |      * @param void
 704 |      * @return void
 705 |      */
 706 |     protected function handleTag_h6()
 707 |     {
 708 |         $this->handleHeader(6);
 709 |     }
 710 | 
 711 |     /**
 712 |      * handle header tags (<h1> - <h6>)
 713 |      *
 714 |      * @param int $level 1-6
 715 |      * @return void
 716 |      */
 717 |     protected function handleHeader($level)
 718 |     {
 719 |         if ($this->parser->isStartTag) {
 720 |             $this->out(str_repeat('#', $level) . ' ', true);
 721 |         } else {
 722 |             $this->setLineBreaks(2);
 723 |         }
 724 |     }
 725 | 
 726 |     /**
 727 |      * handle <p> tags
 728 |      *
 729 |      * @param void
 730 |      * @return void
 731 |      */
 732 |     protected function handleTag_p()
 733 |     {
 734 |         if (!$this->parser->isStartTag) {
 735 |             $this->setLineBreaks(2);
 736 |         }
 737 |     }
 738 | 
 739 |     /**
 740 |      * handle <a> tags
 741 |      *
 742 |      * @param void
 743 |      * @return void
 744 |      */
 745 |     protected function handleTag_a()
 746 |     {
 747 |         if ($this->parser->isStartTag) {
 748 |             $this->buffer();
 749 |             $this->handleTag_a_parser();
 750 |             $this->stack();
 751 |         } else {
 752 |             $tag = $this->unstack();
 753 |             $buffer = $this->unbuffer();
 754 |             $this->handleTag_a_converter($tag, $buffer);
 755 |             $this->out($this->handleTag_a_converter($tag, $buffer), true);
 756 |         }
 757 |     }
 758 | 
 759 |     /**
 760 |      * handle <a> tags parsing
 761 |      *
 762 |      * @param void
 763 |      * @return void
 764 |      */
 765 |     protected function handleTag_a_parser()
 766 |     {
 767 |         if (isset($this->parser->tagAttributes['title'])) {
 768 |             $this->parser->tagAttributes['title'] = $this->decode($this->parser->tagAttributes['title']);
 769 |         } else {
 770 |             $this->parser->tagAttributes['title'] = null;
 771 |         }
 772 |         $this->parser->tagAttributes['href'] = $this->decode(trim($this->parser->tagAttributes['href']));
 773 |     }
 774 | 
 775 |     /**
 776 |      * handle <a> tags conversion
 777 |      *
 778 |      * @param array $tag
 779 |      * @param string $buffer
 780 |      * @return string The markdownified link
 781 |      */
 782 |     protected function handleTag_a_converter($tag, $buffer)
 783 |     {
 784 |         if (empty($tag['href']) && empty($tag['title'])) {
 785 |             // empty links... testcase mania, who would possibly do anything like that?!
 786 |             return '[' . $buffer . ']()';
 787 |         }
 788 | 
 789 |         if ($buffer == $tag['href'] && empty($tag['title'])) {
 790 |             // <http://example.com>
 791 |             return '<' . $buffer . '>';
 792 |         }
 793 | 
 794 |         $bufferDecoded = $this->decode(trim($buffer));
 795 |         if (substr($tag['href'], 0, 7) == 'mailto:' && 'mailto:' . $bufferDecoded == $tag['href']) {
 796 |             if (is_null($tag['title'])) {
 797 |                 // <mail@example.com>
 798 |                 return '<' . $bufferDecoded . '>';
 799 |             }
 800 |             // [mail@example.com][1]
 801 |             // ...
 802 |             //  [1]: mailto:mail@example.com Title
 803 |             $tag['href'] = 'mailto:' . $bufferDecoded;
 804 |         }
 805 | 
 806 |         if ($this->linkPosition == self::LINK_IN_PARAGRAPH) {
 807 |             return '[' . $buffer . '](' . $this->getLinkReference($tag) . ')';
 808 |         }
 809 | 
 810 |         // [This link][id]
 811 |         foreach ($this->footnotes as $tag2) {
 812 |             if ($tag2['href'] == $tag['href'] && $tag2['title'] === $tag['title']) {
 813 |                 $tag['linkID'] = $tag2['linkID'];
 814 |                 break;
 815 |             }
 816 |         }
 817 |         if (!isset($tag['linkID'])) {
 818 |             $tag['linkID'] = count($this->footnotes) + 1;
 819 |             array_push($this->footnotes, $tag);
 820 |         }
 821 | 
 822 |         return '[' . $buffer . '][' . $tag['linkID'] . ']';
 823 |     }
 824 | 
 825 |     /**
 826 |      * handle <img /> tags
 827 |      *
 828 |      * @param void
 829 |      * @return void
 830 |      */
 831 |     protected function handleTag_img()
 832 |     {
 833 |         if (!$this->parser->isStartTag) {
 834 |             return; // just to be sure this is really an empty tag...
 835 |         }
 836 | 
 837 |         if (isset($this->parser->tagAttributes['title'])) {
 838 |             $this->parser->tagAttributes['title'] = $this->decode($this->parser->tagAttributes['title']);
 839 |         } else {
 840 |             $this->parser->tagAttributes['title'] = null;
 841 |         }
 842 |         if (isset($this->parser->tagAttributes['alt'])) {
 843 |             $this->parser->tagAttributes['alt'] = $this->decode($this->parser->tagAttributes['alt']);
 844 |         } else {
 845 |             $this->parser->tagAttributes['alt'] = null;
 846 |         }
 847 | 
 848 |         if (empty($this->parser->tagAttributes['src'])) {
 849 |             // support for "empty" images... dunno if this is really needed
 850 |             // but there are some test cases which do that...
 851 |             if (!empty($this->parser->tagAttributes['title'])) {
 852 |                 $this->parser->tagAttributes['title'] = ' ' . $this->parser->tagAttributes['title'] . ' ';
 853 |             }
 854 |             $this->out('![' . $this->parser->tagAttributes['alt'] . '](' . $this->parser->tagAttributes['title'] . ')', true);
 855 | 
 856 |             return;
 857 |         } else {
 858 |             $this->parser->tagAttributes['src'] = $this->decode($this->parser->tagAttributes['src']);
 859 |         }
 860 | 
 861 |         $out = '![' . $this->parser->tagAttributes['alt'] . ']';
 862 |         if ($this->linkPosition == self::LINK_IN_PARAGRAPH) {
 863 |             $out .= '(' . $this->parser->tagAttributes['src'];
 864 |             if ($this->parser->tagAttributes['title']) {
 865 |                 $out .= ' "' . $this->parser->tagAttributes['title'] . '"';
 866 |             }
 867 |             $out .= ')';
 868 |             $this->out($out, true);
 869 |             return;
 870 |         }
 871 | 
 872 |         // ![This image][id]
 873 |         $link_id = false;
 874 |         if (!empty($this->footnotes)) {
 875 |             foreach ($this->footnotes as $tag) {
 876 |                 if ($tag['href'] == $this->parser->tagAttributes['src']
 877 |                     && $tag['title'] === $this->parser->tagAttributes['title']
 878 |                 ) {
 879 |                     $link_id = $tag['linkID'];
 880 |                     break;
 881 |                 }
 882 |             }
 883 |         }
 884 |         if (!$link_id) {
 885 |             $link_id = count($this->footnotes) + 1;
 886 |             $tag = [
 887 |                 'href' => $this->parser->tagAttributes['src'],
 888 |                 'linkID' => $link_id,
 889 |                 'title' => $this->parser->tagAttributes['title']
 890 |             ];
 891 |             array_push($this->footnotes, $tag);
 892 |         }
 893 |         $out .= '[' . $link_id . ']';
 894 | 
 895 |         $this->out($out, true);
 896 |     }
 897 | 
 898 |     /**
 899 |      * handle <code> tags
 900 |      *
 901 |      * @param void
 902 |      * @return void
 903 |      */
 904 |     protected function handleTag_code()
 905 |     {
 906 |         if ($this->hasParent('pre')) {
 907 |             // ignore code blocks inside <pre>
 908 | 
 909 |             return;
 910 |         }
 911 |         if ($this->parser->isStartTag) {
 912 |             $this->buffer();
 913 |         } else {
 914 |             $buffer = $this->unbuffer();
 915 |             // use as many backticks as needed
 916 |             preg_match_all('#`+#', $buffer, $matches);
 917 |             if (!empty($matches[0])) {
 918 |                 rsort($matches[0]);
 919 | 
 920 |                 $ticks = '`';
 921 |                 while (true) {
 922 |                     if (!in_array($ticks, $matches[0])) {
 923 |                         break;
 924 |                     }
 925 |                     $ticks .= '`';
 926 |                 }
 927 |             } else {
 928 |                 $ticks = '`';
 929 |             }
 930 |             if ($buffer[0] == '`' || substr($buffer, -1) == '`') {
 931 |                 $buffer = ' ' . $buffer . ' ';
 932 |             }
 933 |             $this->out($ticks . $buffer . $ticks, true);
 934 |         }
 935 |     }
 936 | 
 937 |     /**
 938 |      * handle <pre> tags
 939 |      *
 940 |      * @param void
 941 |      * @return void
 942 |      */
 943 |     protected function handleTag_pre()
 944 |     {
 945 |         if ($this->keepHTML && $this->parser->isStartTag) {
 946 |             // check if a simple <code> follows
 947 |             if (!preg_match('#^\s*<code\s*>#Us', $this->parser->html)) {
 948 |                 // this is no standard markdown code block
 949 |                 $this->handleTagToText();
 950 | 
 951 |                 return;
 952 |             }
 953 |         }
 954 |         $this->indent('    ');
 955 |         if (!$this->parser->isStartTag) {
 956 |             $this->setLineBreaks(2);
 957 |         } else {
 958 |             $this->parser->html = ltrim($this->parser->html);
 959 |         }
 960 |     }
 961 | 
 962 |     /**
 963 |      * handle <blockquote> tags
 964 |      *
 965 |      * @param void
 966 |      * @return void
 967 |      */
 968 |     protected function handleTag_blockquote()
 969 |     {
 970 |         $this->indent('> ');
 971 |     }
 972 | 
 973 |     /**
 974 |      * handle <ul> tags
 975 |      *
 976 |      * @param void
 977 |      * @return void
 978 |      */
 979 |     protected function handleTag_ul()
 980 |     {
 981 |         if ($this->parser->isStartTag) {
 982 |             $this->stack();
 983 |             if (!$this->keepHTML && $this->lastClosedTag == $this->parser->tagName) {
 984 |                 $this->out("\n" . $this->indent . '<!-- -->' . "\n" . $this->indent . "\n" . $this->indent);
 985 |             }
 986 |         } else {
 987 |             $this->unstack();
 988 |             if ($this->parent() != 'li' || preg_match('#^\s*(</li\s*>\s*<li\s*>\s*)?<(p|blockquote)\s*>#sU', $this->parser->html)) {
 989 |                 // don't make Markdown add unneeded paragraphs
 990 |                 $this->setLineBreaks(2);
 991 |             }
 992 |         }
 993 |     }
 994 | 
 995 |     /**
 996 |      * handle <ol> tags
 997 |      *
 998 |      * @param void
 999 |      * @return void
1000 |      */
1001 |     protected function handleTag_ol()
1002 |     {
1003 |         // same as above
1004 |         $this->parser->tagAttributes['num'] = 0;
1005 |         $this->handleTag_ul();
1006 |     }
1007 | 
1008 |     /**
1009 |      * handle <li> tags
1010 |      *
1011 |      * @param void
1012 |      * @return void
1013 |      */
1014 |     protected function handleTag_li()
1015 |     {
1016 |         if ($this->parent() == 'ol') {
1017 |             $parent =& $this->getStacked('ol');
1018 |             if ($this->parser->isStartTag) {
1019 |                 $parent['num']++;
1020 |                 $this->out(str_repeat(' ', 3 - strlen($parent['num'])) . $parent['num'] . '. ', true);
1021 |             }
1022 |         } else {
1023 |             if ($this->parser->isStartTag) {
1024 |                 $this->out('  * ', true);
1025 |             }
1026 |         }
1027 |         $this->indent('    ', false);
1028 |         if (!$this->parser->isStartTag) {
1029 |             $this->setLineBreaks(1);
1030 |         }
1031 |     }
1032 | 
1033 |     /**
1034 |      * handle <hr /> tags
1035 |      *
1036 |      * @param void
1037 |      * @return void
1038 |      */
1039 |     protected function handleTag_hr()
1040 |     {
1041 |         if (!$this->parser->isStartTag) {
1042 |             return; // just to be sure this really is an empty tag
1043 |         }
1044 |         $this->out('* * *', true);
1045 |         $this->setLineBreaks(2);
1046 |     }
1047 | 
1048 |     /**
1049 |      * handle <br /> tags
1050 |      *
1051 |      * @param void
1052 |      * @return void
1053 |      */
1054 |     protected function handleTag_br()
1055 |     {
1056 |         $this->out("  \n" . $this->indent, true);
1057 |         $this->parser->html = ltrim($this->parser->html);
1058 |     }
1059 | 
1060 |     /**
1061 |      * add current node to the stack
1062 |      * this only stores the attributes
1063 |      *
1064 |      * @param void
1065 |      * @return void
1066 |      */
1067 |     protected function stack()
1068 |     {
1069 |         if (!isset($this->stack[$this->parser->tagName])) {
1070 |             $this->stack[$this->parser->tagName] = [];
1071 |         }
1072 |         array_push($this->stack[$this->parser->tagName], $this->parser->tagAttributes);
1073 |     }
1074 | 
1075 |     /**
1076 |      * remove current tag from stack
1077 |      *
1078 |      * @param void
1079 |      * @return array
1080 |      */
1081 |     protected function unstack()
1082 |     {
1083 |         if (!isset($this->stack[$this->parser->tagName]) || !is_array($this->stack[$this->parser->tagName])) {
1084 |             trigger_error('Trying to unstack from empty stack. This must not happen.', E_USER_ERROR);
1085 |         }
1086 | 
1087 |         return array_pop($this->stack[$this->parser->tagName]);
1088 |     }
1089 | 
1090 |     /**
1091 |      * get last stacked element of type $tagName
1092 |      *
1093 |      * @param string $tagName
1094 |      * @return array
1095 |      */
1096 |     protected function &getStacked($tagName)
1097 |     {
1098 |         // no end() so it can be referenced
1099 |         return $this->stack[$tagName][count($this->stack[$tagName]) - 1];
1100 |     }
1101 | 
1102 |     /**
1103 |      * set number of line breaks before next start tag
1104 |      *
1105 |      * @param int $number
1106 |      * @return void
1107 |      */
1108 |     protected function setLineBreaks($number)
1109 |     {
1110 |         if ($this->lineBreaks < $number) {
1111 |             $this->lineBreaks = $number;
1112 |         }
1113 |     }
1114 | 
1115 |     /**
1116 |      * buffer next parser output until unbuffer() is called
1117 |      *
1118 |      * @param void
1119 |      * @return void
1120 |      */
1121 |     protected function buffer()
1122 |     {
1123 |         array_push($this->buffer, '');
1124 |     }
1125 | 
1126 |     /**
1127 |      * end current buffer and return buffered output
1128 |      *
1129 |      * @param void
1130 |      * @return string
1131 |      */
1132 |     protected function unbuffer()
1133 |     {
1134 |         return array_pop($this->buffer);
1135 |     }
1136 | 
1137 |     /**
1138 |      * append string to the correct var, either
1139 |      * directly to $this->output or to the current
1140 |      * buffers
1141 |      *
1142 |      * @param string $put
1143 |      * @param boolean $nowrap
1144 |      * @return void
1145 |      */
1146 |     protected function out($put, $nowrap = false)
1147 |     {
1148 |         if (empty($put)) {
1149 |             return;
1150 |         }
1151 |         if (!empty($this->buffer)) {
1152 |             $this->buffer[count($this->buffer) - 1] .= $put;
1153 |         } else {
1154 |             if ($this->bodyWidth && !$this->parser->keepWhitespace) { // wrap lines
1155 |                 // get last line
1156 |                 $pos = strrpos($this->output, "\n");
1157 |                 if ($pos === false) {
1158 |                     $line = $this->output;
1159 |                 } else {
1160 |                     $line = substr($this->output, $pos);
1161 |                 }
1162 | 
1163 |                 if ($nowrap) {
1164 |                     if ($put[0] != "\n" && $this->strlen($line) + $this->strlen($put) > $this->bodyWidth) {
1165 |                         $this->output .= "\n" . $this->indent . $put;
1166 |                     } else {
1167 |                         $this->output .= $put;
1168 |                     }
1169 | 
1170 |                     return;
1171 |                 } else {
1172 |                     $put .= "\n"; // make sure we get all lines in the while below
1173 |                     $lineLen = $this->strlen($line);
1174 |                     while ($pos = strpos($put, "\n")) {
1175 |                         $putLine = substr($put, 0, $pos + 1);
1176 |                         $put = substr($put, $pos + 1);
1177 |                         $putLen = $this->strlen($putLine);
1178 |                         if ($lineLen + $putLen < $this->bodyWidth) {
1179 |                             $this->output .= $putLine;
1180 |                             $lineLen = $putLen;
1181 |                         } else {
1182 |                             $split = preg_split('#^(.{0,' . ($this->bodyWidth - $lineLen) . '})\b#', $putLine, 2, PREG_SPLIT_OFFSET_CAPTURE | PREG_SPLIT_DELIM_CAPTURE);
1183 |                             $this->output .= rtrim($split[1][0]) . "\n" . $this->indent . $this->wordwrap(ltrim($split[2][0]), $this->bodyWidth, "\n" . $this->indent, false);
1184 |                         }
1185 |                     }
1186 |                     $this->output = substr($this->output, 0, -1);
1187 | 
1188 |                     return;
1189 |                 }
1190 |             } else {
1191 |                 $this->output .= $put;
1192 |             }
1193 |         }
1194 |     }
1195 | 
1196 |     /**
1197 |      * indent next output (start tag) or unindent (end tag)
1198 |      *
1199 |      * @param string $str indentation
1200 |      * @param bool $output add indendation to output
1201 |      * @return void
1202 |      */
1203 |     protected function indent($str, $output = true)
1204 |     {
1205 |         if ($this->parser->isStartTag) {
1206 |             $this->indent .= $str;
1207 |             if ($output) {
1208 |                 $this->out($str, true);
1209 |             }
1210 |         } else {
1211 |             $this->indent = substr($this->indent, 0, -strlen($str));
1212 |         }
1213 |     }
1214 | 
1215 |     /**
1216 |      * decode email addresses
1217 |      *
1218 |      * @author derernst@gmx.ch <http://www.php.net/manual/en/function.html-entity-decode.php#68536>
1219 |      * @author Milian Wolff <http://milianw.de>
1220 |      */
1221 |     protected function decode($text)
1222 |     {
1223 |         return htmlspecialchars_decode($text, ENT_QUOTES);
1224 |     }
1225 | 
1226 |     /**
1227 |      * UTF-8 strlen()
1228 |      *
1229 |      * @param string $str
1230 |      * @return int
1231 |      *
1232 |      * @author dtorop 932 at hotmail dot com <http://www.php.net/manual/en/function.strlen.php#37975>
1233 |      * @author Milian Wolff <http://milianw.de>
1234 |      */
1235 |     protected function strlen($str)
1236 |     {
1237 |         if (function_exists('mb_strlen')) {
1238 |             return mb_strlen($str, 'UTF-8');
1239 |         } else {
1240 |             return preg_match_all('/[\x00-\x7F\xC0-\xFD]/', $str, $var_empty);
1241 |         }
1242 |     }
1243 | 
1244 |     /**
1245 |      * wordwrap for utf8 encoded strings
1246 |      *
1247 |      * @param string $str
1248 |      * @param integer $len
1249 |      * @param string $what
1250 |      * @return string
1251 |      */
1252 |     protected function wordwrap($str, $width, $break, $cut = false)
1253 |     {
1254 |         if (!$cut) {
1255 |             $regexp = '#^(?:[\x00-\x7F]|[\xC0-\xFF][\x80-\xBF]+){1,' . $width . '}\b#';
1256 |         } else {
1257 |             $regexp = '#^(?:[\x00-\x7F]|[\xC0-\xFF][\x80-\xBF]+){' . $width . '}#';
1258 |         }
1259 |         $return = '';
1260 |         while (preg_match($regexp, $str, $matches)) {
1261 |             $string = $matches[0];
1262 |             $str = ltrim(substr($str, strlen($string)));
1263 |             if (!$cut && isset($str[0]) && in_array($str[0], ['.', '!', ';', ':', '?', ','])) {
1264 |                 $string .= $str[0];
1265 |                 $str = ltrim(substr($str, 1));
1266 |             }
1267 |             $return .= $string . $break;
1268 |         }
1269 | 
1270 |         return $return . ltrim($str);
1271 |     }
1272 | 
1273 |     /**
1274 |      * check if current node has a $tagName as parent (somewhere, not only the direct parent)
1275 |      *
1276 |      * @param string $tagName
1277 |      * @return bool
1278 |      */
1279 |     protected function hasParent($tagName)
1280 |     {
1281 |         return in_array($tagName, $this->parser->openTags);
1282 |     }
1283 | 
1284 |     /**
1285 |      * get tagName of direct parent tag
1286 |      *
1287 |      * @param void
1288 |      * @return string $tagName
1289 |      */
1290 |     protected function parent()
1291 |     {
1292 |         return end($this->parser->openTags);
1293 |     }
1294 | 
1295 |     /**
1296 |      * Trims whitespace in block-level elements, on the left side.
1297 |      */
1298 |     protected function fixBlockElementSpacing()
1299 |     {
1300 |         if ($this->parser->isStartTag) {
1301 |             $this->parser->html = ltrim($this->parser->html);
1302 |         }
1303 |     }
1304 | 
1305 |     /**
1306 |      * Moves leading/trailing whitespace from inline elements outside of the
1307 |      * element. This is to fix cases like `<strong> Text</strong>`, which if
1308 |      * converted to `** strong**` would be incorrect Markdown.
1309 |      *
1310 |      * Examples:
1311 |      *
1312 |      *   * leading: `<strong> Text</strong>` becomes ` <strong>Text</strong>`
1313 |      *   * trailing: `<strong>Text </strong>` becomes `<strong>Text</strong> `
1314 |      */
1315 |     protected function fixInlineElementSpacing()
1316 |     {
1317 |         if ($this->parser->isStartTag && !$this->parser->isEmptyTag) {
1318 |             // move spaces after the start element to before the element
1319 |             if (preg_match('~^(\s+)~', $this->parser->html, $matches)) {
1320 |                 $this->out($matches[1]);
1321 |                 $this->parser->html = ltrim($this->parser->html, " \t\0\x0B");
1322 |             }
1323 |         } else {
1324 |             if (!empty($this->buffer)) {
1325 |                 $str =& $this->buffer[count($this->buffer) - 1];
1326 |             } else {
1327 |                 $str =& $this->output;
1328 |             }
1329 | 
1330 |             // move spaces before the end element to after the element
1331 |             if (preg_match('~(\s+)$~', $str, $matches)) {
1332 |                 $str = rtrim($str, " \t\0\x0B");
1333 |                 $this->parser->html = $matches[1] . $this->parser->html;
1334 |             }
1335 |         }
1336 |     }
1337 | 
1338 |     /**
1339 |      * Resetting the state forces the instance to behave as a fresh instance.
1340 |      * Ideal for running within a loop where you want to maintain a single instance.
1341 |      */
1342 |     protected function resetState()
1343 |     {
1344 |         $this->notConverted = [];
1345 |         $this->skipConversion = false;
1346 |         $this->buffer = [];
1347 |         $this->indent = '';
1348 |         $this->stack = [];
1349 |         $this->lineBreaks = 0;
1350 |         $this->lastClosedTag = '';
1351 |         $this->lastWasBlockTag = false;
1352 |         $this->footnotes = [];
1353 |     }
1354 | }
1355 | 


--------------------------------------------------------------------------------
/src/ConverterExtra.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Markdownify;
  4 | 
  5 | class ConverterExtra extends Converter
  6 | {
  7 | 
  8 |     /**
  9 |      * table data, including rows with content and the maximum width of each col
 10 |      *
 11 |      * @var array
 12 |      */
 13 |     protected $table = [];
 14 | 
 15 |     /**
 16 |      * current col
 17 |      *
 18 |      * @var int
 19 |      */
 20 |     protected $col = -1;
 21 | 
 22 |     /**
 23 |      * current row
 24 |      *
 25 |      * @var int
 26 |      */
 27 |     protected $row = 0;
 28 | 
 29 |     /**
 30 |      * constructor, see Markdownify::Markdownify() for more information
 31 |      */
 32 |     public function __construct($linksAfterEachParagraph = self::LINK_AFTER_CONTENT, $bodyWidth = MDFY_BODYWIDTH, $keepHTML = MDFY_KEEPHTML)
 33 |     {
 34 |         parent::__construct($linksAfterEachParagraph, $bodyWidth, $keepHTML);
 35 | 
 36 |         // new markdownable tags & attributes
 37 |         // header ids: # foo {bar}
 38 |         $this->isMarkdownable['h1']['id'] = 'optional';
 39 |         $this->isMarkdownable['h1']['class'] = 'optional';
 40 |         $this->isMarkdownable['h2']['id'] = 'optional';
 41 |         $this->isMarkdownable['h2']['class'] = 'optional';
 42 |         $this->isMarkdownable['h3']['id'] = 'optional';
 43 |         $this->isMarkdownable['h3']['class'] = 'optional';
 44 |         $this->isMarkdownable['h4']['id'] = 'optional';
 45 |         $this->isMarkdownable['h4']['class'] = 'optional';
 46 |         $this->isMarkdownable['h5']['id'] = 'optional';
 47 |         $this->isMarkdownable['h5']['class'] = 'optional';
 48 |         $this->isMarkdownable['h6']['id'] = 'optional';
 49 |         $this->isMarkdownable['h6']['class'] = 'optional';
 50 |         // tables
 51 |         $this->isMarkdownable['table'] = [];
 52 |         $this->isMarkdownable['th'] = [
 53 |             'align' => 'optional',
 54 |         ];
 55 |         $this->isMarkdownable['td'] = [
 56 |             'align' => 'optional',
 57 |         ];
 58 |         $this->isMarkdownable['tr'] = [];
 59 |         array_push($this->ignore, 'thead');
 60 |         array_push($this->ignore, 'tbody');
 61 |         array_push($this->ignore, 'tfoot');
 62 |         // definition lists
 63 |         $this->isMarkdownable['dl'] = [];
 64 |         $this->isMarkdownable['dd'] = [];
 65 |         $this->isMarkdownable['dt'] = [];
 66 |         // link class
 67 |         $this->isMarkdownable['a']['id'] = 'optional';
 68 |         $this->isMarkdownable['a']['class'] = 'optional';
 69 |         // footnotes
 70 |         $this->isMarkdownable['fnref'] = [
 71 |             'target' => 'required',
 72 |         ];
 73 |         $this->isMarkdownable['footnotes'] = [];
 74 |         $this->isMarkdownable['fn'] = [
 75 |             'name' => 'required',
 76 |         ];
 77 |         $this->parser->blockElements['fnref'] = false;
 78 |         $this->parser->blockElements['fn'] = true;
 79 |         $this->parser->blockElements['footnotes'] = true;
 80 |         // abbr
 81 |         $this->isMarkdownable['abbr'] = [
 82 |             'title' => 'required',
 83 |         ];
 84 |         // build RegEx lookahead to decide wether table can pe parsed or not
 85 |         $inlineTags = array_keys($this->parser->blockElements, false);
 86 |         $colContents = '(?:[^<]|<(?:' . implode('|', $inlineTags) . '|[^a-z]))*';
 87 |         $this->tableLookaheadHeader = '{
 88 |     ^\s*(?:<thead\s*>)?\s*                                  # open optional thead
 89 |       <tr\s*>\s*(?:                                         # start required row with headers
 90 |         <th(?:\s+align=("|\')(?:left|center|right)\1)?\s*>  # header with optional align
 91 |         \s*' . $colContents . '\s*                              # contents
 92 |         </th>\s*                                            # close header
 93 |       )+</tr>                                               # close row with headers
 94 |     \s*(?:</thead>)?                                        # close optional thead
 95 |     }sxi';
 96 |         $this->tdSubstitute = '\s*' . $colContents . '\s*           # contents
 97 |           </td>\s*';
 98 |         $this->tableLookaheadBody = '{
 99 |       \s*(?:<tbody\s*>)?\s*                                 # open optional tbody
100 |         (?:<tr\s*>\s*                                       # start row
101 |           %s                                                # cols to be substituted
102 |         </tr>)+                                             # close row
103 |       \s*(?:</tbody>)?                                      # close optional tbody
104 |     \s*</table>                                             # close table
105 |     }sxi';
106 |     }
107 | 
108 |     /**
109 |      * handle header tags (<h1> - <h6>)
110 |      *
111 |      * @param int $level 1-6
112 |      * @return void
113 |      */
114 |     protected function handleHeader($level)
115 |     {
116 |         if ($this->parser->isStartTag) {
117 |             $this->parser->tagAttributes['cssSelector'] = $this->getCurrentCssSelector();
118 |             $this->stack();
119 |         } else {
120 |             $tag = $this->unstack();
121 |             if (!empty($tag['cssSelector'])) {
122 |                 // {#id.class}
123 |                 $this->out(' {' . $tag['cssSelector'] . '}');
124 |             }
125 |         }
126 |         parent::handleHeader($level);
127 |     }
128 | 
129 |     /**
130 |      * handle <a> tags parsing
131 |      *
132 |      * @param void
133 |      * @return void
134 |      */
135 |     protected function handleTag_a_parser()
136 |     {
137 |         parent::handleTag_a_parser();
138 |         $this->parser->tagAttributes['cssSelector'] = $this->getCurrentCssSelector();
139 |     }
140 | 
141 |     /**
142 |      * handle <a> tags conversion
143 |      *
144 |      * @param array $tag
145 |      * @param string $buffer
146 |      * @return string The markdownified link
147 |      */
148 |     protected function handleTag_a_converter($tag, $buffer)
149 |     {
150 |         $output = parent::handleTag_a_converter($tag, $buffer);
151 |         if (!empty($tag['cssSelector'])) {
152 |             // [This link][id]{#id.class}
153 |             $output .= '{' . $tag['cssSelector'] . '}';
154 |         }
155 | 
156 |         return $output;
157 |     }
158 | 
159 |     /**
160 |      * handle <abbr> tags
161 |      *
162 |      * @param void
163 |      * @return void
164 |      */
165 |     protected function handleTag_abbr()
166 |     {
167 |         if ($this->parser->isStartTag) {
168 |             $this->stack();
169 |             $this->buffer();
170 |         } else {
171 |             $tag = $this->unstack();
172 |             $tag['text'] = $this->unbuffer();
173 |             $add = true;
174 |             foreach ($this->stack['abbr'] as $stacked) {
175 |                 if ($stacked['text'] == $tag['text']) {
176 |                     /** TODO: differing abbr definitions, i.e. different titles for same text **/
177 |                     $add = false;
178 |                     break;
179 |                 }
180 |             }
181 |             $this->out($tag['text']);
182 |             if ($add) {
183 |                 array_push($this->stack['abbr'], $tag);
184 |             }
185 |         }
186 |     }
187 | 
188 |     /**
189 |      * flush stacked abbr tags
190 |      *
191 |      * @param void
192 |      * @return void
193 |      */
194 |     protected function flushStacked_abbr()
195 |     {
196 |         $out = [];
197 |         foreach ($this->stack['abbr'] as $k => $tag) {
198 |             if (!isset($tag['unstacked'])) {
199 |                 array_push($out, ' *[' . $tag['text'] . ']: ' . $tag['title']);
200 |                 $tag['unstacked'] = true;
201 |                 $this->stack['abbr'][$k] = $tag;
202 |             }
203 |         }
204 |         if (!empty($out)) {
205 |             $this->out("\n\n" . implode("\n", $out));
206 |         }
207 |     }
208 | 
209 |     /**
210 |      * handle <table> tags
211 |      *
212 |      * @param void
213 |      * @return void
214 |      */
215 |     protected function handleTag_table()
216 |     {
217 |         if ($this->parser->isStartTag) {
218 |             // check if upcoming table can be converted
219 |             if ($this->keepHTML) {
220 |                 if (preg_match($this->tableLookaheadHeader, $this->parser->html, $matches)) {
221 |                     // header seems good, now check body
222 |                     // get align & number of cols
223 |                     preg_match_all('#<th(?:\s+align=("|\')(left|right|center)\1)?\s*>#si', $matches[0], $cols);
224 |                     $regEx = '';
225 |                     $i = 1;
226 |                     $aligns = [];
227 |                     foreach ($cols[2] as $align) {
228 |                         $align = strtolower($align);
229 |                         array_push($aligns, $align);
230 |                         if (empty($align)) {
231 |                             $align = 'left'; // default value
232 |                         }
233 |                         $td = '\s+align=("|\')' . $align . '\\' . $i;
234 |                         $i++;
235 |                         if ($align == 'left') {
236 |                             // look for empty align or left
237 |                             $td = '(?:' . $td . ')?';
238 |                         }
239 |                         $td = '<td' . $td . '\s*>';
240 |                         $regEx .= $td . $this->tdSubstitute;
241 |                     }
242 |                     $regEx = sprintf($this->tableLookaheadBody, $regEx);
243 |                     if (preg_match($regEx, $this->parser->html, $matches, null, strlen($matches[0]))) {
244 |                         // this is a markdownable table tag!
245 |                         $this->table = [
246 |                             'rows' => [],
247 |                             'col_widths' => [],
248 |                             'aligns' => $aligns,
249 |                         ];
250 |                         $this->row = 0;
251 |                     } else {
252 |                         // non markdownable table
253 |                         $this->handleTagToText();
254 |                     }
255 |                 } else {
256 |                     // non markdownable table
257 |                     $this->handleTagToText();
258 |                 }
259 |             } else {
260 |                 $this->table = [
261 |                     'rows' => [],
262 |                     'col_widths' => [],
263 |                     'aligns' => [],
264 |                 ];
265 |                 $this->row = 0;
266 |             }
267 |         } else {
268 |             // finally build the table in Markdown Extra syntax
269 |             $separator = [];
270 |             if (!isset($this->table['aligns'])) {
271 |                 $this->table['aligns'] = [];
272 |             }
273 |             // seperator with correct align identifiers
274 |             foreach ($this->table['aligns'] as $col => $align) {
275 |                 if (!$this->keepHTML && !isset($this->table['col_widths'][$col])) {
276 |                     break;
277 |                 }
278 |                 $left = ' ';
279 |                 $right = ' ';
280 |                 switch ($align) {
281 |                     case 'left':
282 |                         $left = ':';
283 |                         break;
284 |                     case 'center':
285 |                         $right = ':';
286 |                         $left = ':';
287 |                     case 'right':
288 |                         $right = ':';
289 |                         break;
290 |                 }
291 |                 array_push($separator, $left . str_repeat('-', $this->table['col_widths'][$col]) . $right);
292 |             }
293 |             $separator = '|' . implode('|', $separator) . '|';
294 | 
295 |             $rows = [];
296 |             // add padding
297 |             array_walk_recursive($this->table['rows'], [&$this, 'alignTdContent']);
298 |             $header = array_shift($this->table['rows']);
299 |             array_push($rows, '| ' . implode(' | ', $header) . ' |');
300 |             array_push($rows, $separator);
301 |             foreach ($this->table['rows'] as $row) {
302 |                 array_push($rows, '| ' . implode(' | ', $row) . ' |');
303 |             }
304 |             $this->out(implode("\n" . $this->indent, $rows));
305 |             $this->table = [];
306 |             $this->setLineBreaks(2);
307 |         }
308 |     }
309 | 
310 |     /**
311 |      * properly pad content so it is aligned as whished
312 |      * should be used with array_walk_recursive on $this->table['rows']
313 |      *
314 |      * @param string &$content
315 |      * @param int $col
316 |      * @return void
317 |      */
318 |     protected function alignTdContent(&$content, $col)
319 |     {
320 |         if (!isset($this->table['aligns'][$col])) {
321 |             $this->table['aligns'][$col] = 'left';
322 |         }
323 |         switch ($this->table['aligns'][$col]) {
324 |             default:
325 |             case 'left':
326 |                 $content .= str_repeat(' ', $this->table['col_widths'][$col] - $this->strlen($content));
327 |                 break;
328 |             case 'right':
329 |                 $content = str_repeat(' ', $this->table['col_widths'][$col] - $this->strlen($content)) . $content;
330 |                 break;
331 |             case 'center':
332 |                 $paddingNeeded = $this->table['col_widths'][$col] - $this->strlen($content);
333 |                 $left = floor($paddingNeeded / 2);
334 |                 $right = $paddingNeeded - $left;
335 |                 $content = str_repeat(' ', $left) . $content . str_repeat(' ', $right);
336 |                 break;
337 |         }
338 |     }
339 | 
340 |     /**
341 |      * handle <tr> tags
342 |      *
343 |      * @param void
344 |      * @return void
345 |      */
346 |     protected function handleTag_tr()
347 |     {
348 |         if ($this->parser->isStartTag) {
349 |             $this->col = -1;
350 |         } else {
351 |             $this->row++;
352 |         }
353 |     }
354 | 
355 |     /**
356 |      * handle <td> tags
357 |      *
358 |      * @param void
359 |      * @return void
360 |      */
361 |     protected function handleTag_td()
362 |     {
363 |         if ($this->parser->isStartTag) {
364 |             $this->col++;
365 |             if (!isset($this->table['col_widths'][$this->col])) {
366 |                 $this->table['col_widths'][$this->col] = 0;
367 |             }
368 |             $this->buffer();
369 |         } else {
370 |             $buffer = trim($this->unbuffer());
371 |             if (!isset($this->table['col_widths'][$this->col])) {
372 |                 $this->table['col_widths'][$this->col] = 0;
373 |             }
374 |             $this->table['col_widths'][$this->col] = max($this->table['col_widths'][$this->col], $this->strlen($buffer));
375 |             $this->table['rows'][$this->row][$this->col] = $buffer;
376 |         }
377 |     }
378 | 
379 |     /**
380 |      * handle <th> tags
381 |      *
382 |      * @param void
383 |      * @return void
384 |      */
385 |     protected function handleTag_th()
386 |     {
387 |         if (!$this->keepHTML && !isset($this->table['rows'][1]) && !isset($this->table['aligns'][$this->col + 1])) {
388 |             if (isset($this->parser->tagAttributes['align'])) {
389 |                 $this->table['aligns'][$this->col + 1] = $this->parser->tagAttributes['align'];
390 |             } else {
391 |                 $this->table['aligns'][$this->col + 1] = '';
392 |             }
393 |         }
394 |         $this->handleTag_td();
395 |     }
396 | 
397 |     /**
398 |      * handle <dl> tags
399 |      *
400 |      * @param void
401 |      * @return void
402 |      */
403 |     protected function handleTag_dl()
404 |     {
405 |         if (!$this->parser->isStartTag) {
406 |             $this->setLineBreaks(2);
407 |         }
408 |     }
409 | 
410 |     /**
411 |      * handle <dt> tags
412 |      *
413 |      * @param void
414 |      * @return void
415 |      **/
416 |     protected function handleTag_dt()
417 |     {
418 |         if (!$this->parser->isStartTag) {
419 |             $this->setLineBreaks(1);
420 |         }
421 |     }
422 | 
423 |     /**
424 |      * handle <dd> tags
425 |      *
426 |      * @param void
427 |      * @return void
428 |      */
429 |     protected function handleTag_dd()
430 |     {
431 |         if ($this->parser->isStartTag) {
432 |             if (substr(ltrim($this->parser->html), 0, 3) == '<p>') {
433 |                 // next comes a paragraph, so we'll need an extra line
434 |                 $this->out("\n" . $this->indent);
435 |             } elseif (substr($this->output, -2) == "\n\n") {
436 |                 $this->output = substr($this->output, 0, -1);
437 |             }
438 |             $this->out(':   ');
439 |             $this->indent('    ', false);
440 |         } else {
441 |             // lookahead for next dt
442 |             if (substr(ltrim($this->parser->html), 0, 4) == '<dt>') {
443 |                 $this->setLineBreaks(2);
444 |             } else {
445 |                 $this->setLineBreaks(1);
446 |             }
447 |             $this->indent('    ');
448 |         }
449 |     }
450 | 
451 |     /**
452 |      * handle <fnref /> tags (custom footnote references, see markdownify_extra::parseString())
453 |      *
454 |      * @param void
455 |      * @return void
456 |      */
457 |     protected function handleTag_fnref()
458 |     {
459 |         $this->out('[^' . $this->parser->tagAttributes['target'] . ']');
460 |     }
461 | 
462 |     /**
463 |      * handle <fn> tags (custom footnotes, see markdownify_extra::parseString()
464 |      * and markdownify_extra::_makeFootnotes())
465 |      *
466 |      * @param void
467 |      * @return void
468 |      */
469 |     protected function handleTag_fn()
470 |     {
471 |         if ($this->parser->isStartTag) {
472 |             $this->out('[^' . $this->parser->tagAttributes['name'] . ']:');
473 |             $this->setLineBreaks(1);
474 |         } else {
475 |             $this->setLineBreaks(2);
476 |         }
477 |         $this->indent('    ');
478 |     }
479 | 
480 |     /**
481 |      * handle <footnotes> tag (custom footnotes, see markdownify_extra::parseString()
482 |      *  and markdownify_extra::_makeFootnotes())
483 |      *
484 |      * @param void
485 |      * @return void
486 |      */
487 |     protected function handleTag_footnotes()
488 |     {
489 |         if (!$this->parser->isStartTag) {
490 |             $this->setLineBreaks(2);
491 |         }
492 |     }
493 | 
494 |     /**
495 |      * parse a HTML string, clean up footnotes prior
496 |      *
497 |      * @param string $HTML input
498 |      * @return string Markdown formatted output
499 |      */
500 |     public function parseString($html)
501 |     {
502 |         /** TODO: custom markdown-extra options, e.g. titles & classes **/
503 |         // <sup id="fnref:..."><a href"#fn..." rel="footnote">...</a></sup>
504 |         // => <fnref target="..." />
505 |         $html = preg_replace('@<sup id="fnref:([^"]+)">\s*<a href="#fn:\1" rel="footnote">\s*\d+\s*</a>\s*</sup>@Us', '<fnref target="$1" />', $html);
506 |         // <div class="footnotes">
507 |         // <hr />
508 |         // <ol>
509 |         //
510 |         // <li id="fn:...">...</li>
511 |         // ...
512 |         //
513 |         // </ol>
514 |         // </div>
515 |         // =>
516 |         // <footnotes>
517 |         //   <fn name="...">...</fn>
518 |         //   ...
519 |         // </footnotes>
520 |         $html = preg_replace_callback('#<div class="footnotes">\s*<hr />\s*<ol>\s*(.+)\s*</ol>\s*</div>#Us', [&$this, '_makeFootnotes'], $html);
521 | 
522 |         return parent::parseString($html);
523 |     }
524 | 
525 |     /**
526 |      * replace HTML representation of footnotes with something more easily parsable
527 |      *
528 |      * @note this is a callback to be used in parseString()
529 |      *
530 |      * @param array $matches
531 |      * @return string
532 |      */
533 |     protected function _makeFootnotes($matches)
534 |     {
535 |         // <li id="fn:1">
536 |         //   ...
537 |         //   <a href="#fnref:block" rev="footnote">&#8617;</a></p>
538 |         // </li>
539 |         // => <fn name="1">...</fn>
540 |         // remove footnote link
541 |         $fns = preg_replace('@\s*(&#160;\s*)?<a href="#fnref:[^"]+" rev="footnote"[^>]*>&#8617;</a>\s*@s', '', $matches[1]);
542 |         // remove empty paragraph
543 |         $fns = preg_replace('@<p>\s*</p>@s', '', $fns);
544 |         // <li id="fn:1">...</li> -> <footnote nr="1">...</footnote>
545 |         $fns = str_replace('<li id="fn:', '<fn name="', $fns);
546 | 
547 |         $fns = '<footnotes>' . $fns . '</footnotes>';
548 | 
549 |         return preg_replace('#</li>\s*(?=(?:<fn|</footnotes>))#s', '</fn>$1', $fns);
550 |     }
551 | 
552 |     /**
553 |      * handle <a> tags parsing
554 |      *
555 |      * @param void
556 |      * @return void
557 |      */
558 |     protected function getCurrentCssSelector()
559 |     {
560 |         $cssSelector = '';
561 |         if (isset($this->parser->tagAttributes['id'])) {
562 |             $cssSelector .= '#' . $this->decode($this->parser->tagAttributes['id']);
563 |         }
564 |         if (isset($this->parser->tagAttributes['class'])) {
565 |             $classes = explode(' ', $this->decode($this->parser->tagAttributes['class']));
566 |             $classes = array_filter($classes);
567 |             $cssSelector .= '.' . join('.', $classes);
568 |         }
569 |         return $cssSelector;
570 |     }
571 | }
572 | 


--------------------------------------------------------------------------------
/src/Parser.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Markdownify;
  4 | 
  5 | class Parser
  6 | {
  7 |     public static $skipWhitespace = true;
  8 |     public static $a_ord;
  9 |     public static $z_ord;
 10 |     public static $special_ords;
 11 | 
 12 |     /**
 13 |      * tags which are always empty (<br /> etc.)
 14 |      *
 15 |      * @var array<string>
 16 |      */
 17 |     public $emptyTags = [
 18 |         'br',
 19 |         'hr',
 20 |         'input',
 21 |         'img',
 22 |         'area',
 23 |         'link',
 24 |         'meta',
 25 |         'param',
 26 |     ];
 27 | 
 28 |     /**
 29 |      * tags with preformatted text
 30 |      * whitespaces wont be touched in them
 31 |      *
 32 |      * @var array<string>
 33 |      */
 34 |     public $preformattedTags = [
 35 |         'script',
 36 |         'style',
 37 |         'pre',
 38 |         'code',
 39 |     ];
 40 | 
 41 |     /**
 42 |      * supress HTML tags inside preformatted tags (see above)
 43 |      *
 44 |      * @var bool
 45 |      */
 46 |     public $noTagsInCode = false;
 47 | 
 48 |     /**
 49 |      * html to be parsed
 50 |      *
 51 |      * @var string
 52 |      */
 53 |     public $html = '';
 54 | 
 55 |     /**
 56 |      * node type:
 57 |      *
 58 |      * - tag (see isStartTag)
 59 |      * - text (includes cdata)
 60 |      * - comment
 61 |      * - doctype
 62 |      * - pi (processing instruction)
 63 |      *
 64 |      * @var string
 65 |      */
 66 |     public $nodeType = '';
 67 | 
 68 |     /**
 69 |      * current node content, i.e. either a
 70 |      * simple string (text node), or something like
 71 |      * <tag attrib="value"...>
 72 |      *
 73 |      * @var string
 74 |      */
 75 |     public $node = '';
 76 | 
 77 |     /**
 78 |      * wether current node is an opening tag (<a>) or not (</a>)
 79 |      * set to NULL if current node is not a tag
 80 |      * NOTE: empty tags (<br />) set this to true as well!
 81 |      *
 82 |      * @var bool | null
 83 |      */
 84 |     public $isStartTag = null;
 85 | 
 86 |     /**
 87 |      * wether current node is an empty tag (<br />) or not (<a></a>)
 88 |      *
 89 |      * @var bool | null
 90 |      */
 91 |     public $isEmptyTag = null;
 92 | 
 93 |     /**
 94 |      * tag name
 95 |      *
 96 |      * @var string | null
 97 |      */
 98 |     public $tagName = '';
 99 | 
100 |     /**
101 |      * attributes of current tag
102 |      *
103 |      * @var array (attribName=>value) | null
104 |      */
105 |     public $tagAttributes = null;
106 | 
107 |     /**
108 |      * whether or not the actual context is a inline context
109 |      *
110 |      * @var bool | null
111 |      */
112 |     public $isInlineContext = null;
113 | 
114 |     /**
115 |      * whether the current tag is a block element
116 |      *
117 |      * @var bool | null
118 |      */
119 |     public $isBlockElement = null;
120 | 
121 |     /**
122 |      * whether the previous tag (browser) is a block element
123 |      *
124 |      * @var bool | null
125 |      */
126 |     public $isNextToInlineContext = null;
127 | 
128 |     /**
129 |      * keep whitespace
130 |      *
131 |      * @var int
132 |      */
133 |     public $keepWhitespace = 0;
134 | 
135 |     /**
136 |      * list of open tags
137 |      * count this to get current depth
138 |      *
139 |      * @var array
140 |      */
141 |     public $openTags = [];
142 | 
143 |     /**
144 |      * list of block elements
145 |      *
146 |      * @var array
147 |      * TODO: what shall we do with <del> and <ins> ?!
148 |      */
149 |     public $blockElements = [
150 |         // tag name => <bool> is block
151 |         // block elements
152 |         'address' => true,
153 |         'aside' => true,
154 |         'blockquote' => true,
155 |         'center' => true,
156 |         'del' => true,
157 |         'dir' => true,
158 |         'div' => true,
159 |         'dl' => true,
160 |         'fieldset' => true,
161 |         'form' => true,
162 |         'h1' => true,
163 |         'h2' => true,
164 |         'h3' => true,
165 |         'h4' => true,
166 |         'h5' => true,
167 |         'h6' => true,
168 |         'hr' => true,
169 |         'ins' => true,
170 |         'isindex' => true,
171 |         'menu' => true,
172 |         'noframes' => true,
173 |         'noscript' => true,
174 |         'ol' => true,
175 |         'p' => true,
176 |         'pre' => true,
177 |         'table' => true,
178 |         'ul' => true,
179 |         // set table elements and list items to block as well
180 |         'thead' => true,
181 |         'tbody' => true,
182 |         'tfoot' => true,
183 |         'td' => true,
184 |         'tr' => true,
185 |         'th' => true,
186 |         'li' => true,
187 |         'dd' => true,
188 |         'dt' => true,
189 |         // header items and html / body as well
190 |         'html' => true,
191 |         'body' => true,
192 |         'head' => true,
193 |         'meta' => true,
194 |         'link' => true,
195 |         'style' => true,
196 |         'title' => true,
197 |         // unfancy media tags, when indented should be rendered as block
198 |         'map' => true,
199 |         'object' => true,
200 |         'param' => true,
201 |         'embed' => true,
202 |         'area' => true,
203 |         // inline elements
204 |         'a' => false,
205 |         'abbr' => false,
206 |         'acronym' => false,
207 |         'applet' => false,
208 |         'b' => false,
209 |         'basefont' => false,
210 |         'bdo' => false,
211 |         'big' => false,
212 |         'br' => false,
213 |         'button' => false,
214 |         'cite' => false,
215 |         'code' => false,
216 |         'del' => false,
217 |         'dfn' => false,
218 |         'em' => false,
219 |         'font' => false,
220 |         'i' => false,
221 |         'img' => false,
222 |         'ins' => false,
223 |         'input' => false,
224 |         'iframe' => false,
225 |         'kbd' => false,
226 |         'label' => false,
227 |         'q' => false,
228 |         'samp' => false,
229 |         'script' => false,
230 |         'select' => false,
231 |         'small' => false,
232 |         'span' => false,
233 |         'strong' => false,
234 |         'sub' => false,
235 |         'sup' => false,
236 |         'textarea' => false,
237 |         'tt' => false,
238 |         'u' => false,
239 |         'var' => false,
240 |     ];
241 | 
242 |     /**
243 |      * get next node, set $this->html prior!
244 |      *
245 |      * @param void
246 |      * @return bool
247 |      */
248 |     public function nextNode()
249 |     {
250 |         if (empty($this->html)) {
251 |             // we are done with parsing the html string
252 | 
253 |             return false;
254 |         }
255 | 
256 |         if ($this->isStartTag && !$this->isEmptyTag) {
257 |             array_push($this->openTags, $this->tagName);
258 |             if (in_array($this->tagName, $this->preformattedTags)) {
259 |                 // don't truncate whitespaces for <code> or <pre> contents
260 |                 $this->keepWhitespace++;
261 |             }
262 |         }
263 | 
264 |         if ($this->html[0] == '<') {
265 |             $token = substr($this->html, 0, 9);
266 |             if (substr($token, 0, 2) == '<?') {
267 |                 // xml prolog or other pi's
268 |                 /** TODO **/
269 |                 // trigger_error('this might need some work', E_USER_NOTICE);
270 |                 $pos = strpos($this->html, '>');
271 |                 $this->setNode('pi', $pos + 1);
272 | 
273 |                 return true;
274 |             }
275 |             if (substr($token, 0, 4) == '<!--') {
276 |                 // comment
277 |                 $pos = strpos($this->html, '-->');
278 |                 if ($pos === false) {
279 |                     // could not find a closing -->, use next gt instead
280 |                     // this is firefox' behaviour
281 |                     $pos = strpos($this->html, '>') + 1;
282 |                 } else {
283 |                     $pos += 3;
284 |                 }
285 |                 $this->setNode('comment', $pos);
286 | 
287 |                 static::$skipWhitespace = true;
288 | 
289 |                 return true;
290 |             }
291 |             if ($token == '<!DOCTYPE') {
292 |                 // doctype
293 |                 $this->setNode('doctype', strpos($this->html, '>') + 1);
294 | 
295 |                 static::$skipWhitespace = true;
296 | 
297 |                 return true;
298 |             }
299 |             if ($token == '<![CDATA[') {
300 |                 // cdata, use text node
301 | 
302 |                 // remove leading <![CDATA[
303 |                 $this->html = substr($this->html, 9);
304 | 
305 |                 $this->setNode('text', strpos($this->html, ']]>') + 3);
306 | 
307 |                 // remove trailing ]]> and trim
308 |                 $this->node = substr($this->node, 0, -3);
309 |                 $this->handleWhitespaces();
310 | 
311 |                 static::$skipWhitespace = true;
312 | 
313 |                 return true;
314 |             }
315 |             if ($this->parseTag()) {
316 |                 // seems to be a tag
317 |                 // handle whitespaces
318 |                 if ($this->isBlockElement) {
319 |                     static::$skipWhitespace = true;
320 |                 } else {
321 |                     static::$skipWhitespace = false;
322 |                 }
323 | 
324 |                 return true;
325 |             }
326 |         }
327 |         if ($this->keepWhitespace) {
328 |             static::$skipWhitespace = false;
329 |         }
330 |         // when we get here it seems to be a text node
331 |         $pos = strpos($this->html, '<');
332 |         if ($pos === false) {
333 |             $pos = strlen($this->html);
334 |         }
335 |         $this->setNode('text', $pos);
336 |         $this->handleWhitespaces();
337 |         if (static::$skipWhitespace && $this->node == ' ') {
338 |             return $this->nextNode();
339 |         }
340 |         $this->isInlineContext = true;
341 |         static::$skipWhitespace = false;
342 | 
343 |         return true;
344 |     }
345 | 
346 |     /**
347 |      * parse tag, set tag name and attributes, see if it's a closing tag and so forth...
348 |      *
349 |      * @param void
350 |      * @return bool
351 |      */
352 |     protected function parseTag()
353 |     {
354 |         if (!isset(static::$a_ord)) {
355 |             static::$a_ord = ord('a');
356 |             static::$z_ord = ord('z');
357 |             static::$special_ords = [
358 |                 ord(':'), // for xml:lang
359 |                 ord('-'), // for http-equiv
360 |             ];
361 |         }
362 | 
363 |         $tagName = '';
364 | 
365 |         $pos = 1;
366 |         $isStartTag = $this->html[$pos] != '/';
367 |         if (!$isStartTag) {
368 |             $pos++;
369 |         }
370 |         // get tagName
371 |         while (isset($this->html[$pos])) {
372 |             $pos_ord = ord(strtolower($this->html[$pos]));
373 |             if (($pos_ord >= static::$a_ord && $pos_ord <= static::$z_ord) || (!empty($tagName) && is_numeric($this->html[$pos]))) {
374 |                 $tagName .= $this->html[$pos];
375 |                 $pos++;
376 |             } else {
377 |                 $pos--;
378 |                 break;
379 |             }
380 |         }
381 | 
382 |         $tagName = strtolower($tagName);
383 |         if (empty($tagName) || !isset($this->blockElements[$tagName])) {
384 |             // something went wrong => invalid tag
385 |             $this->invalidTag();
386 | 
387 |             return false;
388 |         }
389 |         if ($this->noTagsInCode && end($this->openTags) == 'code' && !($tagName == 'code' && !$isStartTag)) {
390 |             // we supress all HTML tags inside code tags
391 |             $this->invalidTag();
392 | 
393 |             return false;
394 |         }
395 | 
396 |         // get tag attributes
397 |         /** TODO: in html 4 attributes do not need to be quoted **/
398 |         $isEmptyTag = false;
399 |         $attributes = [];
400 |         $currAttrib = '';
401 |         while (isset($this->html[$pos + 1])) {
402 |             $pos++;
403 |             // close tag
404 |             if ($this->html[$pos] == '>' || $this->html[$pos] . $this->html[$pos + 1] == '/>') {
405 |                 if ($this->html[$pos] == '/') {
406 |                     $isEmptyTag = true;
407 |                     $pos++;
408 |                 }
409 |                 break;
410 |             }
411 | 
412 |             $pos_ord = ord(strtolower($this->html[$pos]));
413 |             if (($pos_ord >= static::$a_ord && $pos_ord <= static::$z_ord) || in_array($pos_ord, static::$special_ords)) {
414 |                 // attribute name
415 |                 $currAttrib .= $this->html[$pos];
416 |             } elseif (in_array($this->html[$pos], [' ', "\t", "\n"])) {
417 |                 // drop whitespace
418 |             } elseif (in_array($this->html[$pos] . $this->html[$pos + 1], ['="', "='"])) {
419 |                 // get attribute value
420 |                 $pos++;
421 |                 $await = $this->html[$pos]; // single or double quote
422 |                 $pos++;
423 |                 $value = '';
424 |                 while (isset($this->html[$pos]) && $this->html[$pos] != $await) {
425 |                     $value .= $this->html[$pos];
426 |                     $pos++;
427 |                 }
428 |                 $attributes[$currAttrib] = $value;
429 |                 $currAttrib = '';
430 |             } else {
431 |                 $this->invalidTag();
432 | 
433 |                 return false;
434 |             }
435 |         }
436 |         if ($this->html[$pos] != '>') {
437 |             $this->invalidTag();
438 | 
439 |             return false;
440 |         }
441 | 
442 |         if (!empty($currAttrib)) {
443 |             // html 4 allows something like <option selected> instead of <option selected="selected">
444 |             $attributes[$currAttrib] = $currAttrib;
445 |         }
446 |         if (!$isStartTag) {
447 |             if (!empty($attributes) || $tagName != end($this->openTags)) {
448 |                 // end tags must not contain any attributes
449 |                 // or maybe we did not expect a different tag to be closed
450 |                 $this->invalidTag();
451 | 
452 |                 return false;
453 |             }
454 |             array_pop($this->openTags);
455 |             if (in_array($tagName, $this->preformattedTags)) {
456 |                 $this->keepWhitespace--;
457 |             }
458 |         }
459 |         $pos++;
460 |         $this->node = substr($this->html, 0, $pos);
461 |         $this->html = substr($this->html, $pos);
462 |         $this->tagName = $tagName;
463 |         $this->tagAttributes = $attributes;
464 |         $this->isStartTag = $isStartTag;
465 |         $this->isEmptyTag = $isEmptyTag || in_array($tagName, $this->emptyTags);
466 |         if ($this->isEmptyTag) {
467 |             // might be not well formed
468 |             $this->node = preg_replace('# */? *>$#', ' />', $this->node);
469 |         }
470 |         $this->nodeType = 'tag';
471 |         $this->isBlockElement = $this->blockElements[$tagName];
472 |         $this->isNextToInlineContext = $isStartTag && $this->isInlineContext;
473 |         $this->isInlineContext = !$this->isBlockElement;
474 |         return true;
475 |     }
476 | 
477 |     /**
478 |      * handle invalid tags
479 |      *
480 |      * @param void
481 |      * @return void
482 |      */
483 |     protected function invalidTag()
484 |     {
485 |         $this->html = substr_replace($this->html, '&lt;', 0, 1);
486 |     }
487 | 
488 |     /**
489 |      * update all vars and make $this->html shorter
490 |      *
491 |      * @param string $type see description for $this->nodeType
492 |      * @param int $pos to which position shall we cut?
493 |      * @return void
494 |      */
495 |     protected function setNode($type, $pos)
496 |     {
497 |         if ($this->nodeType == 'tag') {
498 |             // set tag specific vars to null
499 |             // $type == tag should not be called here
500 |             // see this::parseTag() for more
501 |             $this->tagName = null;
502 |             $this->tagAttributes = null;
503 |             $this->isStartTag = null;
504 |             $this->isEmptyTag = null;
505 |             $this->isBlockElement = null;
506 | 
507 |         }
508 |         $this->nodeType = $type;
509 |         $this->node = substr($this->html, 0, $pos);
510 |         $this->html = substr($this->html, $pos);
511 |     }
512 | 
513 |     /**
514 |      * check if $this->html begins with $str
515 |      *
516 |      * @param string $str
517 |      * @return bool
518 |      */
519 |     protected function match($str)
520 |     {
521 |         return substr($this->html, 0, strlen($str)) == $str;
522 |     }
523 | 
524 |     /**
525 |      * truncate whitespaces
526 |      *
527 |      * @param void
528 |      * @return void
529 |      */
530 |     protected function handleWhitespaces()
531 |     {
532 |         if ($this->keepWhitespace) {
533 |             // <pre> or <code> before...
534 | 
535 |             return;
536 |         }
537 |         // truncate multiple whitespaces to a single one
538 |         $this->node = preg_replace('#\s+#s', ' ', $this->node);
539 |     }
540 | 
541 |     /**
542 |      * normalize self::node
543 |      *
544 |      * @param void
545 |      * @return void
546 |      */
547 |     protected function normalizeNode()
548 |     {
549 |         $this->node = '<';
550 |         if (!$this->isStartTag) {
551 |             $this->node .= '/' . $this->tagName . '>';
552 | 
553 |             return;
554 |         }
555 |         $this->node .= $this->tagName;
556 |         foreach ($this->tagAttributes as $name => $value) {
557 |             $this->node .= ' ' . $name . '="' . str_replace('"', '&quot;', $value) . '"';
558 |         }
559 |         if ($this->isEmptyTag) {
560 |             $this->node .= ' /';
561 |         }
562 |         $this->node .= '>';
563 |     }
564 | }
565 | 


--------------------------------------------------------------------------------
/test/ConverterExtraTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Test\Markdownify;
  4 | 
  5 | use Markdownify\ConverterExtra;
  6 | 
  7 | require_once(__DIR__ . '/../vendor/autoload.php');
  8 | 
  9 | class ConverterExtraTest extends ConverterTestCase
 10 | {
 11 | 
 12 | 
 13 |     /* UTILS
 14 |      *************************************************************************/
 15 |     public function setUp()
 16 |     {
 17 |         $this->converter = new ConverterExtra;
 18 |     }
 19 | 
 20 | 
 21 |     /* HEADING TEST METHODS
 22 |      *************************************************************************/
 23 |     /**
 24 |      * @dataProvider providerHeadingConversion
 25 |      */
 26 |     public function testHeadingConversion_withAttribute($level, $attributesHTML, $attributesMD = null)
 27 |     {
 28 |         $innerHTML = 'Heading ' . $level;
 29 |         $md = str_pad('', $level, '#') . ' ' . $innerHTML . $attributesMD;
 30 |         $html = '<h' . $level . $attributesHTML . '>' . $innerHTML . '</h' . $level . '>';
 31 |         $this->assertEquals($md, $this->converter->parseString($html));
 32 |     }
 33 | 
 34 |     public function providerHeadingConversion()
 35 |     {
 36 |         $attributes = [' id="idAttribute"', ' class=" class1  class2 "'];
 37 |         $data = [];
 38 |         for ($i = 1; $i <= 6; $i++) {
 39 |             $data[] = [$i, '', ''];
 40 |             $data[] = [$i, $attributes[0], ' {#idAttribute}'];
 41 |             $data[] = [$i, $attributes[1], ' {.class1.class2}'];
 42 |             $data[] = [$i, $attributes[0] . $attributes[1], ' {#idAttribute.class1.class2}'];
 43 |         }
 44 |         return $data;
 45 |     }
 46 | 
 47 | 
 48 |     /* LINK TEST METHODS
 49 |      *************************************************************************/
 50 |     public function providerLinkConversion()
 51 |     {
 52 |         $data = parent::providerLinkConversion();
 53 | 
 54 |         // Link with href + title + id attributes
 55 |         $data['url-title-id']['md'] = 'This is [an example][1]{#myLink} inline link.
 56 | 
 57 |  [1]: http://example.com/ "Title"';
 58 | 
 59 |         // Link with href + title + class attributes
 60 |         $data['url-title-class']['md'] = 'This is [an example][1]{.external} inline link.
 61 | 
 62 |  [1]: http://example.com/ "Title"';
 63 | 
 64 |         // Link with href + title + multiple classes attributes
 65 |         $data['url-title-multiple-class']['md'] = 'This is [an example][1]{.class1.class2} inline link.
 66 | 
 67 |  [1]: http://example.com/ "Title"';
 68 | 
 69 |         // Link with href + title + multiple classes attributes
 70 |         $data['url-title-multiple-class-id']['md'] = 'This is [an example][1]{#myLink.class1.class2} inline link.
 71 | 
 72 |  [1]: http://example.com/ "Title"';
 73 | 
 74 |         return $data;
 75 |     }
 76 | 
 77 | 
 78 |     /* TABLE TEST METHODS
 79 |      *************************************************************************/
 80 |     public function testTableConversion()
 81 |     {
 82 |         $html = <<<EOF
 83 | <table>
 84 | <thead>
 85 | <tr>
 86 |   <th>First Header</th>
 87 |   <th>Second Header</th>
 88 | </tr>
 89 | </thead>
 90 | <tbody>
 91 | <tr>
 92 |   <td>Content Cell</td>
 93 |   <td>Content Cell</td>
 94 | </tr>
 95 | <tr>
 96 |   <td> </td>
 97 |   <td>Content Cell</td>
 98 | </tr>
 99 | </tbody>
100 | </table>
101 | EOF;
102 |         $md = <<<EOF
103 | | First Header | Second Header |
104 | | ------------ | ------------- |
105 | | Content Cell | Content Cell  |
106 | |              | Content Cell  |
107 | EOF;
108 |         $this->assertEquals($md, $this->converter->parseString($html));
109 |     }
110 | 
111 |     public function testTableConversionWithEmptyCell()
112 |     {
113 |         $html = <<<EOF
114 | <table>
115 | <thead>
116 | <tr>
117 |   <th>First Header</th>
118 |   <th>Second Header</th>
119 | </tr>
120 | </thead>
121 | <tbody>
122 | <tr>
123 |   <td>Content Cell</td>
124 |   <td>Content Cell</td>
125 | </tr>
126 | <tr>
127 |   <td></td>
128 |   <td>Content Cell</td>
129 | </tr>
130 | </tbody>
131 | </table>
132 | EOF;
133 |         $md = <<<EOF
134 | | First Header | Second Header |
135 | | ------------ | ------------- |
136 | | Content Cell | Content Cell  |
137 | |              | Content Cell  |
138 | EOF;
139 |         $this->assertEquals($md, $this->converter->parseString($html));
140 |     }
141 | }
142 | 


--------------------------------------------------------------------------------
/test/ConverterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Test\Markdownify;
 4 | 
 5 | use Markdownify\Converter;
 6 | 
 7 | require_once(__DIR__ . '/../vendor/autoload.php');
 8 | 
 9 | class ConverterTest extends ConverterTestCase
10 | {
11 | 
12 | 
13 |     /* UTILS
14 |      *************************************************************************/
15 |     public function setUp()
16 |     {
17 |         $this->converter = new Converter;
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/test/ConverterTestCase.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Test\Markdownify;
  4 | 
  5 | use Markdownify\Converter;
  6 | 
  7 | require_once(__DIR__ . '/../vendor/autoload.php');
  8 | 
  9 | class ConverterTestCase extends \PHPUnit_Framework_TestCase
 10 | {
 11 | 
 12 | 
 13 |     /* ATTRIBUTES
 14 |      *************************************************************************/
 15 |     protected $converter;
 16 | 
 17 | 
 18 |     /* UNICODE TEST METHODS
 19 |      *************************************************************************/
 20 | 
 21 |     /**
 22 |      * @dataProvider providerUnicodeConversion
 23 |      */
 24 |     public function testUnicodeConversion($md)
 25 |     {
 26 |         $html = '<p>' . $md . '</p>';
 27 |         $this->assertEquals($md, $this->converter->parseString($html));
 28 |     }
 29 | 
 30 |     public function providerUnicodeConversion()
 31 |     {
 32 |         return [
 33 |             ['regular ascii'],
 34 |             ['مرحبا بك'],
 35 |         ];
 36 |     }
 37 | 
 38 | 
 39 |     /* HEADING TEST METHODS
 40 |      *************************************************************************/
 41 | 
 42 |     /**
 43 |      * @dataProvider providerHeadingConversion
 44 |      */
 45 |     public function testHeadingConversion_withAttribute($level, $attributesHTML, $attributesMD = null)
 46 |     {
 47 |         $innerHTML = 'Heading ' . $level;
 48 |         if (empty($attributesHTML)) {
 49 |             $md = str_pad('', $level, '#') . ' ' . $innerHTML;
 50 |         } else {
 51 |             $md = '<h' . $level . $attributesHTML . '>' . "\n"
 52 |                 . '  ' . $innerHTML . "\n"
 53 |                 . '</h' . $level . '>';
 54 |         }
 55 |         $html = '<h' . $level . $attributesHTML . '>' . $innerHTML . '</h' . $level . '>';
 56 |         $this->assertEquals($md, $this->converter->parseString($html));
 57 |     }
 58 | 
 59 |     public function providerHeadingConversion()
 60 |     {
 61 |         $attributes = [' id="idAttribute"', ' class=" class1  class2 "'];
 62 |         $data = [];
 63 |         for ($i = 1; $i <= 6; $i++) {
 64 |             $data[] = [$i, ''];
 65 |             $data[] = [$i, $attributes[0]];
 66 |             $data[] = [$i, $attributes[1]];
 67 |             $data[] = [$i, $attributes[0] . $attributes[1]];
 68 |         }
 69 |         return $data;
 70 |     }
 71 | 
 72 |     /**
 73 |      * @dataProvider providerHeadingConversionEscape
 74 |      */
 75 |     public function testHeadingConversionEscape($html, $md)
 76 |     {
 77 |         $this->assertEquals($md, $this->converter->parseString($html));
 78 |     }
 79 | 
 80 |     public function providerHeadingConversionEscape()
 81 |     {
 82 |         $data = [];
 83 |         $data['level1']['html'] = '# Heading 1';
 84 |         $data['level1']['md'] = '\# Heading 1';
 85 |         $data['level2']['html'] = '## Heading 2';
 86 |         $data['level2']['md'] = '\## Heading 2';
 87 |         return $data;
 88 |     }
 89 | 
 90 | 
 91 |     /* ESCAPE TEST METHODS
 92 |      *************************************************************************/
 93 | 
 94 |     /**
 95 |      * @dataProvider providerAutoescapeConversion
 96 |      */
 97 |     public function testAutoescapeConversion($html, $md)
 98 |     {
 99 |         $this->assertEquals($md, $this->converter->parseString($html));
100 |     }
101 | 
102 |     public function providerAutoescapeConversion()
103 |     {
104 |         return [
105 |             ['AT&amp;T', 'AT&T'],
106 |             ['4 &lt; 5', '4 < 5'],
107 |             ['&copy;', '&copy;']
108 |         ];
109 |     }
110 | 
111 | 
112 |     /* STRIP TAGS OPTION
113 |      *************************************************************************/
114 | 
115 |     /**
116 |      * @dataProvider providerKeepHTMLOption
117 |      */
118 |     public function testKeepHTMLOption($html, $mdWithTag, $mdWithoutTag)
119 |     {
120 |         $this->converter->setKeepHTML(false);
121 |         $this->assertEquals($mdWithoutTag, $this->converter->parseString($html));
122 |         $this->converter->setKeepHTML(true);
123 |         $this->assertEquals($mdWithTag, $this->converter->parseString($html));
124 |     }
125 | 
126 |     public function providerKeepHTMLOption()
127 |     {
128 |         $data = [];
129 | 
130 |         // Issue #16
131 |         $data['image']['html'] = '<img title="a012.gif" src="http://images/problems/a012.gif" alt="a012.gif" width="374" height="204" />';
132 |         $data['image']['mdWithTag'] = '<img title="a012.gif" src="http://images/problems/a012.gif" alt="a012.gif" width="374" height="204" />';
133 |         $data['image']['mdWithoutTag'] = '![a012.gif][1]
134 | 
135 |  [1]: http://images/problems/a012.gif "a012.gif"';
136 | 
137 |         // Issue #23
138 |         $data['target']['html'] = '<p>See <a href="https://github.com/quilljs/quill/issues/81" target="_blank">https://github.com/quilljs/quill/issues/81</a></p>';
139 |         $data['target']['mdWithTag'] = 'See <a href="https://github.com/quilljs/quill/issues/81" target="_blank">https://github.com/quilljs/quill/issues/81</a>';
140 |         $data['target']['mdWithoutTag'] = 'See <https://github.com/quilljs/quill/issues/81>';
141 | 
142 |         // Issue #25
143 |         $data['u']['html'] = '<span><u>Some text</u></span>';
144 |         $data['u']['mdWithTag'] = '<span><u>Some text</u></span>';
145 |         $data['u']['mdWithoutTag'] = 'Some text';
146 | 
147 |         return $data;
148 |     }
149 | 
150 | 
151 |     /* BLOCKQUOTE TEST METHODS
152 |      *************************************************************************/
153 | 
154 |     /**
155 |      * @dataProvider providerBlockquoteConversion
156 |      */
157 |     public function testBlockquoteConversion($html, $md)
158 |     {
159 |         $this->assertEquals($md, $this->converter->parseString($html));
160 |     }
161 | 
162 |     public function providerBlockquoteConversion()
163 |     {
164 |         $data = [];
165 |         $data['simple']['html'] = '<blockquote>blockquoted text goes here</blockquote>';
166 |         $data['simple']['md'] = '> blockquoted text goes here';
167 |         $data['paragraphs']['html'] = '<blockquote><p>paragraph1</p><p>paragraph2</p></blockquote>';
168 |         $data['paragraphs']['md'] = '> paragraph1' . PHP_EOL
169 |             . '> ' . PHP_EOL
170 |             . '> paragraph2';
171 |         $data['cascade']['html'] = '<blockquote><blockquote>cascading blockquote</blockquote></blockquote>';
172 |         $data['cascade']['md'] = '> > cascading blockquote';
173 |         $data['container']['html'] = '<blockquote><h2>This is a header.</h2></blockquote>';
174 |         $data['container']['md'] = '> ## This is a header.';
175 |         return $data;
176 |     }
177 | 
178 | 
179 |     /* LISTS TEST METHODS
180 |      *************************************************************************/
181 | 
182 |     /**
183 |      * @dataProvider providerListConversion
184 |      */
185 |     public function testListConversion($html, $md)
186 |     {
187 |         $this->assertEquals($md, $this->converter->parseString($html));
188 |     }
189 | 
190 |     public function providerListConversion()
191 |     {
192 |         $data = [];
193 |         $data['ordered']['html'] = '<ol><li>Bird</li><li>McHale</li><li>Parish</li></ol>';
194 |         $data['ordered']['md'] = '  1. Bird' . PHP_EOL
195 |             . '  2. McHale' . PHP_EOL
196 |             . '  3. Parish';
197 |         $data['unordered']['html'] = '<ul><li>Red</li><li>Green</li><li>Blue</li></ul>';
198 |         $data['unordered']['md'] = '  * Red' . PHP_EOL
199 |             . '  * Green' . PHP_EOL
200 |             . '  * Blue';
201 |         $data['paragraph']['html'] = '<ul><li><p>Bird</p></li><li><p>Magic</p></li></ul>';
202 |         $data['paragraph']['md'] = '  * Bird' . PHP_EOL
203 |             . PHP_EOL
204 |             . '  * Magic';
205 |         $data['next-to-text']['html'] = 'McHale<ol><li>Bird</li><li>Magic</li></ol>';
206 |         $data['next-to-text']['md'] = 'McHale' . PHP_EOL
207 |             . '' . PHP_EOL
208 |             . '  1. Bird' . PHP_EOL
209 |             . '  2. Magic';
210 |         $data['next-to-text-in-block-context']['html'] = '<blockquote>McHale<ol><li>Bird</li><li>Magic</li></ol></blockquote>';
211 |         $data['next-to-text-in-block-context']['md'] = '> McHale' . PHP_EOL
212 |             . '> ' . PHP_EOL
213 |             . '>   1. Bird' . PHP_EOL
214 |             . '>   2. Magic';
215 |         $data['next-to-bold']['html'] = '<b>McHale</b><ol><li>Bird</li><li>Magic</li></ol>';
216 |         $data['next-to-bold']['md'] = '**McHale**' . PHP_EOL
217 |             . PHP_EOL
218 |             . '  1. Bird' . PHP_EOL
219 |             . '  2. Magic';
220 |         $data['next-to-bold-and-br']['html'] = '<b>McHale</b><br><ol><li>Bird</li><li>Magic</li></ol>';
221 |         $data['next-to-bold-and-br']['md'] = '**McHale**  ' . PHP_EOL
222 |             . PHP_EOL
223 |             . PHP_EOL
224 |             . '  1. Bird' . PHP_EOL
225 |             . '  2. Magic';
226 |         $data['next-to-paragraph']['html'] = '<p>McHale</p><ol><li>Bird</li><li>Magic</li></ol>';
227 |         $data['next-to-paragraph']['md'] = 'McHale' . PHP_EOL
228 |             . PHP_EOL
229 |             . '  1. Bird' . PHP_EOL
230 |             . '  2. Magic';
231 |         $data['nested-ordered']['html'] = '<ol><li>Bird</li><li>Colors<ol><li>Red</li><li>Green<ol><li>Light</li><li>Dark</li></ol></li><li>Blue</li></ol></li></ol>';
232 |         $data['nested-ordered']['md'] = '  1. Bird' . PHP_EOL
233 |             . '  2. Colors' . PHP_EOL
234 |             . '      1. Red' . PHP_EOL
235 |             . '      2. Green' . PHP_EOL
236 |             . '          1. Light' . PHP_EOL
237 |             . '          2. Dark' . PHP_EOL
238 |             . '      3. Blue';
239 |         $data['nested-unordered']['html'] = '<ul><li>Bird</li><li>Colors<ul><li>Red</li><li>Green<ul><li>Light</li><li>Dark</li></ul></li><li>Blue</li></ul></li></ul>';
240 |         $data['nested-unordered']['md'] = '  * Bird' . PHP_EOL
241 |             . '  * Colors' . PHP_EOL
242 |             . '      * Red' . PHP_EOL
243 |             . '      * Green' . PHP_EOL
244 |             . '          * Light' . PHP_EOL
245 |             . '          * Dark' . PHP_EOL
246 |             . '      * Blue';
247 | 
248 |         return $data;
249 |     }
250 | 
251 | 
252 |     /* CODE TEST METHODS
253 |      *************************************************************************/
254 | 
255 |     /**
256 |      * @dataProvider providerCodeConversion
257 |      */
258 |     public function testCodeConversion($html, $md)
259 |     {
260 |         $this->assertEquals($md, $this->converter->parseString($html));
261 |     }
262 | 
263 |     public function providerCodeConversion()
264 |     {
265 |         $data = [];
266 |         $data['inline']['html'] = '<p>Use the <code>printf()</code> function.</p>';
267 |         $data['inline']['md'] = 'Use the `printf()` function.';
268 |         $data['inline-backtick']['html'] = '<p>A single backtick in a code span: <code>`</code></p>';
269 |         $data['inline-backtick']['md'] = 'A single backtick in a code span: `` ` ``';
270 |         $data['inline-doubleBacktick']['html'] = '<p>A backtick-delimited string in a code span: <code>`foo`</code></p>';
271 |         $data['inline-doubleBacktick']['md'] = 'A backtick-delimited string in a code span: `` `foo` ``';
272 |         $data['inline-escape']['html'] = 'Use the `printf()` function.';
273 |         $data['inline-escape']['md'] = 'Use the \`printf()\` function.';
274 |         $data['inline-backtick-escape']['html'] = 'A single backtick in a code span: `` ` ``';
275 |         $data['inline-backtick-escape']['md'] = 'A single backtick in a code span: \`\` \` \`\`';
276 |         $data['inline-doubleBacktick-escape']['html'] = 'A backtick-delimited string in a code span: `` `foo` ``';
277 |         $data['inline-doubleBacktick-escape']['md'] = 'A backtick-delimited string in a code span: \`\` \`foo\` \`\`';
278 |         $data['inline']['md'] = 'Use the `printf()` function.';
279 |         $data['inline-html']['html'] = '<p>Please don\'t use any <code>&lt;blink&gt;</code> tags.</p>';
280 |         $data['inline-html']['md'] = 'Please don\'t use any `<blink>` tags.';
281 |         $data['pre']['html'] = '<p>This is a normal paragraph:</p><pre><code>This is a code block.</code></pre>';
282 |         $data['pre']['md'] = 'This is a normal paragraph:' . PHP_EOL
283 |             . PHP_EOL
284 |             . '    This is a code block.';
285 |         $data['pre-indentation']['html'] = '<p>Here is an example of AppleScript:</p><pre><code>tell application "Foo"
286 |     beep
287 | end tell
288 | </code></pre>';
289 |         $data['pre-indentation']['md'] = 'Here is an example of AppleScript:' . PHP_EOL
290 |             . PHP_EOL
291 |             . '    tell application "Foo"' . PHP_EOL
292 |             . '        beep' . PHP_EOL
293 |             . '    end tell';
294 |         $data['pre-html']['html'] = '<pre><code>&lt;div class="footer"&gt;
295 |     &amp;copy; 2004 Foo Corporation
296 | &lt;/div&gt;
297 | </code></pre>';
298 |         $data['pre-html']['md'] = '    <div class="footer">
299 |         &copy; 2004 Foo Corporation
300 |     </div>';
301 | 
302 |         return $data;
303 |     }
304 | 
305 | 
306 |     /* LINK TEST METHODS
307 |      *************************************************************************/
308 | 
309 |     /**
310 |      * @dataProvider providerLinkConversion
311 |      */
312 |     public function testLinkConversion($html, $md, $linkPosition = null)
313 |     {
314 |         if ($linkPosition !== null) {
315 |             $this->converter->setLinkPosition($linkPosition);
316 |         }
317 |         $this->assertEquals($md, $this->converter->parseString($html));
318 |     }
319 | 
320 |     public function providerLinkConversion()
321 |     {
322 |         $data = [];
323 | 
324 |         // Link with href attribute
325 |         $data['url']['html'] = '<p><a href="http://example.net/">This link</a> has no title attribute.</p>';
326 |         $data['url']['md'] = '[This link][1] has no title attribute.' . PHP_EOL
327 |             . PHP_EOL
328 |             . ' [1]: http://example.net/';
329 | 
330 |         // Empty link
331 |         $data['url-empty']['html'] = '<p><a href="">This link</a>.</p>';
332 |         $data['url-empty']['md'] = '[This link]().';
333 | 
334 |         // Multiple paragraph link
335 |         $data['url-multiple-1']['html'] =
336 |             '<p>This is <a href="http://example1.com/" title="Title">an example</a> inline link.</p>
337 |             <p>This is <a href="http://example2.com/" title="Title">another example</a> inline link.</p>';
338 |         $data['url-multiple-1']['md'] = 'This is [an example][1] inline link.' . PHP_EOL
339 |             . PHP_EOL
340 |             . 'This is [another example][2] inline link.' . PHP_EOL
341 |             . PHP_EOL
342 |             . ' [1]: http://example1.com/ "Title"' . PHP_EOL
343 |             . ' [2]: http://example2.com/ "Title"';
344 |         $data['url-multiple-1']['linkPosition'] = Converter::LINK_AFTER_CONTENT;
345 | 
346 |         // Multiple paragraph link
347 |         $data['url-multiple-2']['html'] =
348 |             '<p>This is <a href="http://example1.com/" title="Title">an example</a> inline link.</p>
349 |             <p>This is <a href="http://example2.com/" title="Title">another example</a> inline link.</p>';
350 |         $data['url-multiple-2']['md'] = 'This is [an example][1] inline link.' . PHP_EOL
351 |             . PHP_EOL
352 |             . ' [1]: http://example1.com/ "Title"' . PHP_EOL
353 |             . PHP_EOL
354 |             . 'This is [another example][2] inline link.' . PHP_EOL
355 |             . PHP_EOL
356 |             . ' [2]: http://example2.com/ "Title"';
357 |         $data['url-multiple-2']['linkPosition'] = Converter::LINK_AFTER_PARAGRAPH;
358 | 
359 |         // Multiple paragraph link
360 |         $data['url-multiple-2']['html'] =
361 |             '<p>This is <a href="http://example1.com/" title="Title">an example</a> inline link.</p>
362 |             <p>This is <a href="http://example2.com/" title="Title">another example</a> inline link.</p>';
363 |         $data['url-multiple-2']['md'] = 'This is [an example](http://example1.com/ "Title") inline link.' . PHP_EOL
364 |             . PHP_EOL
365 |             . 'This is [another example](http://example2.com/ "Title") inline link.';
366 |         $data['url-multiple-2']['linkPosition'] = Converter::LINK_IN_PARAGRAPH;
367 | 
368 |         // Direct link
369 |         $data['url-direct']['html'] = '<p><a href="http://example.com">http://example.com</a>.</p>';
370 |         $data['url-direct']['md'] = '<http://example.com>.';
371 | 
372 |         // Link with href + title attributes
373 |         $data['url-title']['html'] = '<p>This is <a href="http://example.com/" title="Title">an example</a> inline link.</p>';
374 |         $data['url-title']['md'] = 'This is [an example][1] inline link.' . PHP_EOL
375 |             . PHP_EOL
376 |             . ' [1]: http://example.com/ "Title"';
377 | 
378 |         // Link with href + title + id attributes
379 |         $data['url-title-id']['html'] = '<p>This is <a href="http://example.com/" title="Title" id="myLink">an example</a> inline link.</p>';
380 |         $data['url-title-id']['md'] = 'This is <a href="http://example.com/" title="Title" id="myLink">an example</a> inline link.';
381 | 
382 |         // Link with href + title + class attributes
383 |         $data['url-title-class']['html'] = '<p>This is <a href="http://example.com/" title="Title" class="external">an example</a> inline link.</p>';
384 |         $data['url-title-class']['md'] = 'This is <a href="http://example.com/" title="Title" class="external">an example</a> inline link.';
385 | 
386 |         // Link with href + title + multiple classes attributes
387 |         $data['url-title-multiple-class']['html'] = '<p>This is <a href="http://example.com/" title="Title" class=" class1  class2 ">an example</a> inline link.</p>';
388 |         $data['url-title-multiple-class']['md'] = 'This is <a href="http://example.com/" title="Title" class=" class1  class2 ">an example</a> inline link.';
389 | 
390 |         // Link with href + title + multiple classes + id attributes
391 |         $data['url-title-multiple-class-id']['html'] = '<p>This is <a href="http://example.com/" title="Title" class=" class1  class2 " id="myLink">an example</a> inline link.</p>';
392 |         $data['url-title-multiple-class-id']['md'] = 'This is <a href="http://example.com/" title="Title" class=" class1  class2 " id="myLink">an example</a> inline link.';
393 | 
394 |         // Escaped link
395 |         $data['url-escape']['html'] = '[This link](/path)';
396 |         $data['url-escape']['md'] = '\[This link\](/path)';
397 | 
398 |         // Image with src + alt attributes
399 |         $data['image']['html'] = '<img src="/path/to/img.jpg" alt="Alt text" />';
400 |         $data['image']['md'] = '![Alt text][1]' . PHP_EOL
401 |             . PHP_EOL
402 |             . ' [1]: /path/to/img.jpg';
403 | 
404 |         // Image with src + alt attributes in content
405 |         $data['image--in']['html'] = '<img src="/path/to/img.jpg" alt="Alt text" />';
406 |         $data['image--in']['md'] = '![Alt text](/path/to/img.jpg)';
407 |         $data['image--in']['linkPosition'] = Converter::LINK_IN_PARAGRAPH;
408 | 
409 |         // Image with src + alt + title attributes
410 |         $data['image-title']['html'] = '<img src="/path/to/img.jpg" alt="Alt text" title="Optional title attribute" />';
411 |         $data['image-title']['md'] = '![Alt text][1]' . PHP_EOL
412 |             . PHP_EOL
413 |             . ' [1]: /path/to/img.jpg "Optional title attribute"';
414 | 
415 |         // Image with src + alt + title attributes in content
416 |         $data['image-title--in']['html'] = '<img src="/path/to/img.jpg" alt="Alt text" title="Optional title attribute" />';
417 |         $data['image-title--in']['md'] = '![Alt text](/path/to/img.jpg "Optional title attribute")';
418 |         $data['image-title--in']['linkPosition'] = Converter::LINK_IN_PARAGRAPH;
419 | 
420 |         // Escaped image
421 |         $data['image-escape']['html'] = '![This link](/path)';
422 |         $data['image-escape']['md'] = '!\[This link\](/path)';
423 | 
424 |         // Image & Link
425 |         $data['image-url']['html'] = '<p><a href="http://google.com"><img src="http://www.fillmurray.com/g/200/300"></a></p>';
426 |         $data['image-url']['md'] = '[![][1]][2]' . PHP_EOL
427 |             . PHP_EOL
428 |             . ' [1]: http://www.fillmurray.com/g/200/300' . PHP_EOL
429 |             . ' [2]: http://google.com';
430 | 
431 |         return $data;
432 |     }
433 | 
434 | 
435 |     /* EMPHASIS TEST METHODS
436 |      *************************************************************************/
437 | 
438 |     /**
439 |      * @dataProvider providerEmphasisConversion
440 |      */
441 |     public function testEmphasisConversion($html, $md)
442 |     {
443 |         $this->assertEquals($md, $this->converter->parseString($html));
444 |     }
445 | 
446 |     public function providerEmphasisConversion()
447 |     {
448 |         $data = [];
449 |         $data['strong']['html'] = '<strong>double asterisks</strong>';
450 |         $data['strong']['md'] = '**double asterisks**';
451 |         $data['strong-escape']['html'] = '**double asterisks**';
452 |         $data['strong-escape']['md'] = '\*\*double asterisks\*\*';
453 |         $data['strong-escape2']['html'] = '__double asterisks__';
454 |         $data['strong-escape2']['md'] = '\_\_double asterisks\_\_';
455 |         $data['em']['html'] = '<em>single asterisks</em>';
456 |         $data['em']['md'] = '_single asterisks_';
457 |         $data['em-escape']['html'] = '*single asterisks*';
458 |         $data['em-escape']['md'] = '\*single asterisks\*';
459 |         $data['em-escape2']['html'] = '_single asterisks_';
460 |         $data['em-escape2']['md'] = '\_single asterisks\_';
461 | 
462 |         return $data;
463 |     }
464 | 
465 | 
466 |     /* RULES TEST METHODS
467 |      *************************************************************************/
468 | 
469 |     /**
470 |      * @dataProvider providerRulesConversion
471 |      */
472 |     public function testRulesConversion($html, $md)
473 |     {
474 |         $this->assertEquals($md, $this->converter->parseString($html));
475 |     }
476 | 
477 |     public function providerRulesConversion()
478 |     {
479 |         $data = [];
480 |         $data['hr']['html'] = '<hr>';
481 |         $data['hr']['md'] = '* * *';
482 |         $data['escape-']['html'] = '-----------------------------------';
483 |         $data['escape-']['md'] = '\---\---\---\---\---\---\---\---\---\---\-----';
484 |         $data['escape-']['html'] = '*****************';
485 |         $data['escape-']['md'] = '\***\***\***\***\*****';
486 | 
487 |         return $data;
488 |     }
489 | 
490 | 
491 |     /* FIX BREAKS TESTS
492 |      *************************************************************************/
493 | 
494 |     /**
495 |      * @dataProvider providerFixBreaks
496 |      */
497 |     public function testFixBreaks($html, $md)
498 |     {
499 |         $this->assertEquals($md, $this->converter->parseString($html));
500 |     }
501 | 
502 | 
503 |     public function providerFixBreaks()
504 |     {
505 |         $data = [];
506 |         $data['break1']['html'] = "<strong>Hello,<br>How are you doing?</strong>";
507 |         $data['break1']['md'] = "**Hello,  \nHow are you doing?**";
508 |         $data['break2']['html'] = "<b>Hey,<br> How you're doing?</b><br><br><b>Sorry<br><br> You can't get through</b>";
509 |         $data['break2']['md'] = "**Hey,  \nHow you're doing?**  \n  \n**Sorry  \n  \nYou can't get through**";
510 | 
511 |         return $data;
512 |     }
513 | 
514 |     /* FIX TAG SPACES TESTS
515 |      *************************************************************************/
516 | 
517 |     /**
518 |      * @dataProvider providerFixTagSpaces
519 |      */
520 |     public function testFixTagSpaces($html, $md)
521 |     {
522 |         $this->assertEquals($md, $this->converter->parseString($html));
523 |     }
524 | 
525 | 
526 |     public function providerFixTagSpaces()
527 |     {
528 |         $data = [];
529 |         $data['strong']['html'] = "<p>This is<strong> strong</strong> text</p>";
530 |         $data['strong']['md'] = "This is **strong** text";
531 |         $data['em']['html'] = "<p>This is<em> italic </em>text</p>";
532 |         $data['em']['md'] = "This is _italic_ text";
533 |         $data['b']['html'] = "<p>Not bold,<b> bolder    </b>boldst</p>";
534 |         $data['b']['md'] = "Not bold, **bolder** boldst";
535 |         $data['i']['html'] = "<p>Not italic, <i>italic </i></p>";
536 |         $data['i']['md'] = "Not italic, _italic_";
537 |         $data['a']['html'] = "<p>This is a paragraph of text with <a href='http://example.com'>a link </a>to something awesome.</p>";
538 |         $data['a']['md'] = "This is a paragraph of text with [a link][1] to something awesome.
539 | 
540 |  [1]: http://example.com";
541 | 
542 |         return $data;
543 |     }
544 | 
545 |     /* FIX STATE RESET
546 |      *************************************************************************/
547 | 
548 |     public function testResetState()
549 |     {
550 |         // Broken (unclosed) tags cause properties (such as indents) to run onto subsequent strings,
551 |         $blockquote = 'Test blockquote <blockquote>Here it is';
552 |         $linebreaks = 'Test<br /><br />Linebreaks';
553 | 
554 |         $converter = new Converter();
555 |         $bqOutput = $converter->parseString($blockquote);
556 | 
557 |         $this->assertContains('>', $bqOutput);
558 | 
559 |         $lbOutput = $converter->parseString($linebreaks);
560 | 
561 |         $this->assertNotContains('>', $lbOutput);
562 |     }
563 | }
564 | 


--------------------------------------------------------------------------------