$match) { $return[$key]['shortcode'] = $matches[2][$key]; $return[$key]['attr'] = shortcode_parse_atts( $match ); if(preg_match("/$pattern/s", $matches[5][$key]) && $depth) { $return[$key]['content'] = self::shortcode2array($matches[5][$key], $depth); } else { $return[$key]['content'] = $matches[5][$key]; } } return $return; } /** *set the allowed shortcodes **/ static function allowed_shortcodes($params, $remove = false) { if(!$remove) { self::$manually_allowed_shortcodes = $params; if(!in_array('av_textblock', self::$manually_allowed_shortcodes)) self::$manually_allowed_shortcodes[] = 'av_textblock'; } else { self::$manually_disallowed_shortcodes = $params; } } /** *check if the current element is nested within column or section **/ static function is_top_level() { global $avia_config; if(!isset($avia_config['conditionals']['is_builder'])) return false; if(isset($avia_config['current_column']) || isset($avia_config['layout_container'])) return false; return true; } /** *creates the shortcode pattern that only matches Avia Builder Shortcodes **/ static function build_pattern($predefined_tags = false) { global $shortcode_tags; //save the "real" shortcode array $old_sc = $shortcode_tags; //if we got allowed shortcodes build the pattern. nested shortcodes are also considered but within a separate array if(!empty(ShortcodeHelper::$allowed_shortcodes)) { $shortcode_tags = array_flip(array_merge(ShortcodeHelper::$allowed_shortcodes, ShortcodeHelper::$nested_shortcodes)); } //filter out all elements that are not in the predefined tags array. this is necessary for nested shortcode modal to work properly if(is_array($predefined_tags)) { $predefined_tags = array_flip($predefined_tags); $shortcode_tags = shortcode_atts($predefined_tags, $shortcode_tags); } //create the pattern and store it ShortcodeHelper::$pattern = get_shortcode_regex(); //restore original shortcode tags $shortcode_tags = $old_sc; return ShortcodeHelper::$pattern; } /** * Create a fake pattern on the fly that makes us able to check a post for shortcodes upfront, * just so we know if we need to load any special resources. Can also returns the complete * shortcode tags (open or close, not the content) to check and balance the shortcodes. * * With 4.2.1 this function also returns the escaped shortcodes. * * @param boolean $nested * @param array|false $shortcode_tags * @param string $return 'fake' | 'tags' (added with 4.3) | 'complete' (added with 4.1.2) * @return string **/ static function get_fake_pattern( $nested = false, $shortcode_tags = false, $return = 'fake' ) { if(!is_array($shortcode_tags)) { if(!empty(ShortcodeHelper::$allowed_shortcodes)) { //usually we dont want the nested fake shortcodes to be included in the count if($nested) { $shortcode_tags = array_merge(ShortcodeHelper::$allowed_shortcodes, ShortcodeHelper::$nested_shortcodes); } else { $shortcode_tags = array_merge(ShortcodeHelper::$allowed_shortcodes); } } } if( 'fake' == $return ) { // match all shortcodes and escaped shortcodes start and end tags: [xxx [[xxx [/xxx] [/xxx]] $pattern = "\[{1,2}" . implode( '[\s|\]]|\[{1,2}', $shortcode_tags ) . "[\s|\]]|\[\/" . implode( '\]{1,2}|\[\/', $shortcode_tags ) . "\]{1,2}"; } else { $arr_patt = array(); foreach ($shortcode_tags as $key => $shortcode_tag) { /** * captures unclosed tags like "[fooo ... [ " and [/foo .... [ - must be placed first otherwise will be included in standard match * * (?=\[) includes everything up to next [ (but not including [) */ if( 'complete' == $return ) { $arr_patt[] = '\[{1,2}[\/]?' . $shortcode_tag . '[^\]]*?(?=\[)'; } // captures complete opening and closing shortcode tags $arr_patt[] = '\[{1,2}[\/]?' . $shortcode_tag . '[^\]]*\]{1,2}'; } $pattern = implode( '|', $arr_patt ); } return $pattern; } /** * Builds a shortcode tree out of an array that was extracted from the content with get_fake_pattern and a call to * preg_match_all( ...., PREG_OFFSET_CAPTURE ). * * Also removes shortcodes inside escaped shortcodes and escaped shortcodes as WP ignores these. * * Ensure that the HTML shortcode structure in page content is balanced with all registered shortcodes before calling this function, * otherwise this might lead to a broken layout because WP might work with a different shortcode structure * https://codex.wordpress.org/Shortcode_API#Unclosed_Shortcodes * * ( also see ShortcodeHelper::balance_shortcode() ) * * @param string $content * @return array */ static public function &build_shortcode_tree( $content ) { // see avia_sc_postcontent (currently experimental only) // if( is_array( $matches[0] ) ) // { // $matches = $matches[0]; // } $tree = array(); $wp_result = array(); $parser_state = Avia_Builder()->get_posts_shortcode_parser_state(); if( in_array( $parser_state, array( 'disabled' ) ) || ! in_array( Avia_Builder()->get_shortcode_parser()->get_shortode_state(), array( 'valid' ) ) ) { /** * This is for a fallback situation when user does not want to or cannot use the autorepair function because it breaks. * We use the old style from version <= 4.2 * * Extract all shortcodes from the post array and store them so we know what we are dealing with when the user opens a page. * Usesfull for special elements that we might need to render outside of the default loop like fullscreen slideshows */ $matches = array(); preg_match_all( "/" . ShortcodeHelper::get_fake_pattern() . "/s", $content, $matches ); if( is_array( $matches ) && is_array( $matches[0] ) && ( ! empty( $matches[0] ) ) ) { $matches = $matches[0]; } else { return $tree; } $matches = explode( ',', str_replace( ']', '', implode( ',', $matches ) ) ); /** * Close all elements that are not self closing to generate a valid xml string */ $current = 0; while ( $current < count( $matches ) ) { $match = trim( $matches[ $current ] ); if( strpos( $match, '/' ) !== false ) { $current ++; continue; } $closing = trim(str_replace('[','[/',$match)); $search = $current + 1; $auto_close = true; while ( $search < count( $matches ) ) { $comp = trim( $matches[ $search ] ); if( $match == $comp ) { break; } if( $closing == $comp ) { $auto_close = false; break; } $search ++; } if( $auto_close ) //if we got no closing tag add a temp one { array_splice( $matches, $current + 1, 0, array( $closing ) ); } $current ++; } /** * Reset to new style array */ foreach( $matches as $sc ) { $wp_result[] = array( $sc ); } } else { $parser = Avia_Builder()->get_shortcode_parser(); /** * This is the preferred way since 4.2.1 * * To be on the safe side we use pure WP regex to extract the shortcodes. * As content should have been balanced before calling this function we can rely on a * valid shortcode structure */ $wp_result = $parser->get_wp_result( $content ); /** * Ensure we have a valid shortcode structure before calling this function !!! * Now we scan for escaped shortcodes and add missing closing tags to self closing tags so we have a valid XML structure * for easier building of the tree. */ $wp_result = $parser->balance_shortcode_array( $wp_result, 'forced' ); /** * Remove escaped shortcodes and extract only ALB shortcodes that have a valid callback */ $parser->remove_escape_shortcodes_in_array( $wp_result ); $parser->filter_shortcodes_in_array( $wp_result, ShortcodeHelper::$allowed_shortcodes ); } /* * As we can rely on valid shortcode structure now we can safely use the truncated shortcode without attributes */ $sc = array(); foreach ( $wp_result as $code ) { $sc[] = $code[0]; } $shortcodes = explode( ',', str_replace( array( ']', '[' ), '', implode( ',', $sc ) ) ); $temp_index = 0; $tree = array('content' => array()); $pointers = array(&$tree); foreach( $shortcodes as $index => $line ) { if(!empty($line[0])) { $close = '/' === $line[0]; $count = count($pointers); if(!$close) { $pointers[$count] = array('tag' => trim($line), 'content' => array(), 'index' => $temp_index); $pointers[$count - 1]['content'][] = & $pointers[$count]; $temp_index ++ ; continue; } else { array_pop($pointers); } } } $result = &$tree['content']; unset($tree); return $result; } static function find_tree_item($index, $sibling = false, $tree = false) { if(empty(self::$tree)) return false; if($tree === false) $tree = self::$tree; $return = array(); foreach($tree as $key => $t) { if(!$return) { if($t['index'] == $index) { if($sibling !== false) { $return = isset($tree[$key + $sibling]) ? $tree[$key + $sibling] : false; } else { $return = $tree[$key]; } return $return; } else if(!empty($tree[$key]['content'])) { $return = self::find_tree_item($index, $sibling, $tree[$key]['content']); } } } return $return; } /** * Clean up the rendered text and ensure balanced shortcode tags (depending on shortcode parser setting). * $text can be content of an ALB paga, a non ALB page, _aviaLayoutBuilderCleanData or ALB template * * - Checks, that existing closing shortcode tags are applied to all opening shortcode tags ( nesting of same name shortcode is not supported ) * - Removes all unnecessary html tags around shortcodes that are added by the editor * * @param string $text * @param string $action 'content' | 'balance_only' * @return string */ static public function clean_up_shortcode( $text, $action = 'balance_only' ) { /* self::build_pattern(); $text_nodes = preg_split("/".self::$pattern."/s", $text); //usually removes all
tags that are not needed before shorttcode and in between them like
foreach($text_nodes as $node )
{
if( strlen( trim( $node ) ) == 0 || strlen( trim( strip_tags($node) ) ) == 0)
{
$text = preg_replace("/(".preg_quote($node, '/')."(?!\[\/))/", '', $text);
}
}
*/
/**
* Activates the shortcode parser depending on shortcode parser flag setting and generates the error output to DB
*/
$text = Avia_Builder()->get_shortcode_parser()->parse_shortcode( $text );
/**
* On a non ALB page, _aviaLayoutBuilderCleanData and template we only need to add the missing shortcode tags and do not
* touch the structure of the page
*/
if( 'balance_only' == $action )
{
return $text;
}
/**
* On ALB page content:
*
* remove all )?\[($tagregexp)(\s[^\]]+)?\](<\/p>| )?\[\/($tagregexp)](<\/p>| $| \s*( )?\s*<\/p>#', '', $content);
return $content;
}
/**
* Applies wordpress autop filter
*
* @param string $content html content by the wordpress editor
* @return string $content
*/
static function avia_apply_autop($content,$do_shortcode = true)
{
$content = wpautop($content);
if($do_shortcode) $content = do_shortcode( shortcode_unautop($content) );
return $content;
}
/**
* holds the function that creates the shortcode based on variables that are passed
*/
static function create_shortcode_by_array($name, $content = NULL, $args = array())
{
$sc = "[".$name;
if(is_array($args))
{
foreach($args as $key => $arg)
{
if(is_numeric($key))
{
$sc .= " ".$arg;
}
else
{
if(strpos($arg , "'") === false && strpos($arg,"'") === false)
{
$sc .= " ".$key."='".$arg."'";
}
else
{
$sc .= ' '.$key.'="'.$arg.'"';
}
}
}
}
$sc .= "]";
if(!is_null($content))
{
//strip slashes and trim the content
$content = "\n".trim(stripslashes($content)) ."\n";
// $content = htmlentities( $content , ENT_QUOTES, get_bloginfo( 'charset' ) ); //entity-test: added htmlentities
//if the content is empty without tabs and line breaks remove it completly
if(trim($content) == "") $content = "";
$sc .= $content."[/$name]";
}
$sc .= "\n\n";
//$sc = str_replace("\n",'',$sc);
return $sc;
}
}
}
tags that are not needed. those that follow immediatly after a shortode or are located just before one
*/
$shortcode_tags = array_merge( ShortcodeHelper::$allowed_shortcodes, ShortcodeHelper::$nested_shortcodes );
$tagregexp = join( '|', array_map( 'preg_quote', $shortcode_tags ) );
$regex = "!(\s*?\
)?/","[$2$3]",$content);
// closing tag
$content = preg_replace("/(
)?/","[/$2]",$content);
if($do_shortcode) $content = do_shortcode( shortcode_unautop($content) );
$content = preg_replace('#^<\/p>|^
|