src/main/java/com/googlesource/gerrit/plugins/xdocs/formatter/FormatterUtil.java - plugins/x-docs - Git at Google

 // Copyright (C) 2014 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.googlesource.gerrit.plugins.xdocs.formatter;

 import static com.googlesource.gerrit.plugins.xdocs.XDocGlobalConfig.KEY_CSS_THEME;
 import static com.googlesource.gerrit.plugins.xdocs.XDocGlobalConfig.KEY_INHERIT_CSS;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.apache.commons.lang.StringEscapeUtils.escapeHtml;

 import com.google.common.base.Joiner;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.Strings;
 import com.google.gerrit.extensions.annotations.PluginData;
 import com.google.gerrit.extensions.annotations.PluginName;
 import com.google.gerrit.reviewdb.client.Project;
 import com.google.gerrit.reviewdb.client.RefNames;
 import com.google.gerrit.server.git.GitRepositoryManager;
 import com.google.gerrit.server.project.ProjectCache;
 import com.google.gerrit.server.project.ProjectState;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;

 import com.googlesource.gerrit.plugins.xdocs.ConfigSection;

 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.ObjectLoader;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevTree;
 import org.eclipse.jgit.revwalk.RevWalk;
 import org.eclipse.jgit.treewalk.TreeWalk;
 import org.eclipse.jgit.treewalk.filter.PathFilter;
 import org.eclipse.jgit.util.TemporaryBuffer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;

 @Singleton
 public class FormatterUtil {
   private static final Logger log = LoggerFactory.getLogger(FormatterUtil.class);

   private final String pluginName;
   private final File baseDir;
   private final GitRepositoryManager repoManager;
   private final ProjectCache projectCache;
   private final Formatters formatters;
   private final Map<String, String> defaultCss;

   @Inject
   FormatterUtil(@PluginName String pluginName,
       @PluginData File baseDir,
       GitRepositoryManager repoManager,
       ProjectCache projectCache,
       Formatters formatters) {
     this.pluginName = pluginName;
     this.baseDir = baseDir;
     this.repoManager = repoManager;
     this.projectCache = projectCache;
     this.formatters = formatters;
     this.defaultCss = new HashMap<>();
   }

   /**
    * Returns the CSS from the file "<plugin-name>/<name>-<theme>.css" in the
    * refs/meta/config branch of the project.
    *
    * If theme is <code>null</code> or empty, the CSS from the file
    * "<plugin-name>/<name>.css" is returned.
    *
    * @param name the name of the file in the "<plugin-name>/" folder without
    *        theme and without the ".css" file extension
    * @param theme the name of the CSS theme, may be <code>null</code>, if given
    *        it is included into the CSS file name: '<name>-<theme>.css'
    * @return the CSS from the file; HTML characters are escaped;
    *         <code>null</code> if the file doesn't exist
    */
   public String getCss(String projectName, String name, String theme) {
     return Strings.isNullOrEmpty(theme)
         ? getCss(projectName, name)
         : getCss(projectName, name + "-" + theme);
   }

   /**
    * Returns the CSS from the file "<plugin-name>/<name>.css" in the
    * refs/meta/config branch of the project.
    *
    * @param name the name of the file in the "<plugin-name>/" folder without the
    *        ".css" file extension
    * @return the CSS from the file; HTML characters are escaped;
    *         <code>null</code> if the file doesn't exist
    */
   public String getCss(String projectName, String name) {
     return escapeHtml(getMetaConfigFile(projectName, name + ".css"));
   }

   /**
    * Returns the inherited CSS.
    *
    * If the project has a parent project the CSS of the parent project is
    * returned; if there is no parent project the global CSS is returned.
    *
    * @param projectName the name of the project
    * @param formatterName the name of the formatter for which the CSS should be
    *        returned
    * @param name the name of the CSS file without theme and without the ".css"
    *        file extension
    * @param theme the name of the CSS theme, may be <code>null</code>, if given
    *        it is included into the CSS file name: '<name>-<theme>.css'
    * @return the inherited CSS; HTML characters are escaped; <code>null</code>
    *         if there is no inherited CSS
    * @throws IOException thrown in case of an I/O Error while reading the global
    *         CSS file
    */
   public String getInheritedCss(String projectName, String formatterName,
       String name, String theme) throws IOException {
     return getInheritedCss(projectCache.get(new Project.NameKey(projectName)),
         formatterName, name, theme);
   }

   private String getInheritedCss(ProjectState project, String formatterName,
     String name, String theme) throws IOException {
     for (ProjectState parent : project.parents()) {
       String css = getCss(parent.getProject().getName(), name, theme);
       ConfigSection cfg =
           formatters.getFormatterConfig(formatterName, parent);
       if (cfg.getBoolean(KEY_INHERIT_CSS, true)) {
         return joinCss(getInheritedCss(parent, formatterName, name, theme), css);
       } else {
         return css;
       }
     }
     return getGlobalCss(name, theme);
   }

   private String joinCss(String css1, String css2) {
     if (css1 == null) {
       return css2;
     }
     if (css2 == null) {
       return css1;
     }
     return Joiner.on('\n').join(css1, css2);
   }

   /**
    * Returns the CSS from the file
    * "<review-site>/data/<plugin-name>/css/<name>-<theme>.css".
    *
    * If theme is <code>null</code> or empty, the CSS from the file
    * "<review-site>/data/<plugin-name>/css/<name>.css" is returned.
    *
    * @param name the name of the CSS file without theme and without the ".css"
    *        file extension
    * @param theme the name of the CSS theme, may be <code>null</code>, if given
    *        it is included into the CSS file name: '<name>-<theme>.css'
    * @return the CSS from the file; HTML characters are escaped;
    *         <code>null</code> if the file doesn't exist
    * @throws IOException thrown in case of an I/O Error while reading the CSS
    *         file
    */
   public String getGlobalCss(String name, String theme) throws IOException {
     return Strings.isNullOrEmpty(theme)
         ? getGlobalCss(name)
         : getGlobalCss(name + "-" + theme);
   }

   /**
    * Returns the CSS from the file
    * "<review-site>/data/<plugin-name>/css/<name>.css".
    *
    * @param name the name of the CSS file without the ".css" file extension
    * @return the CSS from the file; HTML characters are escaped;
    *         <code>null</code> if the file doesn't exist
    * @throws IOException thrown in case of an I/O Error while reading the CSS
    *         file
    */
   public String getGlobalCss(String name) throws IOException {
     Path p = Paths.get(baseDir.getAbsolutePath(), "css", name + ".css");
     if (Files.exists(p)) {
       byte[] css = Files.readAllBytes(p);
       return escapeHtml(new String(css, UTF_8));
     }
     return null;
   }

   public String applyCss(String html, String formatterName, String projectName)
       throws IOException {
     ConfigSection projectCfg =
         formatters.getFormatterConfig(formatterName, projectName);
     String cssName = formatterName.toLowerCase(Locale.US);
     String cssTheme = projectCfg.getString(KEY_CSS_THEME);
     String defaultCss = getDefaultCss(formatterName);
     String inheritedCss =
         getInheritedCss(projectName, formatterName, cssName, cssTheme);
     String projectCss = getCss(projectName, cssName, cssTheme);
     if (projectCfg.getBoolean(KEY_INHERIT_CSS, true)) {
       return insertCss(html,
           MoreObjects.firstNonNull(inheritedCss, defaultCss), projectCss);
     } else {
       return insertCss(html,
           MoreObjects.firstNonNull(projectCss,
               MoreObjects.firstNonNull(inheritedCss, defaultCss)));
     }
   }

   private String getDefaultCss(String formatterName) throws IOException {
     String css = defaultCss.get(formatterName) ;
     if (css == null) {
       URL url = FormatterUtil.class.getResource(
           formatterName.toLowerCase(Locale.US) + ".css");
       if (url != null) {
         try (InputStream in = url.openStream();
             TemporaryBuffer.Heap tmp = new TemporaryBuffer.Heap(128 * 1024)) {
           tmp.copy(in);
           css = new String(tmp.toByteArray(), UTF_8);
         }
       } else {
         log.info(String.format("No default CSS for formatter '%s' found.",
             formatterName));
         css = "";
       }
       defaultCss.put(formatterName, css);
     }
     return css;
   }

   /**
    * Inserts the given CSS into the given HTML.
    *
    * @param html the HTML
    * @param css the CSS, may be <code>null</code>
    * @return the HTML that includes the CSS
    */
   public String insertCss(String html, String css) {
     if (html == null || css == null) {
       return html;
     }

     return insertCss(html, css, null);
   }

   /**
    * Inserts the given CSS's into the given HTML.
    *
    * @param html the HTML
    * @param css1 first CSS, may be <code>null</code>
    * @param css2 second CSS, may be <code>null</code>
    * @return the HTML that includes the CSS
    */
   public String insertCss(String html, String css1, String css2) {
     if (html == null || (css1 == null && css2 == null)) {
       return html;
     }

     int p = html.lastIndexOf("</body>");
     if (p > 0) {
       StringBuilder b = new StringBuilder();
       b.append(html.substring(0, p));
       if (css1 != null) {
         b.append("<style type=\"text/css\">\n");
         b.append(css1);
         b.append("</style>\n");
       }
       if (css2 != null) {
         b.append("<style type=\"text/css\">\n");
         b.append(css2);
         b.append("</style>\n");
       }
       b.append(html.substring(p));
       return b.toString();
     } else {
       return html;
     }
   }

   /**
    * Returns the content of the specified file from the "<plugin-name>/" folder
    * of the ref/meta/config branch.
    *
    * @param projectName the name of the project
    * @param fileName the name of the file in the "<plugin-name>/" folder
    * @return the file content, <code>null</code> if the file doesn't exist
    */
   public String getMetaConfigFile(String projectName, String fileName) {
     try (Repository repo = repoManager.openRepository(
         new Project.NameKey(projectName))) {
       try (RevWalk rw = new RevWalk(repo)) {
         ObjectId id = repo.resolve(RefNames.REFS_CONFIG);
         if (id == null) {
           return null;
         }
         RevCommit commit = rw.parseCommit(id);
         RevTree tree = commit.getTree();
         try (TreeWalk tw = new TreeWalk(repo)) {
           tw.addTree(tree);
           tw.setRecursive(true);
           tw.setFilter(PathFilter.create(pluginName + "/" + fileName));
           if (!tw.next()) {
             return null;
           }
           ObjectId objectId = tw.getObjectId(0);
           ObjectLoader loader = repo.open(objectId);
           byte[] raw = loader.getBytes(Integer.MAX_VALUE);
           return new String(raw, UTF_8);
         }
       }
     } catch (IOException e) {
       return null;
     }
   }
 }
	// Copyright (C) 2014 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.googlesource.gerrit.plugins.xdocs.formatter;

	import static com.googlesource.gerrit.plugins.xdocs.XDocGlobalConfig.KEY_CSS_THEME;
	import static com.googlesource.gerrit.plugins.xdocs.XDocGlobalConfig.KEY_INHERIT_CSS;
	import static java.nio.charset.StandardCharsets.UTF_8;
	import static org.apache.commons.lang.StringEscapeUtils.escapeHtml;

	import com.google.common.base.Joiner;
	import com.google.common.base.MoreObjects;
	import com.google.common.base.Strings;
	import com.google.gerrit.extensions.annotations.PluginData;
	import com.google.gerrit.extensions.annotations.PluginName;
	import com.google.gerrit.reviewdb.client.Project;
	import com.google.gerrit.reviewdb.client.RefNames;
	import com.google.gerrit.server.git.GitRepositoryManager;
	import com.google.gerrit.server.project.ProjectCache;
	import com.google.gerrit.server.project.ProjectState;
	import com.google.inject.Inject;
	import com.google.inject.Singleton;

	import com.googlesource.gerrit.plugins.xdocs.ConfigSection;

	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.ObjectLoader;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.revwalk.RevCommit;
	import org.eclipse.jgit.revwalk.RevTree;
	import org.eclipse.jgit.revwalk.RevWalk;
	import org.eclipse.jgit.treewalk.TreeWalk;
	import org.eclipse.jgit.treewalk.filter.PathFilter;
	import org.eclipse.jgit.util.TemporaryBuffer;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URL;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.util.HashMap;
	import java.util.Locale;
	import java.util.Map;

	@Singleton
	public class FormatterUtil {
	private static final Logger log = LoggerFactory.getLogger(FormatterUtil.class);

	private final String pluginName;
	private final File baseDir;
	private final GitRepositoryManager repoManager;
	private final ProjectCache projectCache;
	private final Formatters formatters;
	private final Map<String, String> defaultCss;

	@Inject
	FormatterUtil(@PluginName String pluginName,
	@PluginData File baseDir,
	GitRepositoryManager repoManager,
	ProjectCache projectCache,
	Formatters formatters) {
	this.pluginName = pluginName;
	this.baseDir = baseDir;
	this.repoManager = repoManager;
	this.projectCache = projectCache;
	this.formatters = formatters;
	this.defaultCss = new HashMap<>();
	}

	/**
	* Returns the CSS from the file "<plugin-name>/<name>-<theme>.css" in the
	* refs/meta/config branch of the project.
	*
	* If theme is <code>null</code> or empty, the CSS from the file
	* "<plugin-name>/<name>.css" is returned.
	*
	* @param name the name of the file in the "<plugin-name>/" folder without
	* theme and without the ".css" file extension
	* @param theme the name of the CSS theme, may be <code>null</code>, if given
	* it is included into the CSS file name: '<name>-<theme>.css'
	* @return the CSS from the file; HTML characters are escaped;
	* <code>null</code> if the file doesn't exist
	*/
	public String getCss(String projectName, String name, String theme) {
	return Strings.isNullOrEmpty(theme)
	? getCss(projectName, name)
	: getCss(projectName, name + "-" + theme);
	}

	/**
	* Returns the CSS from the file "<plugin-name>/<name>.css" in the
	* refs/meta/config branch of the project.
	*
	* @param name the name of the file in the "<plugin-name>/" folder without the
	* ".css" file extension
	* @return the CSS from the file; HTML characters are escaped;
	* <code>null</code> if the file doesn't exist
	*/
	public String getCss(String projectName, String name) {
	return escapeHtml(getMetaConfigFile(projectName, name + ".css"));
	}

	/**
	* Returns the inherited CSS.
	*
	* If the project has a parent project the CSS of the parent project is
	* returned; if there is no parent project the global CSS is returned.
	*
	* @param projectName the name of the project
	* @param formatterName the name of the formatter for which the CSS should be
	* returned
	* @param name the name of the CSS file without theme and without the ".css"
	* file extension
	* @param theme the name of the CSS theme, may be <code>null</code>, if given
	* it is included into the CSS file name: '<name>-<theme>.css'
	* @return the inherited CSS; HTML characters are escaped; <code>null</code>
	* if there is no inherited CSS
	* @throws IOException thrown in case of an I/O Error while reading the global
	* CSS file
	*/
	public String getInheritedCss(String projectName, String formatterName,
	String name, String theme) throws IOException {
	return getInheritedCss(projectCache.get(new Project.NameKey(projectName)),
	formatterName, name, theme);
	}

	private String getInheritedCss(ProjectState project, String formatterName,
	String name, String theme) throws IOException {
	for (ProjectState parent : project.parents()) {
	String css = getCss(parent.getProject().getName(), name, theme);
	ConfigSection cfg =
	formatters.getFormatterConfig(formatterName, parent);
	if (cfg.getBoolean(KEY_INHERIT_CSS, true)) {
	return joinCss(getInheritedCss(parent, formatterName, name, theme), css);
	} else {
	return css;
	}
	}
	return getGlobalCss(name, theme);
	}

	private String joinCss(String css1, String css2) {
	if (css1 == null) {
	return css2;
	}
	if (css2 == null) {
	return css1;
	}
	return Joiner.on('\n').join(css1, css2);
	}

	/**
	* Returns the CSS from the file
	* "<review-site>/data/<plugin-name>/css/<name>-<theme>.css".
	*
	* If theme is <code>null</code> or empty, the CSS from the file
	* "<review-site>/data/<plugin-name>/css/<name>.css" is returned.
	*
	* @param name the name of the CSS file without theme and without the ".css"
	* file extension
	* @param theme the name of the CSS theme, may be <code>null</code>, if given
	* it is included into the CSS file name: '<name>-<theme>.css'
	* @return the CSS from the file; HTML characters are escaped;
	* <code>null</code> if the file doesn't exist
	* @throws IOException thrown in case of an I/O Error while reading the CSS
	* file
	*/
	public String getGlobalCss(String name, String theme) throws IOException {
	return Strings.isNullOrEmpty(theme)
	? getGlobalCss(name)
	: getGlobalCss(name + "-" + theme);
	}

	/**
	* Returns the CSS from the file
	* "<review-site>/data/<plugin-name>/css/<name>.css".
	*
	* @param name the name of the CSS file without the ".css" file extension
	* @return the CSS from the file; HTML characters are escaped;
	* <code>null</code> if the file doesn't exist
	* @throws IOException thrown in case of an I/O Error while reading the CSS
	* file
	*/
	public String getGlobalCss(String name) throws IOException {
	Path p = Paths.get(baseDir.getAbsolutePath(), "css", name + ".css");
	if (Files.exists(p)) {
	byte[] css = Files.readAllBytes(p);
	return escapeHtml(new String(css, UTF_8));
	}
	return null;
	}

	public String applyCss(String html, String formatterName, String projectName)
	throws IOException {
	ConfigSection projectCfg =
	formatters.getFormatterConfig(formatterName, projectName);
	String cssName = formatterName.toLowerCase(Locale.US);
	String cssTheme = projectCfg.getString(KEY_CSS_THEME);
	String defaultCss = getDefaultCss(formatterName);
	String inheritedCss =
	getInheritedCss(projectName, formatterName, cssName, cssTheme);
	String projectCss = getCss(projectName, cssName, cssTheme);
	if (projectCfg.getBoolean(KEY_INHERIT_CSS, true)) {
	return insertCss(html,
	MoreObjects.firstNonNull(inheritedCss, defaultCss), projectCss);
	} else {
	return insertCss(html,
	MoreObjects.firstNonNull(projectCss,
	MoreObjects.firstNonNull(inheritedCss, defaultCss)));
	}
	}

	private String getDefaultCss(String formatterName) throws IOException {
	String css = defaultCss.get(formatterName) ;
	if (css == null) {
	URL url = FormatterUtil.class.getResource(
	formatterName.toLowerCase(Locale.US) + ".css");
	if (url != null) {
	try (InputStream in = url.openStream();
	TemporaryBuffer.Heap tmp = new TemporaryBuffer.Heap(128 * 1024)) {
	tmp.copy(in);
	css = new String(tmp.toByteArray(), UTF_8);
	}
	} else {
	log.info(String.format("No default CSS for formatter '%s' found.",
	formatterName));
	css = "";
	}
	defaultCss.put(formatterName, css);
	}
	return css;
	}

	/**
	* Inserts the given CSS into the given HTML.
	*
	* @param html the HTML
	* @param css the CSS, may be <code>null</code>
	* @return the HTML that includes the CSS
	*/
	public String insertCss(String html, String css) {
	if (html == null \|\| css == null) {
	return html;
	}

	return insertCss(html, css, null);
	}

	/**
	* Inserts the given CSS's into the given HTML.
	*
	* @param html the HTML
	* @param css1 first CSS, may be <code>null</code>
	* @param css2 second CSS, may be <code>null</code>
	* @return the HTML that includes the CSS
	*/
	public String insertCss(String html, String css1, String css2) {
	if (html == null \|\| (css1 == null && css2 == null)) {
	return html;
	}

	int p = html.lastIndexOf("</body>");
	if (p > 0) {
	StringBuilder b = new StringBuilder();
	b.append(html.substring(0, p));
	if (css1 != null) {
	b.append("<style type=\"text/css\">\n");
	b.append(css1);
	b.append("</style>\n");
	}
	if (css2 != null) {
	b.append("<style type=\"text/css\">\n");
	b.append(css2);
	b.append("</style>\n");
	}
	b.append(html.substring(p));
	return b.toString();
	} else {
	return html;
	}
	}

	/**
	* Returns the content of the specified file from the "<plugin-name>/" folder
	* of the ref/meta/config branch.
	*
	* @param projectName the name of the project
	* @param fileName the name of the file in the "<plugin-name>/" folder
	* @return the file content, <code>null</code> if the file doesn't exist
	*/
	public String getMetaConfigFile(String projectName, String fileName) {
	try (Repository repo = repoManager.openRepository(
	new Project.NameKey(projectName))) {
	try (RevWalk rw = new RevWalk(repo)) {
	ObjectId id = repo.resolve(RefNames.REFS_CONFIG);
	if (id == null) {
	return null;
	}
	RevCommit commit = rw.parseCommit(id);
	RevTree tree = commit.getTree();
	try (TreeWalk tw = new TreeWalk(repo)) {
	tw.addTree(tree);
	tw.setRecursive(true);
	tw.setFilter(PathFilter.create(pluginName + "/" + fileName));
	if (!tw.next()) {
	return null;
	}
	ObjectId objectId = tw.getObjectId(0);
	ObjectLoader loader = repo.open(objectId);
	byte[] raw = loader.getBytes(Integer.MAX_VALUE);
	return new String(raw, UTF_8);
	}
	}
	} catch (IOException e) {
	return null;
	}
	}
	}