CssImageInlineUtils.java

package fr.sii.ogham.html.inliner.impl.regexp;

import static fr.sii.ogham.core.util.HtmlUtils.CSS_IMAGE_PROPERTIES_PATTERN;
import static fr.sii.ogham.core.util.HtmlUtils.CSS_URL_FUNC_PATTERN;
import static fr.sii.ogham.html.inliner.impl.regexp.CssImageInlinerConstants.INLINED_URL_FUNC;
import static fr.sii.ogham.html.inliner.impl.regexp.CssImageInlinerConstants.INLINE_MODE_PROPERTY;

import java.util.List;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import fr.sii.ogham.html.inliner.ImageResource;
import fr.sii.ogham.html.inliner.impl.regexp.CssImageInlinerConstants.InlineMode;

/**
 * Helper class that factorizes code for classes that are using inliners.
 * 
 * @author Aurélien Baudet
 *
 */
public final class CssImageInlineUtils {
	private static final Logger LOG = LoggerFactory.getLogger(CssImageInlineUtils.class);

	private static final String QUOTE_ENTITY = "&quot;";
	private static final String QUOTE_TEMP_ESCAPE = "&quot__semicolon__";
	private static final Pattern ESCAPE_QUOTE_ENTITIES = Pattern.compile(Pattern.quote(QUOTE_ENTITY), Pattern.CASE_INSENSITIVE);
	private static final Pattern UNESCAPE_QUOTE_ENTITIES = Pattern.compile(Pattern.quote(QUOTE_TEMP_ESCAPE), Pattern.CASE_INSENSITIVE);
	private static final Pattern RULE_START = Pattern.compile("(?<rulestart>[{])|(?<style>(?<quote>['\"])\\s*=\\s*elyts)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
	private static final Pattern INLINE_PROPERTY_PATTERN = Pattern.compile("(?<property>(?<propertyname>" + Pattern.quote(INLINE_MODE_PROPERTY) + ")\\s*:)(?<value>[^;}>]+)\\s*;?",
			Pattern.MULTILINE | Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
	private static final Pattern INLINE_PROPERTY_MODE_PATTERN = Pattern.compile("\\s*((?<imageurl>[^=]+)=(?<specificmode>[^=\"';\\s]+))|(?<globalmode>[^=;\"'\\s]+)");
	private static final Pattern INLINED_URL_PATTERN = Pattern.compile(Pattern.quote(INLINED_URL_FUNC));

	/**
	 * Search for all images included by CSS properties using {@code url()}
	 * (either defined in CSS rules or style attributes).
	 * 
	 * <p>
	 * For each matched URL, it delegates the replacement value to
	 * {@code inlineHandler} parameter. The HTML content is updated with the new
	 * URL if the image points to a local image and the handler corresponds to
	 * the inline mode.
	 * 
	 * <p>
	 * The inline mode can be specified globally (default mode if none is
	 * specified), per CSS rule or per image using
	 * {@link CssImageInlinerConstants#INLINE_MODE_PROPERTY}.
	 * 
	 * 
	 * @param htmlContent
	 *            the HTML content that may include CSS properties that points
	 *            to images that need to be inlined
	 * @param images
	 *            the images to inline
	 * @param mode
	 *            the inline mode
	 * @param inlineHandler
	 *            the handler that provides the URL replacement
	 * @return the updated HTML
	 */
	public static String inline(String htmlContent, List<ImageResource> images, InlineMode mode, Function<CssImageDeclaration, String> inlineHandler) {
		StringBuffer sb = new StringBuffer();
		String escapedHtml = escapeQuoteEntities(htmlContent);
		Matcher propertyDeclarationMatcher = CSS_IMAGE_PROPERTIES_PATTERN.matcher(escapedHtml);
		while (propertyDeclarationMatcher.find()) {
			String value = propertyDeclarationMatcher.group("value");
			Matcher urlMatcher = CSS_URL_FUNC_PATTERN.matcher(value);
			StringBuffer newValue = new StringBuffer();
			while (urlMatcher.find()) {
				boolean inlined = true;
				MatchedUrl matchedUrl = getUrl(urlMatcher);
				String newUrl = getInlinedUrl(escapedHtml, propertyDeclarationMatcher, matchedUrl, images, mode, inlineHandler);
				// if no new url => use old one
				if (newUrl == null) {
					newUrl = matchedUrl.getUrl();
					inlined = false;
				}
				urlMatcher.appendReplacement(newValue,
						Matcher.quoteReplacement(markAsInlned(inlined, urlMatcher.group("start")) + matchedUrl.getDelim() + newUrl + matchedUrl.getDelim() + urlMatcher.group("end")));
			}
			urlMatcher.appendTail(newValue);
			propertyDeclarationMatcher.appendReplacement(sb, Matcher.quoteReplacement(propertyDeclarationMatcher.group("property") + newValue.toString()));
		}
		propertyDeclarationMatcher.appendTail(sb);
		return unescapeQuoteEntities(sb.toString());
	}

	/**
	 * Checks if inlining mode is allowed on the provided element.
	 * 
	 * @param img
	 *            the image element to check if the actual inlining mode is
	 *            allowed
	 * @param mode
	 *            the actual mode
	 * @return true if this mode is allowed, false otherwise
	 */
	@SuppressWarnings("squid:S1126")
	private static boolean isInlineModeAllowed(CssImageDeclaration img, InlineMode mode) {
		// if already inlined, the regexp won't match so don't need to
		// check if skipped here

		// if inline mode defined but not the wanted mode => reject
		if (img.getMode() != null && !mode.is(img.getMode())) {
			return false;
		}
		// if inline mode defined and matches the wanted mode => allow
		// if no inline mode defined => allow (any mode allowed)
		return true;
	}

	/**
	 * Remove properties that are used only by Ogham:
	 * <ul>
	 * <li>{@link CssImageInlinerConstants#INLINE_MODE_PROPERTY}</li>
	 * <li>{@link CssImageInlinerConstants#INLINED_URL_FUNC}</li>
	 * </ul>
	 * 
	 * @param html
	 *            the html to clean
	 * @return the cleaned html
	 */
	public static String removeOghamProperties(String html) {
		String cleaned = html;
		cleaned = INLINED_URL_PATTERN.matcher(cleaned).replaceAll("url");
		cleaned = INLINE_PROPERTY_PATTERN.matcher(cleaned).replaceAll("");
		return cleaned;
	}

	private static String getInlinedUrl(String htmlContent, Matcher propertyDeclarationMatcher, MatchedUrl matchedUrl, List<ImageResource> images, InlineMode mode,
			Function<CssImageDeclaration, String> inlineHandler) {
		String url = matchedUrl.getUrl();
		ImageResource image = getImage(url, images);
		// url may match external url => simply skip it
		if (image == null) {
			LOG.debug("Skipping {}", url);
			return null;
		}
		String enclosingCssRule = getEnclosingCssRule(htmlContent, propertyDeclarationMatcher);
		CssImageDeclaration imageDeclaration = new CssImageDeclaration(matchedUrl, getInlineProperty(enclosingCssRule, matchedUrl), image);
		if (!isInlineModeAllowed(imageDeclaration, mode)) {
			return null;
		}
		return inlineHandler.apply(imageDeclaration);
	}

	private static MatchedUrl getUrl(Matcher urlMatcher) {
		String url = urlMatcher.group("unquotedurl");
		String delim = "";
		if (url != null && url.contains(QUOTE_TEMP_ESCAPE)) {
			url = removeQuoteEntities(url);
			delim = QUOTE_TEMP_ESCAPE;
		}
		if (url == null) {
			url = urlMatcher.group("singlequotedurl");
			delim = "'";
		}
		if (url == null) {
			url = urlMatcher.group("doublequotedurl");
			delim = "\"";
		}
		return new MatchedUrl(url, delim);
	}

	private static ImageResource getImage(String url, List<ImageResource> images) {
		// @formatter:off
		return images.stream()
				.filter(i -> url.equals(i.getSrcUrl()))
				.findFirst()
				.orElse(null);
		// @formatter:on
	}

	private static String unescapeQuoteEntities(String str) {
		return UNESCAPE_QUOTE_ENTITIES.matcher(str).replaceAll(QUOTE_ENTITY);
	}

	private static String removeQuoteEntities(String url) {
		return UNESCAPE_QUOTE_ENTITIES.matcher(url).replaceAll("");
	}

	private static String escapeQuoteEntities(String htmlContent) {
		return ESCAPE_QUOTE_ENTITIES.matcher(htmlContent).replaceAll(QUOTE_TEMP_ESCAPE);
	}

	private static String getEnclosingCssRule(String htmlContent, Matcher propertyDeclarationMatcher) {
		String untilPropertyDeclaration = htmlContent.substring(0, propertyDeclarationMatcher.start());
		Matcher m = RULE_START.matcher(new StringBuilder(untilPropertyDeclaration).reverse());
		int ruleStart = -1;
		char endChar = '}';
		if (m.find()) {
			ruleStart = untilPropertyDeclaration.length() - m.start();
			if (m.group("style") != null) {
				endChar = m.group("quote").charAt(0);
			}
		}
		if (ruleStart == -1) {
			// @formatter:off
			throw new IllegalStateException("Inlining of CSS images (through either background, list-style, cursor, ...) "
			 		+ "can't be performed safely because we can't determine the beginning of the enclosing CSS rule declaration.\n"
			 		+ "\n"
			 		+ "[            CSS property]="+propertyDeclarationMatcher.group()+"\n"
			 		+ "[text before CSS property]="+untilPropertyDeclaration+"\n\n"
			 		+ "can't find either { character that declares the beginning of a CSS rule "
			 		+ "or style= that declares the beginning of CSS styles on an HTML tag");
			// @formatter:on
		}
		int ruleEnd = htmlContent.indexOf(endChar, propertyDeclarationMatcher.start());
		if (ruleEnd == -1) {
			// @formatter:off
			throw new IllegalStateException("Inlining of CSS images (through either background, list-style, cursor, ...) "
			 		+ "can't be performed safely because we can't determine the end of the enclosing CSS rule declaration.\n"
			 		+ "\n"
			 		+ "[           CSS property]="+propertyDeclarationMatcher.group()+"\n"
			 		+ "[text after CSS property]="+htmlContent.substring(propertyDeclarationMatcher.end())+"\n\n"
			 		+ "can't find either } character that declares the end of a CSS rule "
			 		+ "or "+endChar+" that declares the end of CSS styles on an HTML tag");
			// @formatter:on
		}
		return htmlContent.substring(ruleStart, ruleEnd);
	}

	private static String getInlineProperty(String enclosingCssRule, MatchedUrl matchedUrl) {
		Matcher m = INLINE_PROPERTY_PATTERN.matcher(enclosingCssRule);
		if (m.find()) {
			String modes = m.group("value");
			Matcher imageModeMatcher = INLINE_PROPERTY_MODE_PATTERN.matcher(modes);
			String globalMode = null;
			while (imageModeMatcher.find()) {
				String specificInlineModeUrl = imageModeMatcher.group("imageurl");
				// specific inline mode
				if (isInlineModeForImage(specificInlineModeUrl, matchedUrl)) {
					return imageModeMatcher.group("specificmode");
				}
				// if global mode defined
				String global = imageModeMatcher.group("globalmode");
				if (global != null && globalMode == null) {
					globalMode = global;
				}
			}
			// @formatter:off
			// return either:
			//  - globalMode => global mode for all images included in the CSS rule
			//  - null => use default mode
			// @formatter:on
			return globalMode;
		}
		return null;
	}

	private static boolean isInlineModeForImage(String inlineUrl, MatchedUrl matchedUrl) {
		if (inlineUrl == null) {
			return false;
		}
		return matchedUrl.getUrl().contains(inlineUrl);
	}

	private static String markAsInlned(boolean inlined, String value) {
		if (inlined) {
			return value.replace("url", INLINED_URL_FUNC);
		}
		return value;
	}

	private CssImageInlineUtils() {
		super();
	}
}











































Active mutators

org.pitest.mutationtest.engine.gregor.mutators.BooleanFalseReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.BooleanTrueReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.ConditionalsBoundaryMutator
org.pitest.mutationtest.engine.gregor.mutators.EmptyObjectReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.IncrementsMutator
org.pitest.mutationtest.engine.gregor.mutators.InvertNegsMutator
org.pitest.mutationtest.engine.gregor.mutators.MathMutator
org.pitest.mutationtest.engine.gregor.mutators.NegateConditionalsMutator
org.pitest.mutationtest.engine.gregor.mutators.NullReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.PrimitiveReturnsMutator
org.pitest.mutationtest.engine.gregor.mutators.VoidMethodCallMutator

Tests examined

Report generated by PIT OGHAM

1		package fr.sii.ogham.html.inliner.impl.regexp;
2
3		import static fr.sii.ogham.core.util.HtmlUtils.CSS_IMAGE_PROPERTIES_PATTERN;
4		import static fr.sii.ogham.core.util.HtmlUtils.CSS_URL_FUNC_PATTERN;
5		import static fr.sii.ogham.html.inliner.impl.regexp.CssImageInlinerConstants.INLINED_URL_FUNC;
6		import static fr.sii.ogham.html.inliner.impl.regexp.CssImageInlinerConstants.INLINE_MODE_PROPERTY;
7
8		import java.util.List;
9		import java.util.function.Function;
10		import java.util.regex.Matcher;
11		import java.util.regex.Pattern;
12
13		import org.slf4j.Logger;
14		import org.slf4j.LoggerFactory;
15
16		import fr.sii.ogham.html.inliner.ImageResource;
17		import fr.sii.ogham.html.inliner.impl.regexp.CssImageInlinerConstants.InlineMode;
18
19		/**
20		* Helper class that factorizes code for classes that are using inliners.
21		*
22		* @author Aurélien Baudet
23		*
24		*/
25		public final class CssImageInlineUtils {
26		private static final Logger LOG = LoggerFactory.getLogger(CssImageInlineUtils.class);
27
28		private static final String QUOTE_ENTITY = """;
29		private static final String QUOTE_TEMP_ESCAPE = "&quot__semicolon__";
30		private static final Pattern ESCAPE_QUOTE_ENTITIES = Pattern.compile(Pattern.quote(QUOTE_ENTITY), Pattern.CASE_INSENSITIVE);
31		private static final Pattern UNESCAPE_QUOTE_ENTITIES = Pattern.compile(Pattern.quote(QUOTE_TEMP_ESCAPE), Pattern.CASE_INSENSITIVE);
32		private static final Pattern RULE_START = Pattern.compile("(?<rulestart>[{])\|(?<style>(?<quote>['\"])\\s=\\selyts)", Pattern.CASE_INSENSITIVE \| Pattern.MULTILINE);
33		private static final Pattern INLINE_PROPERTY_PATTERN = Pattern.compile("(?<property>(?<propertyname>" + Pattern.quote(INLINE_MODE_PROPERTY) + ")\\s:)(?<value>[^;}>]+)\\s;?",
34		Pattern.MULTILINE \| Pattern.DOTALL \| Pattern.CASE_INSENSITIVE);
35		private static final Pattern INLINE_PROPERTY_MODE_PATTERN = Pattern.compile("\\s*((?<imageurl>[^=]+)=(?<specificmode>[^=\"';\\s]+))\|(?<globalmode>[^=;\"'\\s]+)");
36		private static final Pattern INLINED_URL_PATTERN = Pattern.compile(Pattern.quote(INLINED_URL_FUNC));
37
38		/**
39		* Search for all images included by CSS properties using {@code url()}
40		* (either defined in CSS rules or style attributes).

CssImageInlineUtils.java

Mutations

Active mutators

Tests examined