JsoupCssInliner.java

  1. package fr.sii.ogham.html.inliner.impl.jsoup;

  3. import static fr.sii.ogham.core.util.HtmlUtils.getCssUrlFunctions;
  4. import static fr.sii.ogham.core.util.HtmlUtils.relativize;
  5. import static fr.sii.ogham.html.inliner.impl.jsoup.CssInlineUtils.isInlineModeAllowed;

  7. import java.util.List;
  8. import java.util.StringTokenizer;
  9. import java.util.regex.Pattern;

  11. import org.jsoup.Jsoup;
  12. import org.jsoup.nodes.DataNode;
  13. import org.jsoup.nodes.Document;
  14. import org.jsoup.nodes.Element;
  15. import org.jsoup.parser.Tag;
  16. import org.jsoup.select.Elements;
  17. import org.slf4j.Logger;
  18. import org.slf4j.LoggerFactory;

  20. import fr.sii.ogham.core.util.CssUrlFunction;
  21. import fr.sii.ogham.html.inliner.CssInliner;
  22. import fr.sii.ogham.html.inliner.CssInlinerConstants.InlineModes;
  23. import fr.sii.ogham.html.inliner.ExternalCss;

  25. public class JsoupCssInliner implements CssInliner {
  26.     private static final Logger LOG = LoggerFactory.getLogger(JsoupCssInliner.class);
  27.     
  28.     private static final String HREF_ATTR = "href";
  29.     private static final String TEMP_STYLE_ATTR = "data-cssstyle";
  30.     private static final String STYLE_ATTR = "style";
  31.     private static final String STYLE_TAG = "style";
  32.     private static final String CSS_LINKS_SELECTOR = "link[rel*=\"stylesheet\"], link[type=\"text/css\"], link[href$=\".css\"]";
  33.     private static final Pattern NEW_LINES = Pattern.compile("\n");
  34.     private static final Pattern COMMENTS = Pattern.compile("/\\*.*?\\*/");
  35.     private static final Pattern SPACES = Pattern.compile(" +");
  36.     private static final String QUOTE_ENTITY = """;

  38.     @Override
  39.     public String inline(String htmlContent, List<ExternalCss> cssContents) {
  40.         Document doc = Jsoup.parse(htmlContent);

  42.         internStyles(doc, cssContents);
  43.         String stylesheet = fetchStyles(doc);
  44.         extractStyles(doc, stylesheet);
  45.         applyStyles(doc);

  47.         return doc.outerHtml();
  48.     }

  50.     /**
  51.      * Applies the styles to a <code>data-cssstyle</code> attribute. This is
  52.      * because the styles need to be applied sequentially, but before the
  53.      * <code>style</code> defined for the element inline.
  54.      *
  55.      * @param doc
  56.      *            the html document
  57.      */
  58.     private static void extractStyles(Document doc, String stylesheet) {
  59.         String cleanedStylesheet = ignoreAtRules(stylesheet);
  60.         cleanedStylesheet = NEW_LINES.matcher(cleanedStylesheet).replaceAll("");
  61.         cleanedStylesheet = COMMENTS.matcher(cleanedStylesheet).replaceAll("");
  62.         cleanedStylesheet = SPACES.matcher(cleanedStylesheet).replaceAll(" ");
  63.         String styleRules = cleanedStylesheet.trim();
  64.         String delims = "{}";
  65.         StringTokenizer st = new StringTokenizer(styleRules, delims);
  66.         while (st.countTokens() > 1) {
  67.             String selector = st.nextToken();
  68.             String properties = st.nextToken();
  69.             Elements selectedElements = doc.select(selector.trim());
  70.             for (Element selElem : selectedElements) {
  71.                 String oldProperties = selElem.attr(TEMP_STYLE_ATTR);
  72.                 selElem.attr(TEMP_STYLE_ATTR, oldProperties.length() > 0 ? concatenateProperties(oldProperties, properties) : properties);
  73.             }
  74.         }
  75.     }
  76.     
  77.     /**
  78.      * Replace link tags with style tags in order to keep the same inclusion
  79.      * order
  80.      *
  81.      * @param doc
  82.      *            the html document
  83.      * @param cssContents
  84.      *            the list of external css files with their content
  85.      */
  86.     private static void internStyles(Document doc, List<ExternalCss> cssContents) {
  87.         Elements els = doc.select(CSS_LINKS_SELECTOR);
  88.         for (Element e : els) {
  89.             if (isInlineModeAllowed(e, InlineModes.STYLE_ATTR)) {
  90.                 String path = e.attr(HREF_ATTR);
  91.                 ExternalCss css = getCss(cssContents, path);
  92.                 if (css != null) {
  93.                     Element style = new Element(Tag.valueOf(STYLE_TAG), "");
  94.                     style.appendChild(new DataNode(getCssContent(css)));
  95.                     e.replaceWith(style);
  96.                 }
  97.             }
  98.         }
  99.     }

  101.     private static ExternalCss getCss(List<ExternalCss> cssContents, String path) {
  102.         for (ExternalCss css : cssContents) {
  103.             if (css.getPath().getOriginalPath().contains(path)) {
  104.                 return css;
  105.             }
  106.         }
  107.         return null;
  108.     }

  110.     /**
  111.      * Generates a stylesheet from an html document
  112.      *
  113.      * @param doc
  114.      *            the html document
  115.      * @return a string representing the stylesheet.
  116.      */
  117.     private static String fetchStyles(Document doc) {
  118.         Elements els = doc.select(STYLE_TAG);
  119.         StringBuilder styles = new StringBuilder();
  120.         for (Element e : els) {
  121.             if (isInlineModeAllowed(e, InlineModes.STYLE_ATTR)) {
  122.                 styles.append(e.data());
  123.                 e.remove();
  124.             }
  125.         }
  126.         return styles.toString();
  127.     }

  129.     /**
  130.      * Transfers styles from the <code>data-cssstyle</code> attribute to the
  131.      * <code>style</code> attribute.
  132.      *
  133.      * @param doc
  134.      *            the html document
  135.      */
  136.     private static void applyStyles(Document doc) {
  137.         Elements allStyledElements = doc.getElementsByAttribute(TEMP_STYLE_ATTR);

  139.         for (Element e : allStyledElements) {
  140.             if (isInlineModeAllowed(e, InlineModes.STYLE_ATTR)) {
  141.                 String newStyle = e.attr(TEMP_STYLE_ATTR);
  142.                 String oldStyle = e.attr(STYLE_ATTR);
  143.                 e.attr(STYLE_ATTR, (trimAll(newStyle) + ";" + trimAll(oldStyle)).replaceAll(";+", ";").trim());
  144.             }
  145.             e.removeAttr(TEMP_STYLE_ATTR);
  146.         }
  147.     }

  149.     private static String concatenateProperties(String oldProp, String newProp) {
  150.         String prop = oldProp;
  151.         if (!prop.endsWith(";")) {
  152.             prop += ";";
  153.         }
  154.         return trimAll(prop) + " " + trimAll(newProp) + ";";
  155.     }
  156.     
  157.     private static String trimAll(String str) {
  158.         return str.replaceAll("\\s+", " ").trim();
  159.     }
  160.     

  162.     private static String ignoreAtRules(String stylesheet) {
  163.         StringBuilder sb = new StringBuilder();
  164.         AtRuleParserContext ctx = new AtRuleParserContext();
  165.         for (int i=0 ; i<stylesheet.length() ; i++) {
  166.             char c = stylesheet.charAt(i);
  167.             updateLineNumberIfNewLine(ctx, c);
  168.             markAsStartOfAtRuleIfAtChar(ctx, c);
  169.             markAsStartOfNestedAtRuleIfAlreadyInAtRuleAndIsOpeningBracket(ctx, c);
  170.             markAsEndOfNestedAtRuleIfAlreadyInAtRuleAndIsClosingBracket(ctx, c);
  171.             if (ignoreAtRuleIfAtEndOfAtRule(ctx, c)) {
  172.                 continue;
  173.             }
  174.             updateStylesAndAtRuleContent(ctx, sb, c);
  175.         }
  176.         return sb.toString();
  177.     }

  179.     private static boolean ignoreAtRuleIfAtEndOfAtRule(AtRuleParserContext ctx, char c) {
  180.         if (ctx.inAtRule && !ctx.inNestedAtRule && c == ';') {
  181.             ctx.inAtRule = false;
  182.             LOG.warn("{} rule is not handled by JsoupCssInliner implementation. Line {}:'{}' is skipped", rulename(ctx.rule), ctx.startLineOfCurrentAtRule, ctx.rule);
  183.             return true;
  184.         }
  185.         if (ctx.inAtRule && ctx.inNestedAtRule && ctx.numberOfOpenedAtRules == 0) {
  186.             ctx.inAtRule = false;
  187.             ctx.inNestedAtRule = false;
  188.             LOG.warn("{} rule is not handled by JsoupCssInliner implementation. Lines {}-{} are skipped", rulename(ctx.rule), ctx.startLineOfCurrentAtRule, ctx.line);
  189.             return true;
  190.         }
  191.         return false;
  192.     }

  194.     private static void updateStylesAndAtRuleContent(AtRuleParserContext ctx, StringBuilder sb, char c) {
  195.         if (!ctx.inAtRule) {
  196.             sb.append(c);
  197.             ctx.rule = new StringBuilder();
  198.         } else {
  199.             ctx.rule.append(c);
  200.         }
  201.     }

  203.     private static void markAsEndOfNestedAtRuleIfAlreadyInAtRuleAndIsClosingBracket(AtRuleParserContext ctx, char c) {
  204.         if (ctx.inAtRule && ctx.inNestedAtRule && c == '}') {
  205.             ctx.numberOfOpenedAtRules--;
  206.         }
  207.     }

  209.     private static void markAsStartOfNestedAtRuleIfAlreadyInAtRuleAndIsOpeningBracket(AtRuleParserContext ctx, char c) {
  210.         if (ctx.inAtRule && c == '{') {
  211.             ctx.inNestedAtRule = true;
  212.             ctx.numberOfOpenedAtRules++;
  213.         }
  214.     }

  216.     private static void markAsStartOfAtRuleIfAtChar(AtRuleParserContext ctx, char c) {
  217.         if (c == '@' && !ctx.inAtRule) {
  218.             ctx.inAtRule = true;
  219.             ctx.startLineOfCurrentAtRule = ctx.line;
  220.         }
  221.     }

  223.     private static void updateLineNumberIfNewLine(AtRuleParserContext ctx, char c) {
  224.         if (c == '\n') {
  225.             ctx.line++;
  226.         }
  227.     }
  228.     
  229.     private static String rulename(StringBuilder rule) {
  230.         StringBuilder name = new StringBuilder();
  231.         for (int i=0 ; i<rule.length() ; i++) {
  232.             char c = rule.charAt(i);
  233.             if (c != '@' && c != '-' && !Character.isAlphabetic(c) && !Character.isDigit(c)) {
  234.                 break;
  235.             }
  236.             name.append(c);
  237.         }
  238.         return name.toString();
  239.     }


  242.     private static String getCssContent(ExternalCss css) {
  243.         String content = css.getContent();
  244.         return updateRelativeUrls(content, css);
  245.     }

  247.     private static String updateRelativeUrls(String content, ExternalCss css) {
  248.         String newContent = content;
  249.         for (CssUrlFunction match : getCssUrlFunctions(content, QUOTE_ENTITY)) {
  250.             newContent = match.rewriteUrl(newContent, relativize(css.getPath().getOriginalPath(), match.getUrl()));
  251.         }
  252.         return newContent;
  253.     }

  255.     private static class AtRuleParserContext {
  256.         protected int line;
  257.         protected int startLineOfCurrentAtRule;
  258.         protected boolean inAtRule;
  259.         protected boolean inNestedAtRule;
  260.         protected int numberOfOpenedAtRules;
  261.         protected StringBuilder rule;
  262.         
  263.         public AtRuleParserContext() {
  264.             super();
  265.             this.line = 1;
  266.             this.startLineOfCurrentAtRule = 0;
  267.             this.inAtRule = false;
  268.             this.inNestedAtRule = false;
  269.             this.numberOfOpenedAtRules = 0;
  270.             this.rule = new StringBuilder();
  271.         }
  272.         
  273.         
  274.     }
  275. }
Created with JaCoCo 0.8.4.201905082037