2015-10-04 12:37:12 +00:00
< ? php
register_module ([
" name " => " Parsedown " ,
2018-07-01 19:56:08 +00:00
" version " => " 0.9.12 " ,
2016-03-19 18:24:52 +00:00
" author " => " Emanuil Rusev & Starbeamrainbowlabs " ,
2016-04-23 15:34:51 +00:00
" description " => " An upgraded (now default!) parser based on Emanuil Rusev's Parsedown Extra PHP library (https://github.com/erusev/parsedown-extra), which is licensed MIT. Please be careful, as this module adds some weight to your installation, and also *requires* write access to the disk on first load. " ,
2015-10-04 12:37:12 +00:00
" id " => " parser-parsedown " ,
" code " => function () {
2016-03-12 18:30:40 +00:00
global $settings ;
2016-03-12 15:26:30 +00:00
$parser = new PeppermintParsedown ();
$parser -> setInternalLinkBase ( " ?page=%s " );
add_parser ( " parsedown " , function ( $source ) use ( $parser ) {
2016-04-08 20:05:42 +00:00
global $settings ;
if ( $settings -> clean_raw_html )
$parser -> setMarkupEscaped ( true );
else
$parser -> setMarkupEscaped ( false );
2016-03-12 15:26:30 +00:00
$result = $parser -> text ( $source );
2015-10-04 13:04:42 +00:00
return $result ;
2015-10-04 12:37:12 +00:00
});
2016-03-12 18:30:40 +00:00
2018-04-28 09:59:08 +00:00
/*
* ███████ ████████ █████ ████████ ██ ███████ ████████ ██ ██████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ███████ ██ ██ ███████ ██ ██ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ██ ██ ███████ ██ ██ ██████ ███████
*/
2017-07-14 19:35:55 +00:00
statistic_add ([
" id " => " wanted-pages " ,
" name " => " Wanted Pages " ,
2017-09-16 12:26:12 +00:00
" type " => " page " ,
2017-07-14 19:35:55 +00:00
" update " => function ( $old_stats ) {
global $pageindex , $env ;
$result = new stdClass (); // completed, value, state
$pages = [];
foreach ( $pageindex as $pagename => $pagedata ) {
2018-04-26 22:51:41 +00:00
if ( ! file_exists ( $env -> storage_prefix . $pagedata -> filename ))
2017-07-14 20:22:37 +00:00
continue ;
2017-07-14 19:35:55 +00:00
$page_content = file_get_contents ( $env -> storage_prefix . $pagedata -> filename );
2018-04-26 22:14:35 +00:00
$page_links = PeppermintParsedown :: extract_page_names ( $page_content );
foreach ( $page_links as $linked_page ) {
2017-07-14 19:35:55 +00:00
// We're only interested in pages that don't exist
2017-07-14 20:22:37 +00:00
if ( ! empty ( $pageindex -> $linked_page )) continue ;
2017-07-14 19:35:55 +00:00
if ( empty ( $pages [ $linked_page ]))
$pages [ $linked_page ] = 0 ;
$pages [ $linked_page ] ++ ;
}
}
arsort ( $pages );
$result -> value = $pages ;
$result -> completed = true ;
return $result ;
2017-07-14 21:13:13 +00:00
},
" render " => function ( $stats_data ) {
$result = " <h2> $stats_data->name </h2> \n " ;
$result .= " <table class='wanted-pages'> \n " ;
$result .= " \t <tr><th>Page Name</th><th>Linking Pages</th></tr> \n " ;
foreach ( $stats_data -> value as $pagename => $linking_pages ) {
$result .= " \t <tr><td> $pagename </td><td> $linking_pages </td></tr> \n " ;
}
$result .= " </table> \n " ;
return $result ;
2017-07-14 19:35:55 +00:00
}
]);
2018-04-26 22:27:44 +00:00
statistic_add ([
" id " => " orphan-pages " ,
" name " => " Orphan Pages " ,
2018-04-28 10:06:23 +00:00
" type " => " page-list " ,
2018-04-26 22:27:44 +00:00
" update " => function ( $old_stats ) {
global $pageindex , $env ;
$result = new stdClass (); // completed, value, state
$pages = [];
foreach ( $pageindex as $pagename => $pagedata ) {
2018-04-26 22:51:41 +00:00
if ( ! file_exists ( $env -> storage_prefix . $pagedata -> filename ))
2018-04-26 22:27:44 +00:00
continue ;
$page_content = file_get_contents ( $env -> storage_prefix . $pagedata -> filename );
$page_links = PeppermintParsedown :: extract_page_names ( $page_content );
foreach ( $page_links as $linked_page ) {
// We're only interested in pages that exist
if ( empty ( $pageindex -> $linked_page )) continue ;
$pages [ $linked_page ] = true ;
}
}
$orphaned_pages = [];
foreach ( $pageindex as $pagename => $page_data ) {
if ( empty ( $pages [ $pagename ]))
$orphaned_pages [] = $pagename ;
}
2018-04-28 10:01:57 +00:00
sort ( $orphaned_pages );
2018-04-26 22:27:44 +00:00
$result -> value = $orphaned_pages ;
$result -> completed = true ;
return $result ;
}
]);
2018-04-28 09:59:08 +00:00
statistic_add ([
" id " => " most-linked-to-pages " ,
" name " => " Most Linked-To Pages " ,
" type " => " page " ,
" update " => function ( $old_stats ) {
global $pageindex , $env ;
$result = new stdClass (); // completed, value, state
$pages = [];
foreach ( $pageindex as $pagename => $pagedata ) {
if ( ! file_exists ( $env -> storage_prefix . $pagedata -> filename ))
continue ;
$page_content = file_get_contents ( $env -> storage_prefix . $pagedata -> filename );
$page_links = PeppermintParsedown :: extract_page_names ( $page_content );
foreach ( $page_links as $linked_page ) {
// We're only interested in pages that exist
if ( empty ( $pageindex -> $linked_page )) continue ;
if ( empty ( $pages [ $linked_page ]))
$pages [ $linked_page ] = 0 ;
$pages [ $linked_page ] ++ ;
}
}
arsort ( $pages );
$result -> value = $pages ;
$result -> completed = true ;
return $result ;
},
" render " => function ( $stats_data ) {
global $pageindex ;
$result = " <h2> $stats_data->name </h2> \n " ;
$result .= " <table class='most-linked-to-pages'> \n " ;
$result .= " \t <tr><th>Page Name</th><th>Linking Pages</th></tr> \n " ;
foreach ( $stats_data -> value as $pagename => $link_count ) {
$pagename_display = ! empty ( $pageindex -> $pagename -> redirect ) && $pageindex -> $pagename -> redirect ? " <em> $pagename </em> " : $pagename ;
$result .= " \t <tr><td><a href='?page= " . rawurlencode ( $pagename ) . " '> $pagename_display </a></td><td> $link_count </td></tr> \n " ;
}
$result .= " </table> \n " ;
return $result ;
}
]);
2017-07-14 19:35:55 +00:00
2016-03-12 18:30:40 +00:00
add_help_section ( " 20-parser-default " , " Editor Syntax " ,
" <p> $settings->sitename 's editor uses an extended version of <a href='http://parsedown.org/'>Parsedown</a> to render pages, which is a fantastic open source Github flavoured markdown parser. You can find a quick reference guide on Github flavoured markdown <a href='https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet'>here</a> by <a href='https://github.com/adam-p/'>adam-p</a>, or if you prefer a book <a href='https://www.gitbook.com/book/roachhd/master-markdown/details'>Mastering Markdown</a> by KB is a good read, and free too!</p>
2016-08-19 19:28:47 +00:00
< h3 > Tips </ h3 >
< ul >
< li > Put 2 spaces at the end of a line to add a soft line break . Leave a blank line to add a head line break ( i . e . a new paragraph ) .</ li >
< li > You can add an id to a header that you can link to . Put it in curly braces after the heading name like this : < code > # Heading Name {#HeadingId}</code>. Then you can link to like like this: <code>[[Page name#HeadingId}]]</code>. You can also link to a heading id on the current page by omitting the page name: <code>[[#HeadingId]]</code>.</li>
</ ul >
2016-03-12 18:30:40 +00:00
< h3 > Extra Syntax </ h3 >
< p > $settings -> sitename 's editor also supports some extra custom syntax, some of which is inspired by <a href=' https :// mediawiki . org / ' > Mediawiki </ a >.
< table >
< tr >< th style = 'width: 40%' > Type this </ th >< th style = 'width: 20%' > To get this </ th >< th > Comments </ th ></ th >
< tr >< td >< code > [[ Internal link ]] </ code ></ td >< td >< a href = '?page=Internal%20link' > Internal Link </ a ></ td >< td > An internal link .</ td ></ tr >
< tr >< td >< code > [[ Display Text | Internal link ]] </ code ></ td >< td >< a href = '?page=Internal%20link' > Display Text </ a ></ td >< td > An internal link with some display text .</ td ></ tr >
< tr >< td >< code >! [ Alt text ]( http :// example . com / path / to / image . png | 256 x256 | right ) </ code ></ td >< td >< img src = 'http://example.com/path/to/image.png' alt = 'Alt text' style = 'float: right; max-width: 256px; max-height: 256px;' /></ td >< td > An image floating to the right of the page that fits inside a 256 px x 256 px box , preserving aspect ratio .</ td ></ tr >
2018-07-01 19:56:08 +00:00
< tr >< td >< code >! [ Alt text ]( http :// example . com / path / to / image . png | 256 x256 | caption ) </ code ></ td >< td >< figure >< img src = 'http://example.com/path/to/image.png' alt = 'Alt text' style = 'max-width: 256px; max-height: 256px;' />< figcaption > Alt text </ figcaption ></ figure ></ td >< td > An image with a caption that fits inside a 256 px x 256 px box , preserving aspect ratio . The presence of the word < code > caption </ code > in the regular braces causes the alt text to be taken and displayed below the image itself .</ td ></ tr >
2016-05-30 11:35:23 +00:00
< tr >< td >< code >! [ Alt text ]( Files / Cheese . png ) </ code ></ td >< td >< img src = 'index.php?action=preview&page=Files/Cheese.png' alt = 'Alt text' style = '' /></ td >< td > An example of the short url syntax for images . Simply enter the page name of an image ( or video / audio file ), and Pepperminty Wiki will sort out the url for you .</ td ></ tr >
2016-03-20 17:57:47 +00:00
</ table >
2016-05-30 11:35:23 +00:00
< p > Note that the all image image syntax above can be mixed and matched to your liking . The < code > caption </ code > option in particular must come last or next to last .</ p >
2016-03-20 17:57:47 +00:00
< h4 > Templating </ h4 >
< p > $settings -> sitename also supports including one page in another page as a < em > template </ em >. The syntax is very similar to that of Mediawiki . For example , < code > {{ Announcement banner }} </ code > will include the contents of the \ " Announcement banner \" page, assuming it exists.</p>
2016-04-09 09:55:44 +00:00
< p > You can also use variables . Again , the syntax here is very similar to that of Mediawiki - they can be referenced in the included page by surrrounding the variable name in triple curly braces ( e . g . < code > {{{ Announcement text }}} </ code > ), and set when including a page with the bar syntax ( e . g . < code > {{ Announcement banner | importance = high | text = Maintenance has been planned for tonight . }} </ code > ) . Currently the only restriction in templates and variables is that you may not include a closing curly brace ( < code > } </ code > ) in the page name , variable name , or value .</ p >
2016-05-30 11:35:23 +00:00
< h5 > Special Variables </ h5 >
2016-04-09 09:55:44 +00:00
< p > $settings -> sitename also supports a number of special built - in variables . Their syntax and function are described below :</ p >
< table >
< tr >< th > Type this </ th >< th > To get this </ th ></ tr >
< tr >< td >< code > {{{ @ }}} </ code ></ td >< td > Lists all variables and their values in a table .</ td ></ tr >
< tr >< td >< code > {{{ #}}}</code></td><td>Shows a 'stack trace', outlining all the parent includes of the current page being parsed.</td></tr>
2016-11-03 20:29:15 +00:00
< tr >< td >< code > {{{ ~ }}} </ code ></ td >< td > Outputs the requested page ' s name .</ td ></ tr >
2016-04-09 09:55:44 +00:00
< tr >< td >< code > {{{ * }}} </ code ></ td >< td > Outputs a comma separated list of all the subpages of the current page .</ td ></ tr >
< tr >< td >< code > {{{ + }}} </ code ></ td >< td > Shows a gallery containing all the files that are sub pages of the current page .</ td ></ tr >
</ table > " );
2015-10-04 12:37:12 +00:00
}
]);
2016-03-12 15:26:30 +00:00
/*** Parsedown versions ***
* Parsedown Core : 1.6 . 0 *
* Parsedown Extra : 0.7 . 0 *
**************************/
$env -> parsedown_paths = new stdClass ();
$env -> parsedown_paths -> parsedown = " https://cdn.rawgit.com/erusev/parsedown/3ebbd730b5c2cf5ce78bc1bf64071407fc6674b7/Parsedown.php " ;
$env -> parsedown_paths -> parsedown_extra = " https://cdn.rawgit.com/erusev/parsedown-extra/11a44e076d02ffcc4021713398a60cd73f78b6f5/ParsedownExtra.php " ;
// Download parsedown and parsedown extra if they don't already exist
2017-11-13 23:12:13 +00:00
// These must still use this old method, as the parser may be asked to render some HTML before Pepperminty Wiki has had a chance to run the downloads
2016-03-12 15:26:30 +00:00
if ( ! file_exists ( " ./Parsedown.php " ) || filesize ( " ./Parsedown.php " ) === 0 )
file_put_contents ( " ./Parsedown.php " , fopen ( $env -> parsedown_paths -> parsedown , " r " ));
if ( ! file_exists ( " ./ParsedownExtra.php " ) || filesize ( " ./ParsedownExtra.php " ) === 0 )
file_put_contents ( " ./ParsedownExtra.php " , fopen ( $env -> parsedown_paths -> parsedown_extra , " r " ));
2015-10-04 12:37:12 +00:00
2016-03-12 15:26:30 +00:00
require_once ( " ./Parsedown.php " );
require_once ( " ./ParsedownExtra.php " );
2015-10-04 12:37:12 +00:00
2015-12-26 12:55:19 +00:00
/*
2016-03-12 15:26:30 +00:00
* ██████ █████ ██████ ███████ ███████ ██████ ██████ ██ ██ ███ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
* ██████ ███████ ██████ ███████ █████ ██ ██ ██ ██ ██ █ ██ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ███ ██ ██ ██ ██
* ██ ██ ██ ██ ██ ███████ ███████ ██████ ██████ ███ ███ ██ ████
*
* ███████ ██ ██ ████████ ███████ ███ ██ ███████ ██ ██████ ███ ██ ███████
* ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ████ ██ ██
* █████ ███ ██ █████ ██ ██ ██ ███████ ██ ██ ██ ██ ██ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ███████ ██ ████ ███████ ██ ██████ ██ ████ ███████
*/
class PeppermintParsedown extends ParsedownExtra
2015-10-04 12:37:12 +00:00
{
2016-03-12 15:26:30 +00:00
private $internalLinkBase = " ./%s " ;
2016-03-20 16:16:55 +00:00
protected $maxParamDepth = 0 ;
protected $paramStack = [];
2016-03-12 15:26:30 +00:00
function __construct ()
{
// Prioritise our internal link parsing over the regular link parsing
array_unshift ( $this -> InlineTypes [ " [ " ], " InternalLink " );
// Prioritise our image parser over the regular image parser
array_unshift ( $this -> InlineTypes [ " ! " ], " ExtendedImage " );
2015-10-04 14:20:47 +00:00
2016-03-20 14:05:55 +00:00
$this -> inlineMarkerList .= " { " ;
2016-03-25 17:52:32 +00:00
if ( ! isset ( $this -> InlineTypes [ " { " ]) or ! is_array ( $this -> InlineTypes [ " { " ]))
2016-03-20 14:05:55 +00:00
$this -> InlineTypes [ " { " ] = [];
$this -> InlineTypes [ " { " ][] = " Template " ;
}
2016-04-09 06:51:29 +00:00
/*
* ████████ ███████ ███ ███ ██████ ██ █████ ████████ ██ ███ ██ ██████
* ██ ██ ████ ████ ██ ██ ██ ██ ██ ██ ██ ████ ██ ██
* ██ █████ ██ ████ ██ ██████ ██ ███████ ██ ██ ██ ██ ██ ██ ███
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ███████ ██ ██ ██ ███████ ██ ██ ██ ██ ██ ████ ██████
*/
2016-03-20 14:05:55 +00:00
protected function inlineTemplate ( $fragment )
{
2016-04-09 06:51:29 +00:00
global $env , $pageindex ;
2016-03-20 17:05:16 +00:00
2016-03-20 16:16:55 +00:00
// Variable parsing
if ( preg_match ( " / \ { \ { \ { ([^}]+) \ } \ } \ }/ " , $fragment [ " text " ], $matches ))
{
2016-04-08 08:01:12 +00:00
$params = [];
if ( ! empty ( $this -> paramStack ))
{
$stackEntry = array_slice ( $this -> paramStack , - 1 )[ 0 ];
$params = ! empty ( $stackEntry ) ? $stackEntry [ " params " ] : false ;
}
2016-03-20 17:05:16 +00:00
2016-03-20 16:16:55 +00:00
$variableKey = trim ( $matches [ 1 ]);
2016-03-20 16:38:36 +00:00
$variableValue = false ;
2016-03-20 17:05:16 +00:00
switch ( $variableKey )
{
2016-04-09 09:55:44 +00:00
case " @ " : // Lists all variables and their values
2016-03-20 17:05:16 +00:00
if ( ! empty ( $params ))
{
$variableValue = " <table>
< tr >< th > Key </ th >< th > Value </ th ></ tr > \n " ;
foreach ( $params as $key => $value )
{
$variableValue .= " \t <tr><td> " . $this -> escapeText ( $key ) . " </td><td> " . $this -> escapeText ( $value ) . " </td></tr> \n " ;
}
$variableValue .= " </table> " ;
}
break ;
2016-04-09 06:51:29 +00:00
case " # " : // Shows a stack trace
2016-03-20 17:05:16 +00:00
$variableValue = " <ol start= \" 0 \" > \n " ;
$variableValue .= " \t <li> $env->page </li> \n " ;
foreach ( $this -> paramStack as $curStackEntry )
{
$variableValue .= " \t <li> " . $curStackEntry [ " pagename " ] . " </li> \n " ;
}
$variableValue .= " </ol> \n " ;
2016-04-08 08:01:12 +00:00
break ;
2016-04-09 06:51:29 +00:00
case " ~ " : // Show requested page's name
2016-04-08 08:50:13 +00:00
if ( ! empty ( $this -> paramStack ))
$variableValue = $this -> escapeText ( $env -> page );
2016-04-09 06:51:29 +00:00
break ;
case " * " : // Lists subpages
$subpages = get_subpages ( $pageindex , $env -> page );
$variableValue = [];
foreach ( $subpages as $pagename => $depth )
{
$variableValue [] = $pagename ;
}
$variableValue = implode ( " , " , $variableValue );
if ( strlen ( $variableValue ) === 0 )
$variableValue = " <em>(none yet!)</em> " ;
break ;
2016-04-09 09:55:44 +00:00
case " + " : // Shows a file gallery for subpages with files
2016-04-09 08:26:18 +00:00
// If the upload module isn't present, then there's no point
// in checking for uploaded files
if ( ! module_exists ( " feature-upload " ))
break ;
$variableValue = [];
$subpages = get_subpages ( $pageindex , $env -> page );
foreach ( $subpages as $pagename => $depth )
{
// Make sure that this is an uploaded file
if ( ! $pageindex -> $pagename -> uploadedfile )
continue ;
$mime_type = $pageindex -> $pagename -> uploadedfilemime ;
$previewSize = 300 ;
$previewUrl = " ?action=preview&size= $previewSize &page= " . rawurlencode ( $pagename );
$previewHtml = " " ;
switch ( substr ( $mime_type , 0 , strpos ( $mime_type , " / " )))
{
case " video " :
$previewHtml .= " <video src=' $previewUrl ' controls preload='metadata'> $pagename </video> \n " ;
break ;
case " audio " :
$previewHtml .= " <audio src=' $previewUrl ' controls preload='metadata'> $pagename </audio> \n " ;
break ;
case " application " :
case " image " :
default :
$previewHtml .= " <img src=' $previewUrl ' /> \n " ;
break ;
}
$previewHtml = " <a href='?page= " . rawurlencode ( $pagename ) . " '> $previewHtml $pagename </a> " ;
$variableValue [ $pagename ] = " <li style='min-width: $previewSize " . " px; min-height: $previewSize " . " px;'> $previewHtml </li> " ;
}
if ( count ( $variableValue ) === 0 )
$variableValue [ " default " ] = " <li><em>(No files found)</em></li> \n " ;
$variableValue = implode ( " \n " , $variableValue );
$variableValue = " <ul class='file-gallery'> $variableValue </ul> " ;
break ;
2016-03-20 17:05:16 +00:00
}
if ( isset ( $params [ $variableKey ]))
2016-03-20 16:42:21 +00:00
{
2016-03-20 17:05:16 +00:00
$variableValue = $params [ $variableKey ];
2016-03-20 16:42:21 +00:00
$variableValue = $this -> escapeText ( $variableValue );
}
2016-03-20 16:38:36 +00:00
2016-04-09 06:51:29 +00:00
if ( $variableValue !== false )
2016-03-20 16:16:55 +00:00
{
return [
" extent " => strlen ( $matches [ 0 ]),
2016-03-20 16:38:36 +00:00
" markup " => $variableValue
2016-03-20 16:16:55 +00:00
];
}
}
else if ( preg_match ( " / \ { \ { ([^}]+) \ } \ }/ " , $fragment [ " text " ], $matches ))
2016-03-20 14:05:55 +00:00
{
$templateElement = $this -> templateHandler ( $matches [ 1 ]);
if ( ! empty ( $templateElement ))
{
return [
" extent " => strlen ( $matches [ 0 ]),
" element " => $templateElement
];
}
}
}
protected function templateHandler ( $source )
{
2016-04-08 08:01:12 +00:00
global $pageindex , $env ;
2016-03-20 14:05:55 +00:00
2016-03-20 16:16:55 +00:00
2016-08-22 08:36:22 +00:00
$parts = preg_split ( " / \\ ||¦/ " , trim ( $source , " { } " ));
2016-04-08 08:01:12 +00:00
$parts = array_map ( " trim " , $parts );
2016-03-20 14:05:55 +00:00
2016-04-10 10:49:50 +00:00
// Extract the name of the template page
2016-03-20 14:05:55 +00:00
$templatePagename = array_shift ( $parts );
// If the page that we are supposed to use as the tempalte doesn't
// exist, then there's no point in continuing.
if ( empty ( $pageindex -> $templatePagename ))
return false ;
// Parse the parameters
2016-03-20 16:16:55 +00:00
$this -> maxParamDepth ++ ;
2016-03-20 14:05:55 +00:00
$params = [];
$i = 0 ;
foreach ( $parts as $part )
{
if ( strpos ( $part , " = " ) !== false )
{
// This param contains an equals sign, so it's a named parameter
$keyValuePair = explode ( " = " , $part , 2 );
2016-04-08 08:01:12 +00:00
$keyValuePair = array_map ( " trim " , $keyValuePair );
2016-03-20 14:05:55 +00:00
$params [ $keyValuePair [ 0 ]] = $keyValuePair [ 1 ];
}
else
{
// This isn't a named parameter
2016-03-20 16:16:55 +00:00
$params [ " $i " ] = trim ( $part );
2016-03-20 14:05:55 +00:00
$i ++ ;
}
}
2016-03-20 16:16:55 +00:00
// Add the parsed parameters to the parameter stack
2016-03-20 17:05:16 +00:00
$this -> paramStack [] = [
" pagename " => $templatePagename ,
" params " => $params
];
2016-03-20 14:05:55 +00:00
2016-04-08 08:01:12 +00:00
$templateFilePath = $env -> storage_prefix . $pageindex -> $templatePagename -> filename ;
2016-03-20 14:05:55 +00:00
$parsedTemplateSource = $this -> text ( file_get_contents ( $templateFilePath ));
2016-03-20 16:16:55 +00:00
// Remove the parsed parameters from the stack
array_pop ( $this -> paramStack );
2016-03-20 14:05:55 +00:00
return [
" name " => " div " ,
" text " => $parsedTemplateSource ,
" attributes " => [
" class " => " template "
]
];
2016-03-12 15:26:30 +00:00
}
2016-08-22 08:40:17 +00:00
/*
* ██ ███ ██ ████████ ███████ ██████ ███ ██ █████ ██
* ██ ████ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██
* ██ ██ ██ ██ ██ █████ ██████ ██ ██ ██ ███████ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ████ ██ ███████ ██ ██ ██ ████ ██ ██ ███████
*
* ██ ██ ███ ██ ██ ██ ███████
* ██ ██ ████ ██ ██ ██ ██
* ██ ██ ██ ██ ██ █████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ████ ██ ██ ███████
*/
2016-03-12 15:26:30 +00:00
protected function inlineInternalLink ( $fragment )
{
2016-08-19 18:39:53 +00:00
global $pageindex , $env ;
2016-04-08 08:28:59 +00:00
2018-09-29 22:40:23 +00:00
if ( preg_match ( '/^\[\[([^\]]*)\]\]([^\s!?",;.()\[\]{}*=+\/]*)/u' , $fragment [ " text " ], $matches ))
2016-03-12 15:26:30 +00:00
{
2017-03-09 10:47:25 +00:00
$linkPage = trim ( $matches [ 1 ]);
$display = $linkPage . trim ( $matches [ 2 ]);
2016-08-22 08:36:22 +00:00
if ( strpos ( $matches [ 1 ], " | " ) !== false || strpos ( $matches [ 1 ], " ¦ " ) !== false )
2016-03-12 15:26:30 +00:00
{
// We have a bar character
2016-08-22 08:36:22 +00:00
$parts = preg_split ( " / \\ ||¦/ " , $matches [ 1 ], 2 );
2016-08-19 09:59:49 +00:00
$linkPage = trim ( $parts [ 0 ]); // The page to link to
$display = trim ( $parts [ 1 ]); // The text to display
2016-03-12 15:26:30 +00:00
}
2016-08-19 18:39:53 +00:00
$hashCode = " " ;
if ( strpos ( $linkPage , " # " ) !== false )
{
// We want to link to a subsection of a page
$hashCode = substr ( $linkPage , strpos ( $linkPage , " # " ) + 1 );
$linkPage = substr ( $linkPage , 0 , strpos ( $linkPage , " # " ));
// If $linkPage is empty then we want to link to the current page
if ( strlen ( $linkPage ) === 0 )
$linkPage = $env -> page ;
}
2016-08-19 09:59:49 +00:00
// If the page doesn't exist, check varying different
// capitalisations to see if it exists under some variant.
if ( empty ( $pageindex -> $linkPage ))
{
if ( ! empty ( $pageindex -> { ucfirst ( $linkPage )}))
$linkPage = ucfirst ( $linkPage );
else if ( ! empty ( $pageindex -> { ucwords ( $linkPage )}))
$linkPage = ucwords ( $linkPage );
}
2016-03-12 15:26:30 +00:00
// Construct the full url
$linkUrl = str_replace (
" %s " , rawurlencode ( $linkPage ),
$this -> internalLinkBase
);
2016-08-19 18:39:53 +00:00
if ( strlen ( $hashCode ) > 0 )
$linkUrl .= " # $hashCode " ;
2016-04-08 08:28:59 +00:00
$result = [
2016-03-12 15:26:30 +00:00
" extent " => strlen ( $matches [ 0 ]),
" element " => [
" name " => " a " ,
" text " => $display ,
" attributes " => [
" href " => $linkUrl
]
]
];
2016-04-08 08:28:59 +00:00
2016-12-26 18:30:29 +00:00
if ( empty ( $pageindex -> { makepathsafe ( $linkPage )}))
2016-04-08 08:28:59 +00:00
$result [ " element " ][ " attributes " ][ " class " ] = " redlink " ;
return $result ;
2016-03-12 15:26:30 +00:00
}
return ;
}
2016-08-22 08:40:17 +00:00
/*
* ███████ ██ ██ ████████ ███████ ███ ██ ██████ ███████ ██████
* ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██
* █████ ███ ██ █████ ██ ██ ██ ██ ██ █████ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ███████ ██ ████ ██████ ███████ ██████
*
* ██ ███ ███ █████ ██████ ███████ ███████
* ██ ████ ████ ██ ██ ██ ██ ██
* ██ ██ ████ ██ ███████ ██ ███ █████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ ██ ██████ ███████ ███████
*/
2016-03-12 15:26:30 +00:00
protected function inlineExtendedImage ( $fragment )
{
2016-05-30 09:54:09 +00:00
global $pageindex ;
2016-08-21 11:00:40 +00:00
2016-08-22 10:14:49 +00:00
if ( preg_match ( '/^!\[(.*)\]\(([^|¦)]+)\s*(?:(?:\||¦)([^|¦)]*))?(?:(?:\||¦)([^|¦)]*))?(?:(?:\||¦)([^)]*))?\)/' , $fragment [ " text " ], $matches ))
2015-10-04 14:20:47 +00:00
{
2016-03-12 15:26:30 +00:00
/*
* 0 - Everything
* 1 - Alt text
* 2 - Url
2016-04-10 10:49:50 +00:00
* 3 - First param ( optional )
2016-05-29 19:34:34 +00:00
* 4 - Second param ( optional )
* 5 - Third param ( optional )
2016-03-12 15:26:30 +00:00
*/
$altText = $matches [ 1 ];
2016-10-11 18:26:42 +00:00
$imageUrl = trim ( str_replace ( " & " , " & " , $matches [ 2 ])); // Decode & to allow it in preview urls
2016-05-29 19:34:34 +00:00
$param1 = empty ( $matches [ 3 ]) ? false : strtolower ( trim ( $matches [ 3 ]));
2016-03-12 15:26:30 +00:00
$param2 = empty ( $matches [ 4 ]) ? false : strtolower ( trim ( $matches [ 4 ]));
2016-05-29 19:34:34 +00:00
$param3 = empty ( $matches [ 5 ]) ? false : strtolower ( trim ( $matches [ 5 ]));
2016-03-12 15:26:30 +00:00
$floatDirection = false ;
$imageSize = false ;
2016-05-29 19:34:34 +00:00
$imageCaption = false ;
2016-10-11 18:44:01 +00:00
$shortImageUrl = false ;
2016-03-12 15:26:30 +00:00
if ( $this -> isFloatValue ( $param1 ))
{
2016-04-08 08:01:12 +00:00
// Param 1 is a valid css float: ... value
2016-03-12 15:26:30 +00:00
$floatDirection = $param1 ;
$imageSize = $this -> parseSizeSpec ( $param2 );
}
else if ( $this -> isFloatValue ( $param2 ))
{
2016-04-08 08:01:12 +00:00
// Param 2 is a valid css float: ... value
2016-03-12 15:26:30 +00:00
$floatDirection = $param2 ;
$imageSize = $this -> parseSizeSpec ( $param1 );
}
2016-05-29 19:34:34 +00:00
else if ( $this -> isFloatValue ( $param3 ))
{
$floatDirection = $param3 ;
$imageSize = $this -> parseSizeSpec ( $param1 );
}
2016-04-08 08:01:12 +00:00
else if ( $param1 === false and $param2 === false )
{
// Neither params were specified
$floatDirection = false ;
$imageSize = false ;
}
2016-03-12 15:26:30 +00:00
else
{
2016-04-08 08:01:12 +00:00
// Neither of them are floats, but at least one is specified
// This must mean that the first param is a size spec like
// 250x128.
2016-03-12 15:26:30 +00:00
$imageSize = $this -> parseSizeSpec ( $param1 );
}
2015-10-04 14:20:47 +00:00
2016-06-03 08:32:26 +00:00
if ( $param1 !== false && strtolower ( trim ( $param1 )) == " caption " )
2016-05-29 19:34:34 +00:00
$imageCaption = true ;
2016-06-03 08:32:26 +00:00
if ( $param2 !== false && strtolower ( trim ( $param2 )) == " caption " )
$imageCaption = true ;
2016-05-29 19:34:34 +00:00
if ( $param3 !== false && strtolower ( trim ( $param3 )) == " caption " )
$imageCaption = true ;
2016-08-22 16:24:22 +00:00
//echo("Image url: $imageUrl, Pageindex entry: " . var_export(isset($pageindex->$imageUrl), true) . "\n");
2016-05-30 09:54:09 +00:00
if ( isset ( $pageindex -> $imageUrl ) and $pageindex -> $imageUrl -> uploadedfile )
{
// We have a short url! Expand it.
2016-10-11 18:44:01 +00:00
$shortImageUrl = $imageUrl ;
2016-05-30 09:54:09 +00:00
$imageUrl = " index.php?action=preview&size= " . max ( $imageSize [ " x " ], $imageSize [ " y " ]) . " &page= " . rawurlencode ( $imageUrl );
}
2016-03-12 15:26:30 +00:00
$style = " " ;
if ( $imageSize !== false )
2016-03-12 18:32:58 +00:00
$style .= " max-width: " . $imageSize [ " x " ] . " px; max-height: " . $imageSize [ " y " ] . " px; " ;
2016-03-12 15:26:30 +00:00
if ( $floatDirection )
$style .= " float: $floatDirection ; " ;
2015-10-04 14:20:47 +00:00
2016-04-08 08:01:12 +00:00
$urlExtension = pathinfo ( $imageUrl , PATHINFO_EXTENSION );
$urlType = system_extension_mime_type ( $urlExtension );
2016-05-29 19:34:34 +00:00
$result = [];
2016-04-08 08:01:12 +00:00
switch ( substr ( $urlType , 0 , strpos ( $urlType , " / " )))
{
case " audio " :
2016-05-29 19:34:34 +00:00
$result = [
2016-04-08 08:01:12 +00:00
" extent " => strlen ( $matches [ 0 ]),
" element " => [
" name " => " audio " ,
" text " => $altText ,
" attributes " => [
" src " => $imageUrl ,
" controls " => " controls " ,
" preload " => " metadata " ,
" style " => trim ( $style )
]
]
];
2016-05-29 19:34:34 +00:00
break ;
2016-04-08 08:01:12 +00:00
case " video " :
2016-05-29 19:34:34 +00:00
$result = [
2016-04-08 08:01:12 +00:00
" extent " => strlen ( $matches [ 0 ]),
" element " => [
" name " => " video " ,
" text " => $altText ,
" attributes " => [
" src " => $imageUrl ,
" controls " => " controls " ,
" preload " => " metadata " ,
" style " => trim ( $style )
]
]
];
2016-05-29 19:34:34 +00:00
break ;
2016-04-08 08:01:12 +00:00
case " image " :
default :
// If we can't work out what it is, then assume it's an image
2016-05-29 19:34:34 +00:00
$result = [
2016-04-08 08:01:12 +00:00
" extent " => strlen ( $matches [ 0 ]),
" element " => [
" name " => " img " ,
" attributes " => [
" src " => $imageUrl ,
" alt " => $altText ,
2016-04-10 10:49:50 +00:00
" title " => $altText ,
2016-04-08 08:01:12 +00:00
" style " => trim ( $style )
]
]
];
2016-05-29 19:34:34 +00:00
break ;
2016-04-08 08:01:12 +00:00
}
2016-05-29 19:34:34 +00:00
2016-10-11 18:44:01 +00:00
// ~ Image linker ~
$imageHref = $shortImageUrl !== false ? " ?page= " . rawurlencode ( $shortImageUrl ) : $imageUrl ;
$result [ " element " ] = [
" name " => " a " ,
" attributes " => [
" href " => $imageHref
],
" text " => [ $result [ " element " ]],
" handler " => " elements "
];
// ~
2016-05-29 19:34:34 +00:00
if ( $imageCaption )
{
2018-04-05 08:47:29 +00:00
$rawStyle = $result [ " element " ][ " text " ][ 0 ][ " attributes " ][ " style " ];
2016-05-29 19:34:34 +00:00
$containerStyle = preg_replace ( '/^.*float/' , " float " , $rawStyle );
$mediaStyle = preg_replace ( '/\s*float.*;/' , " " , $rawStyle );
$result [ " element " ] = [
" name " => " figure " ,
2016-10-11 18:44:01 +00:00
" attributes " => [
" style " => $containerStyle
],
2016-05-29 19:34:34 +00:00
" text " => [
$result [ " element " ],
[
" name " => " figcaption " ,
2016-05-30 09:54:09 +00:00
" text " => $altText
2016-05-29 19:34:34 +00:00
],
],
" handler " => " elements "
];
$result [ " element " ][ " text " ][ 0 ][ " attributes " ][ " style " ] = $mediaStyle ;
}
return $result ;
2015-10-04 14:20:47 +00:00
}
2016-03-12 15:26:30 +00:00
}
2018-04-26 22:14:35 +00:00
# ~
# Static Methods
# ~
public static function extract_page_names ( $page_text ) {
global $pageindex ;
preg_match_all ( " / \ [ \ [([^ \ ]]+) \ ] \ ]/ " , $page_text , $linked_pages );
if ( count ( $linked_pages [ 1 ]) === 0 )
return []; // No linked pages here
$result = [];
foreach ( $linked_pages [ 1 ] as $linked_page ) {
// Strip everything after the | and the #
if ( strpos ( $linked_page , " | " ) !== false )
$linked_page = substr ( $linked_page , 0 , strpos ( $linked_page , " | " ));
if ( strpos ( $linked_page , " # " ) !== false )
$linked_page = substr ( $linked_page , 0 , strpos ( $linked_page , " # " ));
if ( strlen ( $linked_page ) === 0 )
continue ;
// Make sure we try really hard to find this page in the
// pageindex
$altered_linked_page = $linked_page ;
if ( ! empty ( $pageindex -> { ucfirst ( $linked_page )}))
$altered_linked_page = ucfirst ( $linked_page );
else if ( ! empty ( $pageindex -> { ucwords ( $linked_page )}))
$altered_linked_page = ucwords ( $linked_page );
else // Our efforts were in vain, so reset to the original
$altered_linked_page = $linked_page ;
$result [] = $altered_linked_page ;
}
return $result ;
}
2016-03-20 16:16:55 +00:00
# ~
# Utility Methods
# ~
2016-03-12 15:26:30 +00:00
private function isFloatValue ( $value )
{
return in_array ( strtolower ( $value ), [ " left " , " right " ]);
}
private function parseSizeSpec ( $text )
{
if ( strpos ( $text , " x " ) === false )
return false ;
$parts = explode ( " x " , $text , 2 );
2015-10-04 14:20:47 +00:00
2016-03-12 15:26:30 +00:00
if ( count ( $parts ) != 2 )
return false ;
2015-10-04 14:20:47 +00:00
2016-03-12 15:26:30 +00:00
array_map ( " trim " , $parts );
array_map ( " intval " , $parts );
if ( in_array ( 0 , $parts ))
return false ;
return [
" x " => $parts [ 0 ],
" y " => $parts [ 1 ]
];
}
2016-03-20 16:42:21 +00:00
protected function escapeText ( $text )
{
return htmlentities ( $text , ENT_COMPAT | ENT_HTML5 );
}
2016-03-12 15:26:30 +00:00
/**
* Sets the base url to be used for internal links . '%s' will be replaced
* with a URL encoded version of the page name .
* @ param string $url The url to use when parsing internal links .
*/
public function setInternalLinkBase ( $url )
{
$this -> internalLinkBase = $url ;
}
2015-10-04 12:37:12 +00:00
}
?>