public void analyse(Project project, SensorContext context) {
this.project = project;
this.context = context;
Collection<SquidAstVisitor<LexerlessGrammar>> squidChecks = annotationCheckFactory.getChecks();
List<SquidAstVisitor<LexerlessGrammar>> visitors = Lists.newArrayList(squidChecks);
visitors.add(new FileLinesVisitor(project, fileLinesContextFactory));
this.scanner =
FlexAstScanner.create(
createConfiguration(project), visitors.toArray(new SquidAstVisitor[visitors.size()]));
Collection<java.io.File> files =
InputFileUtils.toFiles(project.getFileSystem().mainFiles(Flex.KEY));
files = ImmutableList.copyOf(Collections2.filter(files, Predicates.not(MXML_FILTER)));
scanner.scanFiles(files);
Collection<SourceCode> squidSourceFiles =
scanner.getIndex().search(new QueryByType(SourceFile.class));
save(squidSourceFiles);
Collection<SourceCode> squidPackages =
scanner.getIndex().search(new QueryByType(FlexSquidPackage.class));
for (SourceCode pkg : squidPackages) {
String packageName = pkg.getKey();
if (!"".equals(packageName)) {
Directory directory = resourceBridge.findDirectory(packageName);
context.saveMeasure(directory, CoreMetrics.PACKAGES, 1.0);
}
}
}
@Override
public void analyse(Project module, SensorContext context) {
final String projectBaseDir = module.getFileSystem().getBasedir().getPath();
SwiftLintReportParser parser = new SwiftLintReportParser(module, context);
saveViolations(parseReportIn(projectBaseDir, parser), context);
}
private Project createProject() {
ProjectFileSystem fileSystem = mock(ProjectFileSystem.class);
when(fileSystem.hasJavaSourceFiles()).thenReturn(Boolean.TRUE);
Project project = mock(Project.class);
when(project.getFileSystem()).thenReturn(fileSystem);
return project;
}
public void analyse(Project project, SensorContext context) {
List<InputFile> sourceFiles = project.getFileSystem().mainFiles(CxxLanguage.KEY);
for (InputFile inputFile : sourceFiles) {
if (shouldParseFile(inputFile.getFile())) {
parseFile(inputFile, project, context);
}
}
}
private static File getReportsDirectoryFromProperty(Project project) {
String path = (String) project.getProperty(SUREFIRE_REPORTS_PATH_PROPERTY);
if (StringUtils.isBlank(path)) {
path = (String) project.getProperty(SUREFIRE_REPORTS_PATH_DEPRECATED_PROPERTY);
}
if (path != null) {
return project.getFileSystem().resolvePath(path);
}
return null;
}
private static File getReportFromPluginConfiguration(
Project project, MavenProject mavenProject, String file) {
MavenPlugin mavenPlugin = MavenPlugin.getPlugin(mavenProject, GROUP_ID, ARTIFACT_ID);
if (mavenPlugin != null) {
String path = mavenPlugin.getParameter("outputDirectory");
if (path != null) {
return project.getFileSystem().resolvePath(path + file);
}
}
return null;
}
@Test
public void testGetReportWithProperty() {
File desired = new File(getClass().getResource("big/pylint.txt").getFile());
String dir = desired.getParent();
ProjectFileSystem fileSystem = mock(ProjectFileSystem.class);
when(fileSystem.resolvePath(anyString())).thenReturn(new File(dir));
when(project.getFileSystem()).thenReturn(fileSystem);
when(project.getProperty(PyLintUtils.PYLINT_REPORT_PATH_PROPERTY)).thenReturn(dir);
File report = PyLintUtils.getReport(project);
assertEquals(desired, report);
}
@Test
public void testGetReportWithDefault() {
File desired = new File(getClass().getResource("small/pylint.txt").getFile());
String dir = desired.getParent();
ProjectFileSystem fileSystem = mock(ProjectFileSystem.class);
when(fileSystem.getBasedir()).thenReturn(new File(dir));
when(project.getFileSystem()).thenReturn(fileSystem);
File report = PyLintUtils.getReport(project);
assertEquals(desired, report);
}
private static File getReportsDirectoryFromPluginConfiguration(Project project) {
MavenPlugin plugin =
MavenPlugin.getPlugin(
project.getPom(), MavenSurefireUtils.GROUP_ID, MavenSurefireUtils.ARTIFACT_ID);
if (plugin != null) {
String path = plugin.getParameter("reportsDirectory");
if (path != null) {
return project.getFileSystem().resolvePath(path);
}
}
return null;
}
@Test
public void writeConfigurationToWorkingDir() throws IOException {
Project project =
MavenTestUtils.loadProjectFromPom(getClass(), "writeConfigurationToWorkingDir/pom.xml");
CheckstyleProfileExporter exporter = new FakeExporter();
CheckstyleConfiguration configuration =
new CheckstyleConfiguration(null, exporter, null, project.getFileSystem());
File xmlFile = configuration.getXMLDefinitionFile();
assertThat(xmlFile.exists(), is(true));
assertThat(FileUtils.readFileToString(xmlFile), is("<conf/>"));
}
/** Gets the generated jtl file path, if it was any generated */
protected String getJtlFilePath(Project project, String innerProjectJMeterReportsPath) {
String baseDirPath = project.getFileSystem().getBasedir().getAbsolutePath();
File reportDir = new File(baseDirPath + innerProjectJMeterReportsPath);
if (reportDir.exists()) {
for (File file :
(Collection<File>) FileUtils.listFiles(reportDir, new String[] {"jtl"}, true)) {
return file.getAbsolutePath();
}
for (File file :
(Collection<File>) FileUtils.listFiles(reportDir, new String[] {"xml"}, true)) {
return file.getAbsolutePath();
}
}
return null;
}
public void analyse(Project project, SensorContext context) {
DroolsPlugin.configureSourceDir(project);
Language drools = new Drools(project);
ProjectFileSystem fileSystem = project.getFileSystem();
Map<String, DroolsPackage> packageMap = new HashMap<String, DroolsPackage>();
VerifierBuilder verifierBuilder = VerifierBuilderFactory.newVerifierBuilder();
for (File file : fileSystem.getSourceFiles(drools)) {
Verifier verifier = verifierBuilder.newVerifier();
try {
DroolsFile resource = DroolsFile.fromIOFile(file, false);
Source source = analyseSourceCode(file);
if (source != null) {
context.saveMeasure(
resource, CoreMetrics.LINES, (double) source.getMeasure(Metric.LINES));
context.saveMeasure(
resource, CoreMetrics.NCLOC, (double) source.getMeasure(Metric.LINES_OF_CODE));
context.saveMeasure(
resource,
CoreMetrics.COMMENT_LINES,
(double) source.getMeasure(Metric.COMMENT_LINES));
}
context.saveMeasure(resource, CoreMetrics.FILES, 1.0);
context.saveMeasure(
resource,
CoreMetrics.CLASSES,
(double)
(resource.getPackageDescr().getRules().size()
+ resource.getPackageDescr().getFunctions().size()));
packageMap.put(resource.getParent().getKey(), resource.getParent());
verifier.addResourcesToVerify(new FileSystemResource(file), ResourceType.DRL);
verifier.fireAnalysis();
saveViolations(resource, context, verifier.getResult());
} catch (Throwable e) {
DroolsPlugin.LOG.error(
"error while verifier analyzing '" + file.getAbsolutePath() + "'", e);
} finally {
verifier.dispose();
}
}
for (DroolsPackage droolsPackage : packageMap.values()) {
context.saveMeasure(droolsPackage, CoreMetrics.PACKAGES, 1.0);
}
}
/**
* Matches to something like: (ATOM:ATOM/NUMBER)(WHITESPACES)(SOMETHING NOT
* WHITESPACES)(:WHITESPACES)(NUMBER,NUMBER-NUMBER,NUMBER) like: game:start/0
* /home/dev/project/erlang/game.erl: 4,1-5,12 means: 'application name':'function name'/'number
* of parameters' 'URL to the file': 'starting row','starting col'-'ending row','ending col'
*/
public ViolationReport refactorErl(Project project, RulesProfile profile) {
ViolationReport report = new ViolationReport();
List<ActiveRule> activeRules = profile.getActiveRulesByRepository("Erlang");
/** Read refactorErl results */
File basedir =
new File(
project.getFileSystem().getBasedir()
+ File.separator
+ ((Erlang) project.getLanguage()).getEunitFolder());
LOG.debug("Parsing refactorErl reports from folder {}", basedir.getAbsolutePath());
String refactorErlPattern = ((Erlang) project.getLanguage()).getRefactorErlFilenamePattern();
String[] list = getFileNamesByPattern(basedir, refactorErlPattern);
if (list.length == 0) {
LOG.warn("no file matches to : ", refactorErlPattern);
return report;
}
for (String file : list) {
try {
List<ViolationReportUnit> units = readRefactorErlReportUnits(basedir, file);
for (ViolationReportUnit refactorErlReportUnit : units) {
ActiveRule activeRule =
ActiveRuleFilter.getActiveRuleByRuleName(
activeRules, refactorErlReportUnit.getMetricKey());
if (activeRule != null
&& ViolationUtil.checkIsValid(activeRule, refactorErlReportUnit.getMetricValue())) {
refactorErlReportUnit.setDescription(
ViolationUtil.getMessageForMetric(
activeRule, refactorErlReportUnit.getMetricValue()));
/** Replace key coming from activeProfile because it contains the name originaly */
refactorErlReportUnit.setMetricKey(activeRule.getRuleKey());
report.addUnit(refactorErlReportUnit);
}
}
} catch (FileNotFoundException e) {
} catch (IOException e) {
}
}
return report;
}
/** {@inheritDoc} */
public void analyse(Project project, SensorContext context) {
if (rulesProfile.getActiveRulesByRepository(FxCopConstants.REPOSITORY_KEY).isEmpty()) {
LOG.warn(
"/!\\ SKIP FxCop analysis: no rule defined for FxCop in the \"{}\" profil.",
rulesProfile.getName());
return;
}
fxCopResultParser.setEncoding(fileSystem.getSourceCharset());
final File reportFile;
File projectDir = project.getFileSystem().getBasedir();
String reportDefaultPath =
getMicrosoftWindowsEnvironment().getWorkingDirectory()
+ "/"
+ FxCopConstants.FXCOP_REPORT_XML;
if (MODE_REUSE_REPORT.equalsIgnoreCase(executionMode)) {
String reportPath =
configuration.getString(FxCopConstants.REPORTS_PATH_KEY, reportDefaultPath);
reportFile = FileFinder.browse(projectDir, reportPath);
LOG.info("Reusing FxCop report: " + reportFile);
} else {
// prepare config file for FxCop
File fxCopConfigFile = generateConfigurationFile();
// and run FxCop
try {
FxCopRunner runner =
FxCopRunner.create(
configuration.getString(
FxCopConstants.INSTALL_DIR_KEY, FxCopConstants.INSTALL_DIR_DEFVALUE));
launchFxCop(project, runner, fxCopConfigFile);
} catch (FxCopException e) {
throw new SonarException("FxCop execution failed.", e);
}
reportFile = new File(projectDir, reportDefaultPath);
}
// and analyze results
analyseResults(reportFile);
}
@BeforeClass
public static void init() {
aRule = Rule.create("gendarme", "Rule", "Rule").setSeverity(RulePriority.BLOCKER);
aFileIMoney = new org.sonar.api.resources.File("IMoney");
aFileMoney = new org.sonar.api.resources.File("Money");
env = mock(MicrosoftWindowsEnvironment.class);
VisualStudioSolution solution = mock(VisualStudioSolution.class);
when(env.getCurrentSolution()).thenReturn(solution);
VisualStudioProject vsProject = mock(VisualStudioProject.class);
when(solution.getProjectFromSonarProject(any(Project.class))).thenReturn(vsProject);
when(solution.getProject(any(File.class))).thenReturn(vsProject);
project = mock(Project.class);
ProjectFileSystem fileSystem = mock(ProjectFileSystem.class);
when(fileSystem.getSourceDirs()).thenReturn(Lists.newArrayList(new File("C:\\Sonar\\Example")));
when(project.getFileSystem()).thenReturn(fileSystem);
resourcesBridge = createFakeBridge();
resourceHelper = mock(ResourceHelper.class);
when(resourceHelper.isResourceInProject(any(Resource.class), eq(project))).thenReturn(true);
}
@Before
public void init() {
project = mock(Project.class);
ProjectFileSystem pfs = mock(ProjectFileSystem.class);
// Don't pollute current working directory
when(pfs.getSonarWorkingDirectory()).thenReturn(new File("target"));
File baseDir = DelphiUtils.getResource(ROOT_NAME);
when(project.getLanguage()).thenReturn(DelphiLanguage.instance);
when(project.getFileSystem()).thenReturn(pfs);
when(project.getLanguageKey()).thenReturn(DelphiLanguage.KEY);
when(pfs.getBasedir()).thenReturn(baseDir);
File srcFile = DelphiUtils.getResource(TEST_FILE);
List<File> sourceFiles = new ArrayList<File>();
sourceFiles.add(srcFile);
when(pfs.getSourceFiles(DelphiLanguage.instance)).thenReturn(sourceFiles);
sensor = new DelphiPmdSensor(new DebugRuleFinder());
}
public void saveMeasures(final Map<String, List<Measure>> measures) {
if (measures == null) {
return;
}
for (Map.Entry<String, List<Measure>> entry : measures.entrySet()) {
final org.sonar.api.resources.File objcfile =
org.sonar.api.resources.File.fromIOFile(
new File(project.getFileSystem().getBasedir(), entry.getKey()), project);
if (fileExists(sensorContext, objcfile)) {
for (Measure measure : entry.getValue()) {
try {
LoggerFactory.getLogger(getClass())
.debug("Save measure {} for file {}", measure.getMetric().getName(), objcfile);
sensorContext.saveMeasure(objcfile, measure);
} catch (Exception e) {
LoggerFactory.getLogger(getClass())
.error(" Exception -> {} -> {}", entry.getKey(), measure.getMetric().getName());
}
}
}
}
}
/** {@inheritDoc} */
public void analyse(Project project, SensorContext context) {
analyse(project.getFileSystem(), context);
onFinished();
}
private static File getReportsDirectoryFromDefaultConfiguration(Project project) {
return new File(project.getFileSystem().getBuildDir(), "surefire-reports");
}
/** {@inheritDoc} */
public boolean shouldExecuteOnProject(Project project) {
return PhpConstants.LANGUAGE_KEY.equals(project.getLanguageKey())
&& configuration.isDynamicAnalysisEnabled()
&& !configuration.isSkip()
&& !project.getFileSystem().testFiles(PhpConstants.LANGUAGE_KEY).isEmpty();
}
private static File getReportFromDefaultPath(Project project, String file) {
return new File(project.getFileSystem().getBuildDir(), file);
}
public boolean shouldExecuteOnProject(Project project) {
return project.getFileSystem().hasJavaSourceFiles()
&& (!profile.getActiveRulesByRepository(PmdConstants.REPOSITORY_KEY).isEmpty()
|| project.getReuseExistingRulesConfig());
}
@Override
public boolean shouldExecuteOnProject(Project project) {
return project.getAnalysisType().equals(Project.AnalysisType.DYNAMIC)
&& project.getFileSystem().hasTestFiles(Java.INSTANCE);
}
private FlexConfiguration createConfiguration(Project project) {
return new FlexConfiguration(project.getFileSystem().getSourceCharset());
}