How to use

FilePredicates

in

org.sonar.api.batch.fs

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

@Test
public void and() {
 // empty
 assertThat(predicates.and().apply(javaFile)).isTrue();
 assertThat(predicates.and(new FilePredicate[0]).apply(javaFile)).isTrue();
 assertThat(predicates.and(Collections.<FilePredicate>emptyList()).apply(javaFile)).isTrue();
 // two arguments
 assertThat(predicates.and(predicates.all(), predicates.all()).apply(javaFile)).isTrue();
 assertThat(predicates.and(predicates.all(), predicates.none()).apply(javaFile)).isFalse();
 assertThat(predicates.and(predicates.none(), predicates.all()).apply(javaFile)).isFalse();
 // collection
 assertThat(predicates.and(Arrays.asList(predicates.all(), predicates.all())).apply(javaFile)).isTrue();
 assertThat(predicates.and(Arrays.asList(predicates.all(), predicates.none())).apply(javaFile)).isFalse();
 // array
 assertThat(predicates.and(new FilePredicate[] {predicates.all(), predicates.all()}).apply(javaFile)).isTrue();
 assertThat(predicates.and(new FilePredicate[] {predicates.all(), predicates.none()}).apply(javaFile)).isFalse();
}

@Test
public void not() {
 assertThat(predicates.not(predicates.hasType(InputFile.Type.MAIN)).apply(javaFile)).isFalse();
 assertThat(predicates.not(predicates.hasType(InputFile.Type.TEST)).apply(javaFile)).isTrue();
}

@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) {
 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);
 }
}

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;
}

@Test
public void has_absolute_path() throws Exception {
 String path = javaFile.file().getAbsolutePath();
 assertThat(predicates.hasAbsolutePath(path).apply(javaFile)).isTrue();
 assertThat(predicates.hasAbsolutePath(path.replaceAll("/", "\\\\")).apply(javaFile)).isTrue();
 assertThat(predicates.hasAbsolutePath(temp.newFile().getAbsolutePath()).apply(javaFile)).isFalse();
 assertThat(predicates.hasAbsolutePath("src/main/java/struts/Action.java").apply(javaFile)).isFalse();
}

 @Test
 public void testHasExplicitFilterOnStatus() {
  assertThat(SameInputFilePredicate.hasExplicitFilterOnStatus(predicates.all())).isFalse();
  assertThat(SameInputFilePredicate.hasExplicitFilterOnStatus(predicates.hasStatus(InputFile.Status.ADDED))).isTrue();
  assertThat(SameInputFilePredicate.hasExplicitFilterOnStatus(predicates.hasAnyStatus())).isTrue();
  assertThat(SameInputFilePredicate.hasExplicitFilterOnStatus(predicates.and(predicates.all(), predicates.hasStatus(InputFile.Status.ADDED)))).isTrue();
 }
}

@Test
public void or() {
 // empty
 assertThat(predicates.or().apply(javaFile)).isTrue();
 assertThat(predicates.or(new FilePredicate[0]).apply(javaFile)).isTrue();
 assertThat(predicates.or(Collections.<FilePredicate>emptyList()).apply(javaFile)).isTrue();
 // two arguments
 assertThat(predicates.or(predicates.all(), predicates.all()).apply(javaFile)).isTrue();
 assertThat(predicates.or(predicates.all(), predicates.none()).apply(javaFile)).isTrue();
 assertThat(predicates.or(predicates.none(), predicates.all()).apply(javaFile)).isTrue();
 assertThat(predicates.or(predicates.none(), predicates.none()).apply(javaFile)).isFalse();
 // collection
 assertThat(predicates.or(Arrays.asList(predicates.all(), predicates.all())).apply(javaFile)).isTrue();
 assertThat(predicates.or(Arrays.asList(predicates.all(), predicates.none())).apply(javaFile)).isTrue();
 assertThat(predicates.or(Arrays.asList(predicates.none(), predicates.none())).apply(javaFile)).isFalse();
 // array
 assertThat(predicates.or(new FilePredicate[] {predicates.all(), predicates.all()}).apply(javaFile)).isTrue();
 assertThat(predicates.or(new FilePredicate[] {predicates.all(), predicates.none()}).apply(javaFile)).isTrue();
 assertThat(predicates.or(new FilePredicate[] {predicates.none(), predicates.none()}).apply(javaFile)).isFalse();
}

@Test
public void has_relative_path() {
 assertThat(predicates.hasRelativePath("src/main/java/struts/Action.java").apply(javaFile)).isTrue();
 assertThat(predicates.hasRelativePath("src/main/java/struts/Other.java").apply(javaFile)).isFalse();
 // path is normalized
 assertThat(predicates.hasRelativePath("src/main/java/../java/struts/Action.java").apply(javaFile)).isTrue();
 assertThat(predicates.hasRelativePath("src\\main\\java\\struts\\Action.java").apply(javaFile)).isTrue();
 assertThat(predicates.hasRelativePath("src\\main\\java\\struts\\Other.java").apply(javaFile)).isFalse();
 assertThat(predicates.hasRelativePath("src\\main\\java\\struts\\..\\struts\\Action.java").apply(javaFile)).isTrue();
}

@Test
public void matches_inclusion_pattern() {
 assertThat(predicates.matchesPathPattern("src/main/**/Action.java").apply(javaFile)).isTrue();
 assertThat(predicates.matchesPathPattern("Action.java").apply(javaFile)).isFalse();
 assertThat(predicates.matchesPathPattern("src/**/*.php").apply(javaFile)).isFalse();
}

@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");
}

@Test
public void filesWithDefaultPredicate() {
 DefaultInputFile file1 = new TestInputFileBuilder("foo", "src/Foo.php").setLanguage("php").build();
 fs.add(file1);
 fs.add(new TestInputFileBuilder("foo", "src/Bar.java").setLanguage("java").build());
 fs.add(new TestInputFileBuilder("foo", "src/Baz.java").setLanguage("java").build());
 fs.setDefaultPredicate(p -> f -> f.relativePath().endsWith("Foo.php"));
 Iterator<File> iterator = fs.files(fs.predicates().all()).iterator();
 assertThat(iterator.hasNext()).isTrue();
 assertThat(iterator.next()).isEqualTo(file1.file());
 assertThat(iterator.hasNext()).isFalse();
}

@Test
public void all() {
 assertThat(predicates.all().apply(javaFile)).isTrue();
}

@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 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();
 }
}

@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);
}

@CheckForNull
private static InputFile findFile(SensorContext context, String filePath) {
 return context.fileSystem().inputFile(context.fileSystem().predicates().hasPath(filePath));
}

 private InputFile getSourceFile(InputFile file, Element refElement) {
  Element parentNode = (Element) refElement.getParentNode();
  String fileNum = getChildNodeValue(refElement, "File-num");
  if ("1".equals(fileNum)) {
   return file;
  } else {
   return getContext().fileSystem().inputFile(
     getContext().fileSystem().predicates().hasRelativePath(parentNode.getAttribute("File-name")));
  }
 }
}

  @Override
  public InputFile getUnitTestResource(FileSystem fileSystem, String classname) {
    String fileName = classname.replace('.', '/') + ".m";

    FilePredicate fp = fileSystem.predicates().hasPath(fileName);
    if(fileSystem.hasFiles(fp)){
      return fileSystem.inputFile(fp);
    }

    /*
     * Most xcodebuild JUnit parsers don't include the path to the class in the class field, so search for it if it
     * wasn't found in the root.
     */
    fp = fileSystem.predicates().and(
      fileSystem.predicates().hasType(InputFile.Type.TEST),
      fileSystem.predicates().matchesPathPattern("**/" + fileName.replace("_", "+")));

    if(fileSystem.hasFiles(fp)){
      /*
       * Lazily get the first file, since we wouldn't be able to determine the correct one from just the
       * test class name in the event that there are multiple matches.
       */
      return fileSystem.inputFiles(fp).iterator().next();
    }
    LOGGER.info("Unable to locate test source file {}", fileName);
    return null;
  }
}