org.sonar.plugins.javascript.analysis.CssRuleSensor Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of sonar-javascript-plugin Show documentation
Show all versions of sonar-javascript-plugin Show documentation
Code Analyzer for JavaScript/TypeScript/CSS
/*
* SonarQube JavaScript Plugin
* Copyright (C) 2011-2024 SonarSource SA
* mailto:info AT sonarsource DOT com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.sonar.plugins.javascript.analysis;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.StreamSupport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.SonarProduct;
import org.sonar.api.SonarRuntime;
import org.sonar.api.batch.fs.FilePredicate;
import org.sonar.api.batch.fs.FileSystem;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.rule.CheckFactory;
import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.SensorDescriptor;
import org.sonar.api.batch.sensor.issue.NewIssue;
import org.sonar.api.batch.sensor.issue.NewIssueLocation;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.Version;
import org.sonar.css.CssLanguage;
import org.sonar.css.CssRules;
import org.sonar.plugins.javascript.CancellationException;
import org.sonar.plugins.javascript.bridge.BridgeServer;
import org.sonar.plugins.javascript.bridge.BridgeServer.CssAnalysisRequest;
import org.sonar.plugins.javascript.bridge.BridgeServer.Issue;
import org.sonar.plugins.javascript.bridge.StylelintRule;
import org.sonar.plugins.javascript.utils.ProgressReport;
public class CssRuleSensor extends AbstractBridgeSensor {
private static final Logger LOG = LoggerFactory.getLogger(CssRuleSensor.class);
private final SonarRuntime sonarRuntime;
private final CssRules cssRules;
public CssRuleSensor(
SonarRuntime sonarRuntime,
BridgeServer bridgeServer,
CheckFactory checkFactory
) {
super(bridgeServer, "CSS");
this.sonarRuntime = sonarRuntime;
this.cssRules = new CssRules(checkFactory);
}
@Override
public void describe(SensorDescriptor descriptor) {
descriptor.createIssuesForRuleRepository("css").name("CSS Rules");
processesFilesIndependently(descriptor);
}
private void processesFilesIndependently(SensorDescriptor descriptor) {
if (
sonarRuntime.getProduct() == SonarProduct.SONARQUBE &&
sonarRuntime.getApiVersion().isGreaterThanOrEqual(Version.create(9, 3))
) {
descriptor.processesFilesIndependently();
}
}
@Override
public void execute(SensorContext context) {
this.context = context;
List inputFiles = getInputFiles();
if (inputFiles.isEmpty()) {
LOG.info(
"No CSS, PHP, HTML or VueJS files are found in the project. CSS analysis is skipped."
);
return;
}
super.execute(context);
}
@Override
protected void analyzeFiles(List inputFiles) throws IOException {
ProgressReport progressReport = new ProgressReport(
"Analysis progress",
TimeUnit.SECONDS.toMillis(10)
);
boolean success = false;
List rules = cssRules.getStylelintRules();
try {
progressReport.start(inputFiles.size(), inputFiles.iterator().next().toString());
for (InputFile inputFile : inputFiles) {
if (context.isCancelled()) {
throw new CancellationException(
"Analysis interrupted because the SensorContext is in cancelled state"
);
}
analyzeFile(inputFile, context, rules);
progressReport.nextFile(inputFile.toString());
}
success = true;
} finally {
if (success) {
progressReport.stop();
} else {
progressReport.cancel();
}
}
}
void analyzeFile(InputFile inputFile, SensorContext context, List rules) {
try {
URI uri = inputFile.uri();
if (!"file".equalsIgnoreCase(uri.getScheme())) {
LOG.debug("Skipping {} as it has not 'file' scheme", uri);
return;
}
LOG.debug("Analyzing file: {}", uri);
String fileContent = contextUtils.shouldSendFileContent(inputFile)
? inputFile.contents()
: null;
CssAnalysisRequest request = new CssAnalysisRequest(
new File(uri).getAbsolutePath(),
fileContent,
rules
);
var analysisResponse = bridgeServer.analyzeCss(request);
LOG.debug("Found {} issue(s)", analysisResponse.issues().size());
saveIssues(context, inputFile, analysisResponse.issues());
} catch (IOException | RuntimeException e) {
throw new IllegalStateException("Failure during analysis of " + inputFile.uri(), e);
}
}
private void saveIssues(
SensorContext context,
InputFile inputFile,
List issues
) {
for (Issue issue : issues) {
RuleKey ruleKey = cssRules.getActiveSonarKey(issue.ruleId());
if (ruleKey == null) {
if ("CssSyntaxError".equals(issue.ruleId())) {
String errorMessage = issue.message().replace("(CssSyntaxError)", "").trim();
logWarningOrDebug(
inputFile,
"Failed to parse file {}, line {}, {}",
inputFile.uri(),
issue.line(),
errorMessage
);
} else {
logErrorOrDebug(
inputFile,
"Unknown stylelint rule or rule not enabled: '" + issue.ruleId() + "'"
);
}
} else {
NewIssue sonarIssue = context.newIssue();
NewIssueLocation location = sonarIssue
.newLocation()
.on(inputFile)
.at(inputFile.selectLine(issue.line()))
.message(normalizeMessage(issue.message()));
sonarIssue.at(location).forRule(ruleKey).save();
}
}
}
private static void logErrorOrDebug(InputFile file, String msg, Object... arguments) {
if (CssLanguage.KEY.equals(file.language())) {
LOG.error(msg, arguments);
} else {
LOG.debug(msg, arguments);
}
}
private static void logWarningOrDebug(InputFile file, String msg, Object... arguments) {
if (CssLanguage.KEY.equals(file.language())) {
LOG.warn(msg, arguments);
} else {
LOG.debug(msg, arguments);
}
}
@Override
protected void logErrorOrWarn(String msg, Throwable e) {
if (hasCssFiles(context)) {
LOG.error(msg, e);
} else {
LOG.warn(msg);
}
}
@Override
protected List getInputFiles() {
var fileSystem = this.context.fileSystem();
var p = fileSystem.predicates();
var cssFilePredicate = p.and(
p.hasType(InputFile.Type.MAIN),
p.or(p.hasLanguages(CssLanguage.KEY))
);
var webFilePredicate = p.and(
p.hasType(InputFile.Type.MAIN),
p.or(p.hasExtension("htm"), p.hasExtension("html"), p.hasExtension("xhtml"))
);
var vueFilePredicate = p.and(
p.hasType(InputFile.Type.MAIN),
p.hasExtension("vue"),
// by default 'vue' extension is defined for JS language, but 'vue' files can contain TS code and thus language can be changed
p.hasLanguages("js", "ts")
);
return StreamSupport
.stream(
fileSystem
.inputFiles(p.or(cssFilePredicate, webFilePredicate, vueFilePredicate))
.spliterator(),
false
)
.toList();
}
public static boolean hasCssFiles(SensorContext context) {
FileSystem fileSystem = context.fileSystem();
FilePredicate mainFilePredicate = fileSystem
.predicates()
.and(
fileSystem.predicates().hasType(InputFile.Type.MAIN),
fileSystem.predicates().hasLanguages(CssLanguage.KEY)
);
return fileSystem.inputFiles(mainFilePredicate).iterator().hasNext();
}
private static String normalizeMessage(String message) {
// stylelint messages have format "message (rulekey)"
Pattern pattern = Pattern.compile("(.+)\\([a-z\\-]+\\)");
Matcher matcher = pattern.matcher(message);
if (matcher.matches()) {
return matcher.group(1);
} else {
return message;
}
}
}