Refine search
@Override public void execute(SensorContext context) { File f = new File(context.settings().getString(SONAR_XOO_RANDOM_ACCESS_ISSUE_PATHS)); FileSystem fs = context.fileSystem(); FilePredicates p = fs.predicates(); try { for (String path : FileUtils.readLines(f)) { createIssues(fs.inputFile(p.and(p.hasPath(path), p.hasType(Type.MAIN), p.hasLanguage(Xoo.KEY))), context); } } catch (IOException e) { throw new IllegalStateException(e); } }
@Override public void execute(SensorContext context) { FileSystem fs = context.fileSystem(); FilePredicates p = fs.predicates(); for (InputFile file : fs.inputFiles(p.and(p.hasLanguages(Xoo.KEY), p.hasType(Type.MAIN)))) { createIssues(file, context); } }
@Override public void execute(SensorContext context) { for (InputFile file : context.fileSystem().inputFiles(context.fileSystem().predicates().hasLanguages(Xoo.KEY, Xoo2.KEY))) { File ioFile = file.file(); File measureFile = new File(ioFile.getParentFile(), ioFile.getName() + MEASURES_EXTENSION); processFileMeasures(file, measureFile, context); InputDir inputDir = context.fileSystem().inputDir(ioFile.getParentFile()); if (inputDir != null) { processFileMeasures(inputDir, new File(ioFile.getParentFile(), "folder" + MEASURES_EXTENSION), context); } } processFileMeasures(context.module(), new File(context.fileSystem().baseDir(), "module" + MEASURES_EXTENSION), context); } }
@Override public void execute(SensorContext context) { context.fileSystem().inputFiles(context.fileSystem().predicates().all()).forEach(inputFile -> LOG.info("Deprecated Global Sensor: {}", inputFile.relativePath())); } }
@CheckForNull private static InputFile findFile(SensorContext context, String filePath) { return context.fileSystem().inputFile(context.fileSystem().predicates().hasPath(filePath)); }
@Override public void execute(SensorContext context) { for (InputFile file : context.fileSystem().inputFiles(context.fileSystem().predicates().hasLanguages(Xoo.KEY))) { processFileSymbol(file, context); } } }
private void processFileMeasures(InputComponent component, File measureFile, SensorContext context) { if (measureFile.exists()) { LOG.debug("Processing " + measureFile.getAbsolutePath()); try { List<String> lines = FileUtils.readLines(measureFile, context.fileSystem().encoding().name()); int lineNumber = 0; for (String line : lines) { lineNumber++; if (StringUtils.isBlank(line) || line.startsWith("#")) { continue; } processMeasure(component, context, measureFile, lineNumber, line); } } catch (IOException e) { throw new IllegalStateException(e); } } }
private void processTestFile(InputFile inputFile, SensorContext context) { File testExecutionFile = new File(inputFile.file().getParentFile(), inputFile.file().getName() + TEST_EXTENSION); if (testExecutionFile.exists()) { LOG.debug("Processing " + testExecutionFile.getAbsolutePath()); try { List<String> lines = FileUtils.readLines(testExecutionFile, fs.encoding().name()); int lineNumber = 0; MutableTestPlan testPlan = perspectives.as(MutableTestPlan.class, inputFile); Iterator<String> splitCoveredBlock = Splitter.on(",").split(coveredBlockStr).iterator(); String componentPath = splitCoveredBlock.next(); InputFile coveredFile = context.fileSystem().inputFile(context.fileSystem().predicates().hasPath(componentPath)); MutableTestable testable = perspectives.as(MutableTestable.class, coveredFile); List<Integer> coveredLines = new ArrayList<>();
private File copyLib(String name) { InputStream input = null; try { input = getClass().getResourceAsStream(name); File dir = new File(fileSystem.workDir(), "findbugs"); FileUtils.forceMkdir(dir); File target = new File(dir, name); FileUtils.copyInputStreamToFile(input, target); return target; } catch (IOException e) { throw new IllegalStateException("Fail to extract Findbugs dependency", e); } finally { IOUtils.closeQuietly(input); } }
private boolean fsCondition(DefaultSensorDescriptor descriptor) { if (!descriptor.languages().isEmpty() || descriptor.type() != null) { FilePredicate langPredicate = descriptor.languages().isEmpty() ? fs.predicates().all() : fs.predicates().hasLanguages(descriptor.languages()); FilePredicate typePredicate = descriptor.type() == null ? fs.predicates().all() : fs.predicates().hasType(descriptor.type()); return fs.hasFiles(fs.predicates().and(langPredicate, typePredicate)); } return true; }
private static InputFile getInputFile(SensorContext context, String fileName) { FilePredicates predicates = context.fileSystem().predicates(); InputFile inputFile = context.fileSystem().inputFile(predicates.or(predicates.hasRelativePath(fileName), predicates.hasAbsolutePath(fileName))); if (inputFile == null) { LOG.warn("No input file found for {}. No {} issues will be imported on this file.", fileName, LINTER_NAME); return null; } return inputFile; }
protected boolean hasJavaSources() { return fs.hasFiles(fs.predicates().and(fs.predicates().hasLanguage("java"), fs.predicates().hasType(fileType))); }
@Override public void execute(SensorContext sensorContext) { File workDir = new File(sensorContext.fileSystem().workDir(), "pylint"); if (!shouldExecute() || !prepareWorkDir(workDir) || !initializeAnalyzer(sensorContext)) { return; } int i = 0; FileSystem fileSystem = sensorContext.fileSystem(); FilePredicates p = fileSystem.predicates(); Iterable<InputFile> files = fileSystem.inputFiles(p.and(p.hasType(InputFile.Type.MAIN), p.hasLanguage(Python.KEY))); for (InputFile file : files) { try { File out = new File(workDir, i + ".out"); analyzeFile(sensorContext, file, out); i++; } catch (Exception e) { LOG.warn("Cannot analyse file '{}', the following exception occurred:", file.toString(), e); } } }
private static void analyse(SensorContext context) { FileSystem fs = context.fileSystem(); FilePredicates p = fs.predicates(); RuleKey ruleKey = RuleKey.of(XooRulesDefinition.XOO_REPOSITORY, RULE_KEY); StreamSupport.stream(fs.inputFiles(p.hasType(Type.MAIN)).spliterator(), false) .map(file -> fs.inputDir(file.file().getParentFile())) .filter(Objects::nonNull) .distinct() .forEach(inputDir -> { NewIssue newIssue = context.newIssue(); newIssue .forRule(ruleKey) .at(newIssue.newLocation() .on(inputDir) .message("This issue is generated for any non-empty directory")) .save(); }); } }
@Override public void execute(SensorContext context) { Iterator<InputFile> inputFiles = context.fileSystem().inputFiles(context.fileSystem().predicates().all()).iterator(); if (!inputFiles.hasNext()) { throw new IllegalStateException("No files indexed"); } InputFile file = inputFiles.next(); context.newHighlighting() .onFile(file) .highlight(file.selectLine(1), TypeOfText.CONSTANT) .save(); context.newHighlighting() .onFile(file) .highlight(file.selectLine(file.lines()), TypeOfText.COMMENT) .save(); } }
@Override public void execute(SensorContext context) { FileSystem fileSystem = context.fileSystem(); FilePredicate mainFilePredicate = fileSystem.predicates().and( fileSystem.predicates().hasType(InputFile.Type.MAIN), fileSystem.predicates().hasLanguage(PerlLanguage.KEY)); List<InputFile> inputFiles = new ArrayList<>(); fileSystem.inputFiles(mainFilePredicate).forEach(inputFiles::add); for (InputFile inputFile : inputFiles) { this.analyseFile(inputFile, fileSystem.encoding(), context); } }
private void parseFiles(SMInputCursor fileCursor, SensorContext context) throws XMLStreamException { while (fileCursor.getNext() != null) { checkElementName(fileCursor, "file"); String filePath = mandatoryAttribute(fileCursor, "path"); InputFile inputFile = context.fileSystem().inputFile(context.fileSystem().predicates().hasPath(filePath)); if (inputFile == null) { numberOfUnknownFiles++; if (numberOfUnknownFiles <= MAX_STORED_UNKNOWN_FILE_PATHS) { firstUnknownFiles.add(filePath); } continue; } Preconditions.checkState( inputFile.language() != null, "Line %s of report refers to a file with an unknown language: %s", fileCursor.getCursorLocation().getLineNumber(), filePath); Preconditions.checkState( inputFile.type() != InputFile.Type.MAIN, "Line %s of report refers to a file which is not configured as a test file: %s", fileCursor.getCursorLocation().getLineNumber(), filePath); matchedFileKeys.add(inputFile.absolutePath()); MutableTestPlan testPlan = testPlanBuilder.loadPerspective(MutableTestPlan.class, inputFile); SMInputCursor testCaseCursor = fileCursor.childElementCursor(); while (testCaseCursor.getNext() != null) { parseTestCase(testCaseCursor, testPlan); } } }
private void save(Collection<SourceCode> squidSourceFiles) { for (SourceCode squidSourceFile : squidSourceFiles) { SourceFile squidFile = (SourceFile) squidSourceFile; String relativePath = pathResolver.relativePath(context.fileSystem().baseDir(), new File(squidFile.getKey())); InputFile inputFile = context.fileSystem().inputFile(context.fileSystem().predicates().hasRelativePath(relativePath)); saveMeasures(inputFile, squidFile); saveIssues(inputFile, squidFile); } }
@Override public void execute(final SensorContext context) { FileSystem fs = context.fileSystem(); for (InputFile f : fs.inputFiles(fs.predicates().hasType(Type.MAIN))) { if (((DefaultInputFile) f).isExcludedForCoverage()) { continue; } if (!isCoverageMeasuresAlreadyDefined(f)) { DefaultMeasure<String> execLines = (DefaultMeasure<String>) measureCache.byMetric(f.key(), CoreMetrics.EXECUTABLE_LINES_DATA_KEY); if (execLines != null) { storeZeroCoverageForEachExecutableLine(context, f, execLines); } } } }