org.sonar.api.batch.fs.FilePredicate Java Examples

@Override
public void execute(SensorContext context) {
    LOG.info("Running ClojureSensor");
    FilePredicates predicates = context.fileSystem().predicates();
    FilePredicate clojure = predicates.hasLanguage(Clojure.KEY);
    FilePredicate main = predicates.hasType(InputFile.Type.MAIN);

    //TODO This is inaccurate. We need to properly count the lines of code, excluding spaces, comments, etc.
    //TODO This is here to make sure analysis data will show up in the Sonar UI.
    Iterable<InputFile> sources = context.fileSystem().inputFiles(predicates.and(clojure, main));

    for (InputFile source : sources) {
        LOG.info(source.toString());
        context.<Integer>newMeasure().withValue(source.lines()).forMetric(NCLOC).on(source).save();
    }
}
 

private static Optional<FileAnalysis> findFileBySources(SensorContext context, String filename) {
    FileSystem fs = context.fileSystem();
    FilePredicate pattern = fs.predicates().matchesPathPattern("**/" + filename);
    InputFile potentialFile = fs.inputFile(pattern);

    if (potentialFile != null) {
        LOG.debug("Found file");
        FileAnalysis foundSource = new FileAnalysis();
        foundSource.setInputFile(potentialFile);
        return Optional.of(foundSource);
    }

    return Optional.empty();
}
 

private FilePredicate mainFilePredicate(FileSystem fileSystem) {
  String[] suffixes = getSettings().getStringArray(Plugin.EMBEDDED_CSS_FILE_SUFFIXES_KEY);
  if (suffixes == null || suffixes.length == 0) {
    suffixes = StringUtils.split(Plugin.CSS_FILE_SUFFIXES_DEFAULT_VALUE, ",");
  }

  List<FilePredicate> filePredicates = new ArrayList<>();
  for (String suffix : suffixes) {
    filePredicates.add(fileSystem.predicates().matchesPathPattern("**/*." + suffix));
  }

  return fileSystem.predicates().or(filePredicates);
}
 

@Before
public void before() {
    fileSystem = mock(FileSystem.class);
    context = mock(SensorContext.class);
    inputFile = mock(InputFile.class);
    ruleFinder = mock(ActiveRules.class);

    final FilePredicates predicates = mock(FilePredicates.class);
    final FilePredicate filePredicate = mock(FilePredicate.class);
    when(fileSystem.inputFile(any(FilePredicate.class))).thenReturn(inputFile);
    when(fileSystem.predicates()).thenReturn(predicates);
    when(predicates.hasAbsolutePath(anyString())).thenReturn(filePredicate);
}
 

@Override
public void execute(SensorContext context) {
    FilePredicate htlFilePredicate = HtlFilePredicateProvider.createFilePredicate(configuration, context);
    Iterable<InputFile> inputFiles = context.fileSystem().inputFiles(htlFilePredicate);

    Collection<File> files = StreamSupport.stream(inputFiles.spliterator(), false)
        .map(InputFile::uri)
        .map(File::new)
        .collect(Collectors.toList());

    ProgressReport progressReport = new ProgressReport("Report about progress of HTL analyzer",
        TimeUnit.SECONDS.toMillis(10));
    progressReport.start(files);
    analyseFiles(context, inputFiles, progressReport);
}
 

public static FilePredicate createFilePredicate(Configuration configuration, SensorContext sensorContext) {
    FilePredicates predicates = sensorContext.fileSystem().predicates();

    List<FilePredicate> fileExtensions = getFileExtensionsPredicates(predicates, configuration);
    List<FilePredicate> relativePaths = getPathsPredicate(predicates, configuration);

    return predicates.and(
            predicates.hasType(InputFile.Type.MAIN),
            predicates.or(
                    predicates.hasLanguages(Htl.KEY),
                    predicates.or(fileExtensions)
            ),
            predicates.or(relativePaths)
    );
}
 

private static List<FilePredicate> getFileExtensionsPredicates(FilePredicates predicates, Configuration configuration) {
    return Stream.of(configuration.getStringArray(Constants.FILE_EXTENSIONS_PROP_KEY))
            .filter(Objects::nonNull)
            .map(extension -> StringUtils.removeStart(extension, "."))
            .map(predicates::hasExtension)
            .collect(Collectors.toList());
}
 

private static List<FilePredicate> getPathsPredicate(FilePredicates predicates, Configuration configuration) {
    return Stream.of(configuration.getStringArray(Constants.HTL_FILES_RELATIVE_PATHS_KEY))
            .filter(StringUtils::isNotEmpty)
            .map(path -> StringUtils.wrapIfMissing(path, "**"))
            .map(predicates::matchesPathPattern)
            .collect(Collectors.toList());
}
 

private FilePredicate mainFilePredicate(FileSystem fileSystem) {
  return fileSystem.predicates()
    .and(
      fileSystem.predicates().hasType(InputFile.Type.MAIN),
      fileSystem.predicates().hasLanguage(CssLanguage.KEY));
}
 

private FilePredicate mainFilePredicate(FileSystem fileSystem) {
  return fileSystem.predicates()
    .and(
      fileSystem.predicates().hasType(InputFile.Type.MAIN),
      fileSystem.predicates().hasLanguage(LessLanguage.KEY));
}
 

private FilePredicate mainFilePredicate(FileSystem fileSystem) {
  return fileSystem.predicates()
    .and(
      fileSystem.predicates().hasType(Type.MAIN),
      fileSystem.predicates().hasLanguage(ScssLanguage.KEY));
}
 

public FilePredicate getPredicate() {
	return new AbsolutePathCaseInsensitivePredicate(this.getFilePath());
}