Util::shorten_html()

Complexity

Conditions	19
Paths	1153

Size

Total Lines	111
Code Lines	50

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	38
CRAP Score	33.7982

Importance

Changes

0

<?php
	public static function shorten_html($string, $length = 384, $ellipsis = '...', $exact = true)
	{
		// If its shorter than the maximum length, while accounting for html tags, simply return
		if (self::strlen(preg_replace('~<.*?>~', '', $string)) <= $length)
			return $string;

		// Start off empty
		$total_length = $exact ? self::strlen($ellipsis) : 0;
		$open_tags = array();
		$truncate = '';

		// Group all html open and closing tags, [1] full tag with <> [2] basic tag name [3] tag content
		preg_match_all('~(<\/?([\w+]+)[^>]*>)?([^<>]*)~', $string, $tags, PREG_SET_ORDER);

		// Walk down the stack of tags
		foreach ($tags as $tag)
		{
			// If this tag has content
			if (!preg_match('/img|br|input|hr|area|base|basefont|col|frame|isindex|link|meta|param/s', $tag[2]))
			{
				// Opening tag add the closing tag to the top of the stack
				if (preg_match('~<[\w]+[^>]*>~s', $tag[0]))
					array_unshift($open_tags, $tag[2]);
				// Closing tag
				elseif (preg_match('~<\/([\w]+)[^>]*>~s', $tag[0], $close_tag))
				{
					// Remove its starting tag
					$pos = array_search($close_tag[1], $open_tags);
					if ($pos !== false)
						array_splice($open_tags, $pos, 1);

It seems like $pos can also be of type string; however, parameter $offset of array_splice() does only seem to accept integer, maybe add an additional type check?

				}
			}

			// Add this (opening or closing) tag to $truncate
			$truncate .= $tag[1];

			// Calculate the length of the actual tag content, accounts for html entities as a single characters
			$content_length = self::strlen($tag[3]);

			// Have we exceeded the allowed length limit, only add in what we are allowed
			if ($content_length + $total_length > $length)
			{
				// The number of characters which we can still return
				$remaining = $length - $total_length;
				$truncate .= self::substr($tag[3], 0, $remaining);
				break;
			}
			// Still room to go so add the tag content and continue
			else
			{
				$truncate .= $tag[3];
				$total_length += $content_length;
			}

			// Are we there yet?
			if ($total_length >= $length)
				break;
		}

		// Our truncated string up to the last space
		$space_pos = self::strpos($truncate, ' ', 0, true);
		$space_pos = empty($space_pos) ? $length : $space_pos;
		$truncate_check = self::substr($truncate, 0, $space_pos);

		// Make sure this would not cause a cut in the middle of a tag
		$lastOpenTag = (int) self::strpos($truncate_check, '<', 0, true);
		$lastCloseTag = (int) self::strpos($truncate_check, '>', 0, true);
		if ($lastOpenTag > $lastCloseTag)
		{
			// Find the last full open tag in our truncated string, its what was being cut
			preg_match_all('~<[\w]+[^>]*>~s', $truncate, $lastTagMatches);
			$last_tag = array_pop($lastTagMatches[0]);

			// Set the space to just after the last tag
			$space_pos = self::strpos($truncate, $last_tag, 0, true) + strlen($last_tag);
			$space_pos = empty($space_pos) ? $length : $space_pos;
		}

		// Look at what we are going to cut off the end of our truncated string
		$bits = self::substr($truncate, $space_pos);

		// Does it cut a tag off, if so we need to know so it can be added back at the cut point
		preg_match_all('~<\/([a-z]+)>~', $bits, $dropped_tags, PREG_SET_ORDER);
		if (!empty($dropped_tags))
		{
			if (!empty($open_tags))
			{
				foreach ($dropped_tags as $closing_tag)
				{
					if (!in_array($closing_tag[1], $open_tags))
						array_unshift($open_tags, $closing_tag[1]);
				}
			}
			else
			{
				foreach ($dropped_tags as $closing_tag)
					$open_tags[] = $closing_tag[1];
			}
		}

		// Cut it
		$truncate = self::substr($truncate, 0, $space_pos);

		// Dot dot dot
		$truncate .= $ellipsis;

		// Finally close any html tags that were left open
		foreach ($open_tags as $tag)
			$truncate .= '</' . $tag . '>';

		return $truncate;
	}