FileTreeIterator.java
/*
* Copyright (C) 2008, Google Inc.
* Copyright (C) 2007-2010, Robin Rosenberg <robin.rosenberg@dewire.com>
* Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
* Copyright (C) 2009, Tor Arne Vestbø <torarnv@gmail.com> and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.treewalk;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.time.Instant;
import org.eclipse.jgit.dircache.DirCacheIterator;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.util.FS;
/**
* Working directory iterator for standard Java IO.
* <p>
* This iterator uses the standard <code>java.io</code> package to read the
* specified working directory as part of a
* {@link org.eclipse.jgit.treewalk.TreeWalk}.
*/
public class FileTreeIterator extends WorkingTreeIterator {
/**
* the starting directory of this Iterator. All entries are located directly
* in this directory.
*/
protected final File directory;
/**
* the file system abstraction which will be necessary to perform certain
* file system operations.
*/
protected final FS fs;
/**
* the strategy used to compute the FileMode for a FileEntry. Can be used to
* control things such as whether to recurse into a directory or create a
* gitlink.
*
* @since 4.3
*/
protected final FileModeStrategy fileModeStrategy;
/**
* Create a new iterator to traverse the work tree and its children.
*
* @param repo
* the repository whose working tree will be scanned.
*/
public FileTreeIterator(Repository repo) {
this(repo,
repo.getConfig().get(WorkingTreeOptions.KEY).isDirNoGitLinks() ?
NoGitlinksStrategy.INSTANCE :
DefaultFileModeStrategy.INSTANCE);
}
/**
* Create a new iterator to traverse the work tree and its children.
*
* @param repo
* the repository whose working tree will be scanned.
* @param fileModeStrategy
* the strategy to use to determine the FileMode for a FileEntry;
* controls gitlinks etc.
* @since 4.3
*/
public FileTreeIterator(Repository repo, FileModeStrategy fileModeStrategy) {
this(repo.getWorkTree(), repo.getFS(),
repo.getConfig().get(WorkingTreeOptions.KEY),
fileModeStrategy);
initRootIterator(repo);
}
/**
* Create a new iterator to traverse the given directory and its children.
*
* @param root
* the starting directory. This directory should correspond to
* the root of the repository.
* @param fs
* the file system abstraction which will be necessary to perform
* certain file system operations.
* @param options
* working tree options to be used
*/
public FileTreeIterator(File root, FS fs, WorkingTreeOptions options) {
this(root, fs, options, DefaultFileModeStrategy.INSTANCE);
}
/**
* Create a new iterator to traverse the given directory and its children.
*
* @param root
* the starting directory. This directory should correspond to
* the root of the repository.
* @param fs
* the file system abstraction which will be necessary to perform
* certain file system operations.
* @param options
* working tree options to be used
* @param fileModeStrategy
* the strategy to use to determine the FileMode for a FileEntry;
* controls gitlinks etc.
* @since 4.3
*/
public FileTreeIterator(final File root, FS fs, WorkingTreeOptions options,
FileModeStrategy fileModeStrategy) {
super(options);
directory = root;
this.fs = fs;
this.fileModeStrategy = fileModeStrategy;
init(entries());
}
/**
* Create a new iterator to traverse a subdirectory.
*
* @param p
* the parent iterator we were created from.
* @param root
* the subdirectory. This should be a directory contained within
* the parent directory.
* @param fs
* the file system abstraction which will be necessary to perform
* certain file system operations.
* @since 4.3
*/
protected FileTreeIterator(final FileTreeIterator p, final File root,
FS fs) {
this(p, root, fs, p.fileModeStrategy);
}
/**
* Create a new iterator to traverse a subdirectory, given the specified
* FileModeStrategy.
*
* @param p
* the parent iterator we were created from.
* @param root
* the subdirectory. This should be a directory contained within
* the parent directory
* @param fs
* the file system abstraction which will be necessary to perform
* certain file system operations.
* @param fileModeStrategy
* the strategy to use to determine the FileMode for a given
* FileEntry.
* @since 4.3
*/
protected FileTreeIterator(final WorkingTreeIterator p, final File root,
FS fs, FileModeStrategy fileModeStrategy) {
super(p);
directory = root;
this.fs = fs;
this.fileModeStrategy = fileModeStrategy;
init(entries());
}
/** {@inheritDoc} */
@Override
public AbstractTreeIterator createSubtreeIterator(ObjectReader reader)
throws IncorrectObjectTypeException, IOException {
if (!walksIgnoredDirectories() && isEntryIgnored()) {
DirCacheIterator iterator = getDirCacheIterator();
if (iterator == null) {
return new EmptyTreeIterator(this);
}
// Only enter if we have an associated DirCacheIterator that is
// at the same entry (which indicates there is some already
// tracked file underneath this directory). Otherwise the
// directory is indeed ignored and can be skipped entirely.
}
return enterSubtree();
}
/**
* Create a new iterator for the current entry's subtree.
* <p>
* The parent reference of the iterator must be <code>this</code>, otherwise
* the caller would not be able to exit out of the subtree iterator
* correctly and return to continue walking <code>this</code>.
*
* @return a new iterator that walks over the current subtree.
* @since 5.0
*/
protected AbstractTreeIterator enterSubtree() {
return new FileTreeIterator(this, ((FileEntry) current()).getFile(), fs,
fileModeStrategy);
}
private Entry[] entries() {
return fs.list(directory, fileModeStrategy);
}
/**
* An interface representing the methods used to determine the FileMode for
* a FileEntry.
*
* @since 4.3
*/
public interface FileModeStrategy {
/**
* Compute the FileMode for a given File, based on its attributes.
*
* @param f
* the file to return a FileMode for
* @param attributes
* the attributes of a file
* @return a FileMode indicating whether the file is a regular file, a
* directory, a gitlink, etc.
*/
FileMode getMode(File f, FS.Attributes attributes);
}
/**
* A default implementation of a FileModeStrategy; defaults to treating
* nested .git directories as gitlinks, etc.
*
* @since 4.3
*/
public static class DefaultFileModeStrategy implements FileModeStrategy {
/**
* a singleton instance of the default FileModeStrategy
*/
public static final DefaultFileModeStrategy INSTANCE =
new DefaultFileModeStrategy();
@Override
public FileMode getMode(File f, FS.Attributes attributes) {
if (attributes.isSymbolicLink()) {
return FileMode.SYMLINK;
} else if (attributes.isDirectory()) {
if (new File(f, Constants.DOT_GIT).exists()) {
return FileMode.GITLINK;
}
return FileMode.TREE;
} else if (attributes.isExecutable()) {
return FileMode.EXECUTABLE_FILE;
} else {
return FileMode.REGULAR_FILE;
}
}
}
/**
* A FileModeStrategy that implements native git's DIR_NO_GITLINKS
* behavior. This is the same as the default FileModeStrategy, except
* all directories will be treated as directories regardless of whether
* or not they contain a .git directory or file.
*
* @since 4.3
*/
public static class NoGitlinksStrategy implements FileModeStrategy {
/**
* a singleton instance of the default FileModeStrategy
*/
public static final NoGitlinksStrategy INSTANCE = new NoGitlinksStrategy();
@Override
public FileMode getMode(File f, FS.Attributes attributes) {
if (attributes.isSymbolicLink()) {
return FileMode.SYMLINK;
} else if (attributes.isDirectory()) {
return FileMode.TREE;
} else if (attributes.isExecutable()) {
return FileMode.EXECUTABLE_FILE;
} else {
return FileMode.REGULAR_FILE;
}
}
}
/**
* Wrapper for a standard Java IO file
*/
public static class FileEntry extends Entry {
private final FileMode mode;
private FS.Attributes attributes;
private FS fs;
/**
* Create a new file entry.
*
* @param f
* file
* @param fs
* file system
*/
public FileEntry(File f, FS fs) {
this(f, fs, DefaultFileModeStrategy.INSTANCE);
}
/**
* Create a new file entry given the specified FileModeStrategy
*
* @param f
* file
* @param fs
* file system
* @param fileModeStrategy
* the strategy to use when determining the FileMode of a
* file; controls gitlinks etc.
*
* @since 4.3
*/
public FileEntry(File f, FS fs, FileModeStrategy fileModeStrategy) {
this.fs = fs;
f = fs.normalize(f);
attributes = fs.getAttributes(f);
mode = fileModeStrategy.getMode(f, attributes);
}
/**
* Create a new file entry given the specified FileModeStrategy
*
* @param f
* file
* @param fs
* file system
* @param attributes
* of the file
* @param fileModeStrategy
* the strategy to use when determining the FileMode of a
* file; controls gitlinks etc.
*
* @since 5.0
*/
public FileEntry(File f, FS fs, FS.Attributes attributes,
FileModeStrategy fileModeStrategy) {
this.fs = fs;
this.attributes = attributes;
f = fs.normalize(f);
mode = fileModeStrategy.getMode(f, attributes);
}
@Override
public FileMode getMode() {
return mode;
}
@Override
public String getName() {
return attributes.getName();
}
@Override
public long getLength() {
return attributes.getLength();
}
@Override
@Deprecated
public long getLastModified() {
return attributes.getLastModifiedInstant().toEpochMilli();
}
/**
* @since 5.1.9
*/
@Override
public Instant getLastModifiedInstant() {
return attributes.getLastModifiedInstant();
}
@Override
public InputStream openInputStream() throws IOException {
if (attributes.isSymbolicLink()) {
return new ByteArrayInputStream(fs.readSymLink(getFile())
.getBytes(UTF_8));
}
return new FileInputStream(getFile());
}
/**
* Get the underlying file of this entry.
*
* @return the underlying file of this entry
*/
public File getFile() {
return attributes.getFile();
}
}
/**
* <p>Getter for the field <code>directory</code>.</p>
*
* @return The root directory of this iterator
*/
public File getDirectory() {
return directory;
}
/**
* Get the location of the working file.
*
* @return The location of the working file. This is the same as {@code new
* File(getDirectory(), getEntryPath())} but may be faster by
* reusing an internal File instance.
*/
public File getEntryFile() {
return ((FileEntry) current()).getFile();
}
/** {@inheritDoc} */
@Override
protected byte[] idSubmodule(Entry e) {
return idSubmodule(getDirectory(), e);
}
/** {@inheritDoc} */
@Override
protected String readSymlinkTarget(Entry entry) throws IOException {
return fs.readSymLink(getEntryFile());
}
}