How to use

hasLanguage

method

in

org.sonar.api.batch.fs.FilePredicates

@Test
public void has_language() {
 assertThat(predicates.hasLanguage("java").apply(javaFile)).isTrue();
 assertThat(predicates.hasLanguage("php").apply(javaFile)).isFalse();
}

@Override
public void execute(SensorContext context) {
 FilePredicates p = context.fileSystem().predicates();
 List<InputFile> sourceFiles = StreamSupport.stream(
  context.fileSystem().inputFiles(
   p.and(
    p.hasType(InputFile.Type.MAIN),
    p.hasLanguage("java")
   )
  ).spliterator(), false)
  .filter(f -> !((DefaultInputFile) f).isExcludedForDuplication())
  .collect(Collectors.toList());
 if (sourceFiles.isEmpty()) {
  return;
 }
 createIndex(sourceFiles);
}

@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) {
 for (InputFile inputFile : context.fileSystem().inputFiles(context.fileSystem().predicates().hasLanguage(Xoo.KEY))) {
  processFile(inputFile);
 }
}

private void doAnalyse(SensorContext context, String languageKey) {
 RuleKey ruleKey = RuleKey.of(XooRulesDefinition.XOO_REPOSITORY, getRuleKey());
 if (activeRules.find(ruleKey) == null) {
  return;
 }
 for (InputFile inputFile : fs.inputFiles(fs.predicates().hasLanguage(languageKey))) {
  processFile(inputFile, context, ruleKey, languageKey);
 }
}

 @Test
 public void input_file_supports_non_indexed_predicates() {
  fs.add(new TestInputFileBuilder("foo", "src/Bar.java").setLanguage("java").build());

  // it would fail if more than one java file
  assertThat(fs.inputFile(fs.predicates().hasLanguage("java"))).isNotNull();
 }
}

@Test
public void input_file_returns_null_if_file_not_found() {
 assertThat(fs.inputFile(fs.predicates().hasRelativePath("src/Bar.java"))).isNull();
 assertThat(fs.inputFile(fs.predicates().hasLanguage("cobol"))).isNull();
}

@Test
public void files() {
 assertThat(fs.inputFiles(fs.predicates().all())).isEmpty();
 fs.add(new TestInputFileBuilder("foo", "src/Foo.php").setLanguage("php").build());
 fs.add(new TestInputFileBuilder("foo", "src/Bar.java").setLanguage("java").build());
 fs.add(new TestInputFileBuilder("foo", "src/Baz.java").setLanguage("java").build());
 // no language
 fs.add(new TestInputFileBuilder("foo", "src/readme.txt").build());
 assertThat(fs.inputFile(fs.predicates().hasRelativePath("src/Bar.java"))).isNotNull();
 assertThat(fs.inputFile(fs.predicates().hasRelativePath("does/not/exist"))).isNull();
 assertThat(fs.inputFile(fs.predicates().hasAbsolutePath(new File(basedir, "src/Bar.java").getAbsolutePath()))).isNotNull();
 assertThat(fs.inputFile(fs.predicates().hasAbsolutePath(new File(basedir, "does/not/exist").getAbsolutePath()))).isNull();
 assertThat(fs.inputFile(fs.predicates().hasAbsolutePath(new File(basedir, "../src/Bar.java").getAbsolutePath()))).isNull();
 assertThat(fs.inputFile(fs.predicates().hasURI(new File(basedir, "src/Bar.java").toURI()))).isNotNull();
 assertThat(fs.inputFile(fs.predicates().hasURI(new File(basedir, "does/not/exist").toURI()))).isNull();
 assertThat(fs.inputFile(fs.predicates().hasURI(new File(basedir, "../src/Bar.java").toURI()))).isNull();
 assertThat(fs.files(fs.predicates().all())).hasSize(4);
 assertThat(fs.files(fs.predicates().hasLanguage("java"))).hasSize(2);
 assertThat(fs.files(fs.predicates().hasLanguage("cobol"))).isEmpty();
 assertThat(fs.hasFiles(fs.predicates().all())).isTrue();
 assertThat(fs.hasFiles(fs.predicates().hasLanguage("java"))).isTrue();
 assertThat(fs.hasFiles(fs.predicates().hasLanguage("cobol"))).isFalse();
 assertThat(fs.inputFiles(fs.predicates().all())).hasSize(4);
 assertThat(fs.inputFiles(fs.predicates().hasLanguage("php"))).hasSize(1);
 assertThat(fs.inputFiles(fs.predicates().hasLanguage("java"))).hasSize(2);
 assertThat(fs.inputFiles(fs.predicates().hasLanguage("cobol"))).isEmpty();
 assertThat(fs.languages()).containsOnly("java", "php");
}

public static FilePredicate[] getSupportedLanguagesFilePredicate(FilePredicates pred) {
  return Arrays.stream(SUPPORTED_JVM_LANGUAGES)
      .map(s -> pred.hasLanguage(s))
      .collect(Collectors.toList())
      .toArray(new FilePredicate[SUPPORTED_JVM_LANGUAGES.length]);
}

public SwiftFileSystem(FileSystem fileSystem) {
  this.fileSystem = fileSystem;
  this.predicates = fileSystem.predicates();
  this.isSwiftLanguage = predicates.hasLanguage(Swift.KEY);
  this.isMainTypeFile = predicates.hasType(InputFile.Type.MAIN);
}

 @Override
 public FilePredicate apply(@Nullable String s) {
  return s == null ? predicates().all() : predicates().hasLanguage(s);
 }
}));

public static List<InputFile> searchByType(final SensorContext context, final InputFile.Type type) {
FileSystem system = context.fileSystem();
FilePredicates predicate = system.predicates();
Iterable<InputFile> iter = system
  .inputFiles(predicate.and(predicate.hasLanguage(GoLanguage.KEY), predicate.hasType(type)));
final List<InputFile> listFiles = new ArrayList<>();
iter.forEach(listFiles::add);
return listFiles;
}

@Override
public void execute(SensorContext context) {
 FilePredicates p = context.fileSystem().predicates();
 Iterable<InputFile> it = context.fileSystem().inputFiles(p.and(p.hasType(InputFile.Type.MAIN), p.hasLanguage(Python.KEY)));
 List<InputFile> list = new ArrayList<>();
 it.forEach(list::add);
 List<InputFile> inputFiles = Collections.unmodifiableList(list);
 PythonScanner scanner = new PythonScanner(context, checks, fileLinesContextFactory, noSonarFilter, inputFiles);
 scanner.scanFiles();
}

@Override
public boolean shouldExecuteOnProject(Project project) {
 if (!fs.hasFiles(fs.predicates().hasLanguage(language))) {
  return false;
 }
 checks = checkFactory.create(DefaultCommonRulesRepository.keyForLanguage(language));
 checks.addAnnotatedChecks(CommonRulesConstants.CLASSES);
 return !checks.all().isEmpty();
}

public static List<InputFile> searchFileWithTypeMainOrTest(final SensorContext context) {
FilePredicates predicate = context.fileSystem().predicates();
Iterable<InputFile> iter = context.fileSystem().inputFiles(predicate.and(predicate.hasLanguage(GoLanguage.KEY),
  predicate.or(predicate.hasType(InputFile.Type.MAIN), predicate.hasType(InputFile.Type.TEST))));
final List<InputFile> listFiles = new ArrayList<>();
iter.forEach(listFiles::add);
return listFiles;
}

private InputFile getUnitTestInputFile(FileSystem fileSystem) {
 FilePredicates predicates = fileSystem.predicates();
 return fileSystem.inputFile(predicates.and(
  predicates.hasPath(file),
  predicates.hasType(InputFile.Type.TEST),
  predicates.hasLanguage(Php.KEY)));
}

public JsTestDriverSensor(FileSystem fileSystem, Settings settings) {
 this.fileSystem = fileSystem;
 this.settings = settings;
 this.mainFilePredicate = fileSystem.predicates().and(
  fileSystem.predicates().hasType(InputFile.Type.MAIN),
  fileSystem.predicates().hasLanguage(JavaScript.KEY));
 this.testFilePredicate = fileSystem.predicates().and(
  fileSystem.predicates().hasType(InputFile.Type.TEST),
  fileSystem.predicates().hasLanguage(JavaScript.KEY));
}

private static Iterable<InputFile> getInputFiles(SensorContext sensorContext) {
 FileSystem fileSystem = sensorContext.fileSystem();
 FilePredicate mainFilePredicate = sensorContext.fileSystem().predicates().and(
  fileSystem.predicates().hasType(InputFile.Type.MAIN),
  fileSystem.predicates().hasLanguage(JavaScriptLanguage.KEY));
 return fileSystem.inputFiles(mainFilePredicate);
}

private static Iterable<InputFile> getInputFiles(SensorContext sensorContext) {
 FileSystem fileSystem = sensorContext.fileSystem();
 FilePredicate mainFilePredicate = sensorContext.fileSystem().predicates().and(
  fileSystem.predicates().hasType(InputFile.Type.MAIN),
  fileSystem.predicates().hasLanguage(JavaScriptLanguage.KEY));
 return fileSystem.inputFiles(mainFilePredicate);
}

static Iterable<InputFile> getInputFiles(SensorContext sensorContext) {
 FileSystem fileSystem = sensorContext.fileSystem();
 FilePredicate mainFilePredicate = sensorContext.fileSystem().predicates().and(
  fileSystem.predicates().hasType(InputFile.Type.MAIN),
  fileSystem.predicates().hasLanguage(TypeScriptLanguage.KEY));
 Iterable<InputFile> inputFiles = fileSystem.inputFiles(mainFilePredicate);
 return excludeInputFilesWithUnreadableCharacters(inputFiles);
}