jenkins.scm.api.SCMFile Java Examples

@NonNull
@Override
public Iterable<SCMFile> children() throws IOException, InterruptedException {
    if (!this.isDirectory()) {
        throw new IOException("Cannot get children from a regular file");
    }
    List<TreeItem> treeItems = fetchTree();
    List<SCMFile> result = new ArrayList<>(treeItems.size());
    for (TreeItem c : treeItems) {
        Type t;
        if (c.getType() == TreeItem.Type.TREE) {
            t = Type.DIRECTORY;
        } else if (c.getType() == TreeItem.Type.BLOB) {
            if ("120000".equals(c.getMode())) {
                // File Mode 120000 is a symlink
                t = Type.LINK;
            } else {
                t = Type.REGULAR_FILE;
            }
        } else {
            t = Type.OTHER;
        }
        result.add(new GitLabSCMFile(this, c.getName(), t));
    }
    return result;
}
 

@Test
public void resolveDirPRHead() throws Exception {
    assumeThat(revision, nullValue());

    assertThat(prHeadRevision.isMerge(), is(false));

    SCMFileSystem fs = SCMFileSystem.of(source, prHead, prHeadRevision);
    assertThat(fs, instanceOf(GitHubSCMFileSystem.class));

    // We can't check the sha, but we can check last modified
    // which are different for head or merge
    assertThat(((GitHubSCMFileSystem)fs).lastModified(),
        is(1480691047000L));

    assertThat(fs.getRoot().child("fu").getType(), is(SCMFile.Type.DIRECTORY));
}
 

@Test
public void resolveDirPRMerge() throws Exception {
    assumeThat(revision, nullValue());

    assertThat(prMergeRevision.isMerge(), is(true));

    SCMFileSystem fs = SCMFileSystem.of(source, prMerge, prMergeRevision);
    assertThat(fs, instanceOf(GitHubSCMFileSystem.class));

    // We can't check the sha, but we can check last modified
    // which are different for head or merge
    assertThat(((GitHubSCMFileSystem)fs).lastModified(),
        is(1480777447000L));

    assertThat(fs.getRoot().child("fu").getType(), is(SCMFile.Type.DIRECTORY));
}
 

@Override
public SCMFile getRoot() {
    if (repo == null) {
        return null;
    }
    synchronized (this) {
        if (!open) {
            return null;
        }
    }
    String ref;
    if (revision != null) {
        if (revision.getHead() instanceof PullRequestSCMHead) {
            ref = this.ref;
        } else if (revision instanceof AbstractGitSCMSource.SCMRevisionImpl){
            ref = ((AbstractGitSCMSource.SCMRevisionImpl) revision).getHash();
        } else {
            ref = this.ref;
        }
    } else {
        ref = this.ref;
    }
    return new GitHubSCMFile(this, repo, ref);
}
 

@Nonnull
private SCMProbeStat stat(String root, String name) throws GitLabAPIException, FileNotFoundException {
    for (GitlabRepositoryTree content : api().getTree(projectId, hash, root)) {
        if (content.getName().equals(name)) {
            if (TYPE_BLOB.equals(content.getType())) {
                return SCMProbeStat.fromType(SCMFile.Type.REGULAR_FILE);
            } else if (TYPE_DIRECTORY.equals(content.getType())) {
                return SCMProbeStat.fromType(SCMFile.Type.DIRECTORY);
            } else {
                return SCMProbeStat.fromType(SCMFile.Type.OTHER);
            }
        }
    }

    throw new FileNotFoundException(root + "/" + name);
}
 

@Override
public boolean isHead(@Nonnull Probe probe, @Nonnull TaskListener listener) throws IOException {
    SCMProbeStat stat = probe.stat("Jenkinsfile");
    boolean foundJenkinsFile =  stat.getType() != SCMFile.Type.NONEXISTENT && stat.getType() != SCMFile.Type.DIRECTORY;
    if(foundJenkinsFile && !jenkinsFileFound.get()) {
        jenkinsFileFound.set(true);
    }
    return foundJenkinsFile;
}
 

@Test
public void resolveDir() throws Exception {
    assumeThat(revision, instanceOf(AbstractGitSCMSource.SCMRevisionImpl.class));
    assumeThat(((AbstractGitSCMSource.SCMRevisionImpl) revision).getHash(),
            is("c0e024f89969b976da165eecaa71e09dc60c3da1"));
    SCMFileSystem fs = SCMFileSystem.of(source, master, revision);
    assertThat(fs.getRoot().child("fu").getType(), is(SCMFile.Type.DIRECTORY));
}
 

@Test
public void listDir() throws Exception {
    assumeThat(revision, instanceOf(AbstractGitSCMSource.SCMRevisionImpl.class));
    assumeThat(((AbstractGitSCMSource.SCMRevisionImpl) revision).getHash(),
            is("c0e024f89969b976da165eecaa71e09dc60c3da1"));
    SCMFileSystem fs = SCMFileSystem.of(source, master, revision);
    assertThat(fs.getRoot().child("fu").children(),
            hasItem(Matchers.<SCMFile>hasProperty("name", is("manchu.txt"))));
}
 

@NonNull
@Override
public Iterable<SCMFile> children() throws IOException {
    checkOpen();
    List<GHContent> content = repo.getDirectoryContent(getPath(), ref.indexOf('/') == -1 ? ref : Constants.R_REFS + ref);
    List<SCMFile> result = new ArrayList<>(content.size());
    for (GHContent c : content) {
        result.add(new GitHubSCMFile(this, c.getName(), c));
    }
    return result;
}
 

Entry(String path, GHTreeEntry entry, boolean file) {
    this.path = path;
    this.entry = entry;
    this.file = file;

    if (entry != null) {
        type = SCMFile.Type.DIRECTORY;
    } else if (file) {
        type = SCMFile.Type.REGULAR_FILE;
    } else {
        type = SCMFile.Type.NONEXISTENT;
    }
}
 

@Nonnull
@Override
public SCMProbeStat stat(@Nonnull String path) throws IOException {
    try {
        int index = path.lastIndexOf('/') + 1;
        return stat(path.substring(0, index), path.substring(index));
    } catch (FileNotFoundException fnf) {
        return SCMProbeStat.fromType(SCMFile.Type.NONEXISTENT);
    }
}
 

@Nonnull
@Override
public Iterable<SCMFile> children() throws IOException, InterruptedException {
    return getEntry().getSubEntryNames().stream()
            .map(this::newChild)
            .collect(Collectors.toList());
}
 

@Test
public void rootIsADirectory() throws Exception {
    SCMFileSystem fs = SCMFileSystem.of(source, master, revision);
    assertThat(fs.getRoot().getType(), is(SCMFile.Type.DIRECTORY));

}
 

public SCMFile.Type getType() {
    return type;
}
 

private SCMFile newChild(@Nonnull String child) {
    return new GitHubSCMFile(this, child);
}
 

@Nonnull
@Override
protected SCMFile newChild(@Nonnull String child, boolean assumeIsDirectory) {
    return newChild(child);
}
 

@Nonnull
@Override
public SCMFile getRoot() {
    return new GitHubSCMFile(this);
}
 

@Test
public void readmeIsAFile() throws Exception {
    SCMFileSystem fs = SCMFileSystem.of(source, master, revision);
    assertThat(fs.getRoot().child("README.md").getType(), is(SCMFile.Type.REGULAR_FILE));
}
 

@Test
public void listFilesInRoot() throws Exception {
    SCMFileSystem fs = SCMFileSystem.of(source, master, revision);
    assertThat(fs.getRoot().children(), hasItem(Matchers.<SCMFile>hasProperty("name", is("README.md"))));
}
 

@NonNull
@Override
public SCMFile getRoot() {
    return new GitLabSCMFile(gitLabApi, projectPath, ref);
}
 

/**
 * {@inheritDoc}
 */
@NonNull
@Override
public SCMFile getRoot() {
    return new GitHubSCMFile(this, repo, ref);
}
 

@NonNull
@Override
protected SCMFile newChild(String name, boolean assumeIsDirectory) {
    return new GitHubSCMFile(this, name, assumeIsDirectory ? TypeInfo.DIRECTORY_ASSUMED: TypeInfo.UNRESOLVED);
}
 

@NonNull
@Override
public SCMFile getRoot() {
    return new GiteaSCMFile(connection, repo, ref);
}
 

@NonNull
@Override
public Iterable<SCMFile> children() throws IOException {
    // TODO once https://github.com/go-gitea/gitea/issues/1978
    return Collections.emptyList();
}
 

@NonNull
@Override
protected SCMFile newChild(String name, boolean assumeIsDirectory) {
    return new GiteaSCMFile(this, name, assumeIsDirectory ? Boolean.FALSE : null);
}
 

@NonNull
@Override
protected SCMFile newChild(@NonNull String name, boolean assumeIsDirectory) {
    return new GitLabSCMFile(this, name, assumeIsDirectory);
}