| // 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; |
| } |
| } |
| } |