* This handles relative URLs that are typically specified in the * '.gitmodules' file by resolving them against the remote URL of the parent * repository. *
* Relative URLs will be resolved against the parent repository's working
* directory if the parent repository has no configured remote URL.
*
* @param parent
* parent repository
* @param url
* absolute or relative URL of the submodule repository
* @return resolved URL
* @throws java.io.IOException
*/
public static String getSubmoduleRemoteUrl(final Repository parent,
final String url) throws IOException {
if (!url.startsWith("./") && !url.startsWith("../")) //$NON-NLS-1$ //$NON-NLS-2$
return url;
String remoteName = null;
// Look up remote URL associated wit HEAD ref
Ref ref = parent.exactRef(Constants.HEAD);
if (ref != null) {
if (ref.isSymbolic())
ref = ref.getLeaf();
remoteName = parent.getConfig().getString(
ConfigConstants.CONFIG_BRANCH_SECTION,
Repository.shortenRefName(ref.getName()),
ConfigConstants.CONFIG_KEY_REMOTE);
}
// Fall back to 'origin' if current HEAD ref has no remote URL
if (remoteName == null)
remoteName = Constants.DEFAULT_REMOTE_NAME;
String remoteUrl = parent.getConfig().getString(
ConfigConstants.CONFIG_REMOTE_SECTION, remoteName,
ConfigConstants.CONFIG_KEY_URL);
// Fall back to parent repository's working directory if no remote URL
if (remoteUrl == null) {
remoteUrl = parent.getWorkTree().getAbsolutePath();
// Normalize slashes to '/'
if ('\\' == File.separatorChar)
remoteUrl = remoteUrl.replace('\\', '/');
}
// Remove trailing '/'
if (remoteUrl.charAt(remoteUrl.length() - 1) == '/')
remoteUrl = remoteUrl.substring(0, remoteUrl.length() - 1);
char separator = '/';
String submoduleUrl = url;
while (submoduleUrl.length() > 0) {
if (submoduleUrl.startsWith("./")) //$NON-NLS-1$
submoduleUrl = submoduleUrl.substring(2);
else if (submoduleUrl.startsWith("../")) { //$NON-NLS-1$
int lastSeparator = remoteUrl.lastIndexOf('/');
if (lastSeparator < 1) {
lastSeparator = remoteUrl.lastIndexOf(':');
separator = ':';
}
if (lastSeparator < 1)
throw new IOException(MessageFormat.format(
JGitText.get().submoduleParentRemoteUrlInvalid,
remoteUrl));
remoteUrl = remoteUrl.substring(0, lastSeparator);
submoduleUrl = submoduleUrl.substring(3);
} else
break;
}
return remoteUrl + separator + submoduleUrl;
}
private final Repository repository;
private final TreeWalk walk;
private StoredConfig repoConfig;
private AbstractTreeIterator rootTree;
private Config modulesConfig;
private String path;
private Map
* The root tree is not read until the first submodule is encountered by the
* walk.
*
* This method need only be called if constructing a walk manually instead of
* with one of the static factory methods above.
*
* @param tree
* tree containing .gitmodules
* @return this generator
*/
public SubmoduleWalk setRootTree(AbstractTreeIterator tree) {
rootTree = tree;
modulesConfig = null;
pathToName = null;
return this;
}
/**
* Set the tree used by this walk for finding {@code .gitmodules}.
*
* The root tree is not read until the first submodule is encountered by the
* walk.
*
* This method need only be called if constructing a walk manually instead of
* with one of the static factory methods above.
*
* @param id
* ID of a tree containing .gitmodules
* @return this generator
* @throws java.io.IOException
*/
public SubmoduleWalk setRootTree(AnyObjectId id) throws IOException {
final CanonicalTreeParser p = new CanonicalTreeParser();
p.reset(walk.getObjectReader(), id);
rootTree = p;
modulesConfig = null;
pathToName = null;
return this;
}
/**
* Load the config for this walk from {@code .gitmodules}.
*
* Uses the root tree if {@link #setRootTree(AbstractTreeIterator)} was
* previously called, otherwise uses the working tree.
*
* If no submodule config is found, loads an empty config.
*
* @return this generator
* @throws java.io.IOException
* if an error occurred, or if the repository is bare
* @throws org.eclipse.jgit.errors.ConfigInvalidException
*/
public SubmoduleWalk loadModulesConfig() throws IOException, ConfigInvalidException {
if (rootTree == null) {
File modulesFile = new File(repository.getWorkTree(),
Constants.DOT_GIT_MODULES);
FileBasedConfig config = new FileBasedConfig(modulesFile,
repository.getFS());
config.load();
modulesConfig = config;
loadPathNames();
} else {
try (TreeWalk configWalk = new TreeWalk(repository)) {
configWalk.addTree(rootTree);
// The root tree may be part of the submodule walk, so we need to revert
// it after this walk.
int idx;
for (idx = 0; !rootTree.first(); idx++) {
rootTree.back(1);
}
try {
configWalk.setRecursive(false);
PathFilter filter = PathFilter.create(Constants.DOT_GIT_MODULES);
configWalk.setFilter(filter);
while (configWalk.next()) {
if (filter.isDone(configWalk)) {
modulesConfig = new BlobBasedConfig(null, repository,
configWalk.getObjectId(0));
loadPathNames();
return this;
}
}
modulesConfig = new Config();
pathToName = null;
} finally {
if (idx > 0)
rootTree.next(idx);
}
}
}
return this;
}
private void loadPathNames() {
pathToName = null;
if (modulesConfig != null) {
HashMap
* This method resolves the value of {@link #getModulesUrl()} to an absolute
* URL
*
* @return resolved remote URL
* @throws java.io.IOException
* @throws org.eclipse.jgit.errors.ConfigInvalidException
*/
public String getRemoteUrl() throws IOException, ConfigInvalidException {
String url = getModulesUrl();
return url != null ? getSubmoduleRemoteUrl(repository, url) : null;
}
/**
* {@inheritDoc}
*
* Release any resources used by this walker's reader.
*
* @since 4.0
*/
@Override
public void close() {
walk.close();
}
}
true if the working tree contains a .gitmodules file,
* false otherwise. Always returns false
* for bare repositories.
* @throws java.io.IOException
* @throws CorruptObjectException if any.
* @since 3.6
*/
public static boolean containsGitModulesFile(Repository repository)
throws IOException {
if (repository.isBare()) {
return false;
}
File modulesFile = new File(repository.getWorkTree(),
Constants.DOT_GIT_MODULES);
return (modulesFile.exists());
}
private void lazyLoadModulesConfig() throws IOException, ConfigInvalidException {
if (modulesConfig == null) {
loadModulesConfig();
}
}
private String getModuleName(String modulePath) {
String name = pathToName != null ? pathToName.get(modulePath) : null;
return name != null ? name : modulePath;
}
/**
* Set tree filter
*
* @param filter
* a {@link org.eclipse.jgit.treewalk.filter.TreeFilter} object.
* @return this generator
*/
public SubmoduleWalk setFilter(TreeFilter filter) {
walk.setFilter(filter);
return this;
}
/**
* Set the tree iterator used for finding submodule entries
*
* @param iterator
* an {@link org.eclipse.jgit.treewalk.AbstractTreeIterator}
* object.
* @return this generator
* @throws org.eclipse.jgit.errors.CorruptObjectException
*/
public SubmoduleWalk setTree(AbstractTreeIterator iterator)
throws CorruptObjectException {
walk.addTree(iterator);
return this;
}
/**
* Set the tree used for finding submodule entries
*
* @param treeId
* an {@link org.eclipse.jgit.lib.AnyObjectId} object.
* @return this generator
* @throws java.io.IOException
* @throws IncorrectObjectTypeException
* if any.
* @throws MissingObjectException
* if any.
*/
public SubmoduleWalk setTree(AnyObjectId treeId) throws IOException {
walk.addTree(treeId);
return this;
}
/**
* Reset generator and start new submodule walk
*
* @return this generator
*/
public SubmoduleWalk reset() {
repoConfig = repository.getConfig();
modulesConfig = null;
pathToName = null;
walk.reset();
return this;
}
/**
* Get directory that will be the root of the submodule's local repository
*
* @return submodule repository directory
*/
public File getDirectory() {
return getSubmoduleDirectory(repository, path);
}
/**
* Advance to next submodule in the index tree.
*
* The object id and path of the next entry can be obtained by calling
* {@link #getObjectId()} and {@link #getPath()}.
*
* @return true if entry found, false otherwise
* @throws java.io.IOException
*/
public boolean next() throws IOException {
while (walk.next()) {
if (FileMode.GITLINK != walk.getFileMode(0))
continue;
path = walk.getPathString();
return true;
}
path = null;
return false;
}
/**
* Get path of current submodule entry
*
* @return path
*/
public String getPath() {
return path;
}
/**
* The module name for the current submodule entry (used for the section name of .git/config)
* @since 4.10
* @return name
*/
public String getModuleName() {
return getModuleName(path);
}
/**
* Get object id of current submodule entry
*
* @return object id
*/
public ObjectId getObjectId() {
return walk.getObjectId(0);
}
/**
* Get the configured path for current entry. This will be the value from
* the .gitmodules file in the current repository's working tree.
*
* @return configured path
* @throws org.eclipse.jgit.errors.ConfigInvalidException
* @throws java.io.IOException
*/
public String getModulesPath() throws IOException, ConfigInvalidException {
lazyLoadModulesConfig();
return modulesConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
getModuleName(), ConfigConstants.CONFIG_KEY_PATH);
}
/**
* Get the configured remote URL for current entry. This will be the value
* from the repository's config.
*
* @return configured URL
* @throws org.eclipse.jgit.errors.ConfigInvalidException
* @throws java.io.IOException
*/
public String getConfigUrl() throws IOException, ConfigInvalidException {
return repoConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
getModuleName(), ConfigConstants.CONFIG_KEY_URL);
}
/**
* Get the configured remote URL for current entry. This will be the value
* from the .gitmodules file in the current repository's working tree.
*
* @return configured URL
* @throws org.eclipse.jgit.errors.ConfigInvalidException
* @throws java.io.IOException
*/
public String getModulesUrl() throws IOException, ConfigInvalidException {
lazyLoadModulesConfig();
return modulesConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
getModuleName(), ConfigConstants.CONFIG_KEY_URL);
}
/**
* Get the configured update field for current entry. This will be the value
* from the repository's config.
*
* @return update value
* @throws org.eclipse.jgit.errors.ConfigInvalidException
* @throws java.io.IOException
*/
public String getConfigUpdate() throws IOException, ConfigInvalidException {
return repoConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
getModuleName(), ConfigConstants.CONFIG_KEY_UPDATE);
}
/**
* Get the configured update field for current entry. This will be the value
* from the .gitmodules file in the current repository's working tree.
*
* @return update value
* @throws org.eclipse.jgit.errors.ConfigInvalidException
* @throws java.io.IOException
*/
public String getModulesUpdate() throws IOException, ConfigInvalidException {
lazyLoadModulesConfig();
return modulesConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
getModuleName(), ConfigConstants.CONFIG_KEY_UPDATE);
}
/**
* Get the configured ignore field for the current entry. This will be the
* value from the .gitmodules file in the current repository's working tree.
*
* @return ignore value
* @throws org.eclipse.jgit.errors.ConfigInvalidException
* @throws java.io.IOException
* @since 3.6
*/
public IgnoreSubmoduleMode getModulesIgnore() throws IOException,
ConfigInvalidException {
lazyLoadModulesConfig();
return modulesConfig.getEnum(IgnoreSubmoduleMode.values(),
ConfigConstants.CONFIG_SUBMODULE_SECTION, getModuleName(),
ConfigConstants.CONFIG_KEY_IGNORE, IgnoreSubmoduleMode.NONE);
}
/**
* Get repository for current submodule entry
*
* @return repository or null if non-existent
* @throws java.io.IOException
*/
public Repository getRepository() throws IOException {
return getSubmoduleRepository(repository, path);
}
/**
* Get commit id that HEAD points to in the current submodule's repository
*
* @return object id of HEAD reference
* @throws java.io.IOException
*/
public ObjectId getHead() throws IOException {
try (Repository subRepo = getRepository()) {
if (subRepo == null) {
return null;
}
return subRepo.resolve(Constants.HEAD);
}
}
/**
* Get ref that HEAD points to in the current submodule's repository
*
* @return ref name, null on failures
* @throws java.io.IOException
*/
public String getHeadRef() throws IOException {
try (Repository subRepo = getRepository()) {
if (subRepo == null) {
return null;
}
Ref head = subRepo.exactRef(Constants.HEAD);
return head != null ? head.getLeaf().getName() : null;
}
}
/**
* Get the resolved remote URL for the current submodule.
*