org.eclipse.jgit/src/org/eclipse/jgit/submodule/SubmoduleWalk.java - sop/jgit - Git at Google

 /*
  * Copyright (C) 2011, GitHub Inc.
  * and other copyright owners as documented in the project's IP log.
  *
  * This program and the accompanying materials are made available
  * under the terms of the Eclipse Distribution License v1.0 which
  * accompanies this distribution, is reproduced below, and is
  * available at http://www.eclipse.org/org/documents/edl-v10.php
  *
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or
  * without modification, are permitted provided that the following
  * conditions are met:
  *
  * - Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  *
  * - Redistributions in binary form must reproduce the above
  *   copyright notice, this list of conditions and the following
  *   disclaimer in the documentation and/or other materials provided
  *   with the distribution.
  *
  * - Neither the name of the Eclipse Foundation, Inc. nor the
  *   names of its contributors may be used to endorse or promote
  *   products derived from this software without specific prior
  *   written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 package org.eclipse.jgit.submodule;

 import java.io.File;
 import java.io.IOException;
 import java.text.MessageFormat;
 import java.util.Locale;

 import org.eclipse.jgit.dircache.DirCache;
 import org.eclipse.jgit.dircache.DirCacheIterator;
 import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.eclipse.jgit.errors.CorruptObjectException;
 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
 import org.eclipse.jgit.errors.MissingObjectException;
 import org.eclipse.jgit.errors.RepositoryNotFoundException;
 import org.eclipse.jgit.internal.JGitText;
 import org.eclipse.jgit.lib.AnyObjectId;
 import org.eclipse.jgit.lib.BlobBasedConfig;
 import org.eclipse.jgit.lib.Config;
 import org.eclipse.jgit.lib.ConfigConstants;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.RepositoryBuilder;
 import org.eclipse.jgit.lib.StoredConfig;
 import org.eclipse.jgit.storage.file.FileBasedConfig;
 import org.eclipse.jgit.treewalk.AbstractTreeIterator;
 import org.eclipse.jgit.treewalk.CanonicalTreeParser;
 import org.eclipse.jgit.treewalk.TreeWalk;
 import org.eclipse.jgit.treewalk.filter.PathFilter;
 import org.eclipse.jgit.treewalk.filter.TreeFilter;
 import org.eclipse.jgit.util.FS;

 /**
  * Walker that visits all submodule entries found in a tree
  */
 public class SubmoduleWalk implements AutoCloseable {

 	/**
 	 * The values for the config param submodule.<name>.ignore
 	 *
 	 * @since 3.6
 	 */
 	public enum IgnoreSubmoduleMode {
 		/**
 		 * Ignore all modifications to submodules
 		 */
 		ALL,

 		/**
 		 * Ignore changes to the working tree of a submodule
 		 */
 		DIRTY,

 		/**
 		 * Ignore changes to untracked files in the working tree of a submodule
 		 */
 		UNTRACKED,

 		/**
 		 * Ignore nothing. That's the default
 		 */
 		NONE;
 	}

 	/**
 	 * Create a generator to walk over the submodule entries currently in the
 	 * index
 	 *
 	 * The {@code .gitmodules} file is read from the index.
 	 *
 	 * @param repository
 	 * @return generator over submodule index entries
 	 * @throws IOException
 	 */
 	public static SubmoduleWalk forIndex(Repository repository)
 			throws IOException {
 		SubmoduleWalk generator = new SubmoduleWalk(repository);
 		try {
 			DirCache index = repository.readDirCache();
 			generator.setTree(new DirCacheIterator(index));
 		} catch (IOException e) {
 			generator.close();
 			throw e;
 		}
 		return generator;
 	}

 	/**
 	 * Create a generator and advance it to the submodule entry at the given
 	 * path
 	 *
 	 * @param repository
 	 * @param treeId
 	 *            the root of a tree containing both a submodule at the given path
 	 *            and .gitmodules at the root.
 	 * @param path
 	 * @return generator at given path, null if no submodule at given path
 	 * @throws IOException
 	 */
 	public static SubmoduleWalk forPath(Repository repository,
 			AnyObjectId treeId, String path) throws IOException {
 		SubmoduleWalk generator = new SubmoduleWalk(repository);
 		try {
 			generator.setTree(treeId);
 			PathFilter filter = PathFilter.create(path);
 			generator.setFilter(filter);
 			generator.setRootTree(treeId);
 			while (generator.next())
 				if (filter.isDone(generator.walk))
 					return generator;
 		} catch (IOException e) {
 			generator.close();
 			throw e;
 		}
 		generator.close();
 		return null;
 	}

 	/**
 	 * Create a generator and advance it to the submodule entry at the given
 	 * path
 	 *
 	 * @param repository
 	 * @param iterator
 	 *            the root of a tree containing both a submodule at the given path
 	 *            and .gitmodules at the root.
 	 * @param path
 	 * @return generator at given path, null if no submodule at given path
 	 * @throws IOException
 	 */
 	public static SubmoduleWalk forPath(Repository repository,
 			AbstractTreeIterator iterator, String path) throws IOException {
 		SubmoduleWalk generator = new SubmoduleWalk(repository);
 		try {
 			generator.setTree(iterator);
 			PathFilter filter = PathFilter.create(path);
 			generator.setFilter(filter);
 			generator.setRootTree(iterator);
 			while (generator.next())
 				if (filter.isDone(generator.walk))
 					return generator;
 		} catch (IOException e) {
 			generator.close();
 			throw e;
 		}
 		generator.close();
 		return null;
 	}

 	/**
 	 * Get submodule directory
 	 *
 	 * @param parent
 	 * @param path
 	 * @return directory
 	 */
 	public static File getSubmoduleDirectory(final Repository parent,
 			final String path) {
 		return new File(parent.getWorkTree(), path);
 	}

 	/**
 	 * Get submodule repository
 	 *
 	 * @param parent
 	 * @param path
 	 * @return repository or null if repository doesn't exist
 	 * @throws IOException
 	 */
 	public static Repository getSubmoduleRepository(final Repository parent,
 			final String path) throws IOException {
 		return getSubmoduleRepository(parent.getWorkTree(), path);
 	}

 	/**
 	 * Get submodule repository at path
 	 *
 	 * @param parent
 	 * @param path
 	 * @return repository or null if repository doesn't exist
 	 * @throws IOException
 	 */
 	public static Repository getSubmoduleRepository(final File parent,
 			final String path) throws IOException {
 		File subWorkTree = new File(parent, path);
 		if (!subWorkTree.isDirectory())
 			return null;
 		File workTree = new File(parent, path);
 		try {
 			return new RepositoryBuilder() //
 					.setMustExist(true) //
 					.setFS(FS.DETECTED) //
 					.setWorkTree(workTree) //
 					.build();
 		} catch (RepositoryNotFoundException e) {
 			return null;
 		}
 	}

 	/**
 	 * Resolve submodule repository URL.
 	 * <p>
 	 * This handles relative URLs that are typically specified in the
 	 * '.gitmodules' file by resolving them against the remote URL of the parent
 	 * repository.
 	 * <p>
 	 * 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 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;

 	/**
 	 * Create submodule generator
 	 *
 	 * @param repository
 	 * @throws IOException
 	 */
 	public SubmoduleWalk(final Repository repository) throws IOException {
 		this.repository = repository;
 		repoConfig = repository.getConfig();
 		walk = new TreeWalk(repository);
 		walk.setRecursive(true);
 	}

 	/**
 	 * Set the config used by this walk.
 	 *
 	 * This method need only be called if constructing a walk manually instead of
 	 * with one of the static factory methods above.
 	 *
 	 * @param config
 	 *            .gitmodules config object
 	 * @return this generator
 	 */
 	public SubmoduleWalk setModulesConfig(final Config config) {
 		modulesConfig = config;
 		return this;
 	}

 	/**
 	 * Set the tree used by this walk for finding {@code .gitmodules}.
 	 * <p>
 	 * The root tree is not read until the first submodule is encountered by the
 	 * walk.
 	 * <p>
 	 * 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(final AbstractTreeIterator tree) {
 		rootTree = tree;
 		modulesConfig = null;
 		return this;
 	}

 	/**
 	 * Set the tree used by this walk for finding {@code .gitmodules}.
 	 * <p>
 	 * The root tree is not read until the first submodule is encountered by the
 	 * walk.
 	 * <p>
 	 * 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 IOException
 	 */
 	public SubmoduleWalk setRootTree(final AnyObjectId id) throws IOException {
 		final CanonicalTreeParser p = new CanonicalTreeParser();
 		p.reset(walk.getObjectReader(), id);
 		rootTree = p;
 		modulesConfig = null;
 		return this;
 	}

 	/**
 	 * Load the config for this walk from {@code .gitmodules}.
 	 * <p>
 	 * Uses the root tree if {@link #setRootTree(AbstractTreeIterator)} was
 	 * previously called, otherwise uses the working tree.
 	 * <p>
 	 * If no submodule config is found, loads an empty config.
 	 *
 	 * @return this generator
 	 * @throws IOException if an error occurred, or if the repository is bare
 	 * @throws 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;
 		} 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));
 							return this;
 						}
 					}
 					modulesConfig = new Config();
 				} finally {
 					if (idx > 0)
 						rootTree.next(idx);
 				}
 			}
 		}
 		return this;
 	}

 	/**
 	 * Checks whether the working tree contains a .gitmodules file. That's a
 	 * hint that the repo contains submodules.
 	 *
 	 * @param repository
 	 *            the repository to check
 	 * @return <code>true</code> if the working tree contains a .gitmodules file,
 	 *         <code>false</code> otherwise. Always returns <code>false</code>
 	 *         for bare repositories.
 	 * @throws IOException
 	 * @throws CorruptObjectException
 	 * @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();
 	}

 	/**
 	 * Set tree filter
 	 *
 	 * @param filter
 	 * @return this generator
 	 */
 	public SubmoduleWalk setFilter(TreeFilter filter) {
 		walk.setFilter(filter);
 		return this;
 	}

 	/**
 	 * Set the tree iterator used for finding submodule entries
 	 *
 	 * @param iterator
 	 * @return this generator
 	 * @throws CorruptObjectException
 	 */
 	public SubmoduleWalk setTree(final AbstractTreeIterator iterator)
 			throws CorruptObjectException {
 		walk.addTree(iterator);
 		return this;
 	}

 	/**
 	 * Set the tree used for finding submodule entries
 	 *
 	 * @param treeId
 	 * @return this generator
 	 * @throws IOException
 	 * @throws IncorrectObjectTypeException
 	 * @throws MissingObjectException
 	 */
 	public SubmoduleWalk setTree(final 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;
 		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 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;
 	}

 	/**
 	 * 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 ConfigInvalidException
 	 * @throws IOException
 	 */
 	public String getModulesPath() throws IOException, ConfigInvalidException {
 		lazyLoadModulesConfig();
 		return modulesConfig.getString(
 				ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
 				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 ConfigInvalidException
 	 * @throws IOException
 	 */
 	public String getConfigUrl() throws IOException, ConfigInvalidException {
 		return repoConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
 				path, 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 ConfigInvalidException
 	 * @throws IOException
 	 */
 	public String getModulesUrl() throws IOException, ConfigInvalidException {
 		lazyLoadModulesConfig();
 		return modulesConfig.getString(
 				ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
 				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 ConfigInvalidException
 	 * @throws IOException
 	 */
 	public String getConfigUpdate() throws IOException, ConfigInvalidException {
 		return repoConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
 				path, 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 ConfigInvalidException
 	 * @throws IOException
 	 */
 	public String getModulesUpdate() throws IOException, ConfigInvalidException {
 		lazyLoadModulesConfig();
 		return modulesConfig.getString(
 				ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
 				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 ConfigInvalidException
 	 * @throws IOException
 	 * @since 3.6
 	 */
 	public IgnoreSubmoduleMode getModulesIgnore() throws IOException,
 			ConfigInvalidException {
 		lazyLoadModulesConfig();
 		String name = modulesConfig.getString(
 				ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
 				ConfigConstants.CONFIG_KEY_IGNORE);
 		if (name == null)
 			return null;
 		return IgnoreSubmoduleMode
 				.valueOf(name.trim().toUpperCase(Locale.ROOT));
 	}

 	/**
 	 * Get repository for current submodule entry
 	 *
 	 * @return repository or null if non-existent
 	 * @throws 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 IOException
 	 */
 	public ObjectId getHead() throws IOException {
 		Repository subRepo = getRepository();
 		if (subRepo == null)
 			return null;
 		try {
 			return subRepo.resolve(Constants.HEAD);
 		} finally {
 			subRepo.close();
 		}
 	}

 	/**
 	 * Get ref that HEAD points to in the current submodule's repository
 	 *
 	 * @return ref name, null on failures
 	 * @throws IOException
 	 */
 	public String getHeadRef() throws IOException {
 		Repository subRepo = getRepository();
 		if (subRepo == null)
 			return null;
 		try {
 			Ref head = subRepo.exactRef(Constants.HEAD);
 			return head != null ? head.getLeaf().getName() : null;
 		} finally {
 			subRepo.close();
 		}
 	}

 	/**
 	 * Get the resolved remote URL for the current submodule.
 	 * <p>
 	 * This method resolves the value of {@link #getModulesUrl()} to an absolute
 	 * URL
 	 *
 	 * @return resolved remote URL
 	 * @throws IOException
 	 * @throws ConfigInvalidException
 	 */
 	public String getRemoteUrl() throws IOException, ConfigInvalidException {
 		String url = getModulesUrl();
 		return url != null ? getSubmoduleRemoteUrl(repository, url) : null;
 	}

 	/**
 	 * Release any resources used by this walker's reader.
 	 *
 	 * @since 4.0
 	 */
 	@Override
 	public void close() {
 		walk.close();
 	}
 }
	/*
	* Copyright (C) 2011, GitHub Inc.
	* and other copyright owners as documented in the project's IP log.
	*
	* This program and the accompanying materials are made available
	* under the terms of the Eclipse Distribution License v1.0 which
	* accompanies this distribution, is reproduced below, and is
	* available at http://www.eclipse.org/org/documents/edl-v10.php
	*
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or
	* without modification, are permitted provided that the following
	* conditions are met:
	*
	* - Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* - Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	*
	* - Neither the name of the Eclipse Foundation, Inc. nor the
	* names of its contributors may be used to endorse or promote
	* products derived from this software without specific prior
	* written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
	* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/
	package org.eclipse.jgit.submodule;

	import java.io.File;
	import java.io.IOException;
	import java.text.MessageFormat;
	import java.util.Locale;

	import org.eclipse.jgit.dircache.DirCache;
	import org.eclipse.jgit.dircache.DirCacheIterator;
	import org.eclipse.jgit.errors.ConfigInvalidException;
	import org.eclipse.jgit.errors.CorruptObjectException;
	import org.eclipse.jgit.errors.IncorrectObjectTypeException;
	import org.eclipse.jgit.errors.MissingObjectException;
	import org.eclipse.jgit.errors.RepositoryNotFoundException;
	import org.eclipse.jgit.internal.JGitText;
	import org.eclipse.jgit.lib.AnyObjectId;
	import org.eclipse.jgit.lib.BlobBasedConfig;
	import org.eclipse.jgit.lib.Config;
	import org.eclipse.jgit.lib.ConfigConstants;
	import org.eclipse.jgit.lib.Constants;
	import org.eclipse.jgit.lib.FileMode;
	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.Ref;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.lib.RepositoryBuilder;
	import org.eclipse.jgit.lib.StoredConfig;
	import org.eclipse.jgit.storage.file.FileBasedConfig;
	import org.eclipse.jgit.treewalk.AbstractTreeIterator;
	import org.eclipse.jgit.treewalk.CanonicalTreeParser;
	import org.eclipse.jgit.treewalk.TreeWalk;
	import org.eclipse.jgit.treewalk.filter.PathFilter;
	import org.eclipse.jgit.treewalk.filter.TreeFilter;
	import org.eclipse.jgit.util.FS;

	/**
	* Walker that visits all submodule entries found in a tree
	*/
	public class SubmoduleWalk implements AutoCloseable {

	/**
	* The values for the config param submodule.<name>.ignore
	*
	* @since 3.6
	*/
	public enum IgnoreSubmoduleMode {
	/**
	* Ignore all modifications to submodules
	*/
	ALL,

	/**
	* Ignore changes to the working tree of a submodule
	*/
	DIRTY,

	/**
	* Ignore changes to untracked files in the working tree of a submodule
	*/
	UNTRACKED,

	/**
	* Ignore nothing. That's the default
	*/
	NONE;
	}

	/**
	* Create a generator to walk over the submodule entries currently in the
	* index
	*
	* The {@code .gitmodules} file is read from the index.
	*
	* @param repository
	* @return generator over submodule index entries
	* @throws IOException
	*/
	public static SubmoduleWalk forIndex(Repository repository)
	throws IOException {
	SubmoduleWalk generator = new SubmoduleWalk(repository);
	try {
	DirCache index = repository.readDirCache();
	generator.setTree(new DirCacheIterator(index));
	} catch (IOException e) {
	generator.close();
	throw e;
	}
	return generator;
	}

	/**
	* Create a generator and advance it to the submodule entry at the given
	* path
	*
	* @param repository
	* @param treeId
	* the root of a tree containing both a submodule at the given path
	* and .gitmodules at the root.
	* @param path
	* @return generator at given path, null if no submodule at given path
	* @throws IOException
	*/
	public static SubmoduleWalk forPath(Repository repository,
	AnyObjectId treeId, String path) throws IOException {
	SubmoduleWalk generator = new SubmoduleWalk(repository);
	try {
	generator.setTree(treeId);
	PathFilter filter = PathFilter.create(path);
	generator.setFilter(filter);
	generator.setRootTree(treeId);
	while (generator.next())
	if (filter.isDone(generator.walk))
	return generator;
	} catch (IOException e) {
	generator.close();
	throw e;
	}
	generator.close();
	return null;
	}

	/**
	* Create a generator and advance it to the submodule entry at the given
	* path
	*
	* @param repository
	* @param iterator
	* the root of a tree containing both a submodule at the given path
	* and .gitmodules at the root.
	* @param path
	* @return generator at given path, null if no submodule at given path
	* @throws IOException
	*/
	public static SubmoduleWalk forPath(Repository repository,
	AbstractTreeIterator iterator, String path) throws IOException {
	SubmoduleWalk generator = new SubmoduleWalk(repository);
	try {
	generator.setTree(iterator);
	PathFilter filter = PathFilter.create(path);
	generator.setFilter(filter);
	generator.setRootTree(iterator);
	while (generator.next())
	if (filter.isDone(generator.walk))
	return generator;
	} catch (IOException e) {
	generator.close();
	throw e;
	}
	generator.close();
	return null;
	}

	/**
	* Get submodule directory
	*
	* @param parent
	* @param path
	* @return directory
	*/
	public static File getSubmoduleDirectory(final Repository parent,
	final String path) {
	return new File(parent.getWorkTree(), path);
	}

	/**
	* Get submodule repository
	*
	* @param parent
	* @param path
	* @return repository or null if repository doesn't exist
	* @throws IOException
	*/
	public static Repository getSubmoduleRepository(final Repository parent,
	final String path) throws IOException {
	return getSubmoduleRepository(parent.getWorkTree(), path);
	}

	/**
	* Get submodule repository at path
	*
	* @param parent
	* @param path
	* @return repository or null if repository doesn't exist
	* @throws IOException
	*/
	public static Repository getSubmoduleRepository(final File parent,
	final String path) throws IOException {
	File subWorkTree = new File(parent, path);
	if (!subWorkTree.isDirectory())
	return null;
	File workTree = new File(parent, path);
	try {
	return new RepositoryBuilder() //
	.setMustExist(true) //
	.setFS(FS.DETECTED) //
	.setWorkTree(workTree) //
	.build();
	} catch (RepositoryNotFoundException e) {
	return null;
	}
	}

	/**
	* Resolve submodule repository URL.
	* <p>
	* This handles relative URLs that are typically specified in the
	* '.gitmodules' file by resolving them against the remote URL of the parent
	* repository.
	* <p>
	* 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 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;

	/**
	* Create submodule generator
	*
	* @param repository
	* @throws IOException
	*/
	public SubmoduleWalk(final Repository repository) throws IOException {
	this.repository = repository;
	repoConfig = repository.getConfig();
	walk = new TreeWalk(repository);
	walk.setRecursive(true);
	}

	/**
	* Set the config used by this walk.
	*
	* This method need only be called if constructing a walk manually instead of
	* with one of the static factory methods above.
	*
	* @param config
	* .gitmodules config object
	* @return this generator
	*/
	public SubmoduleWalk setModulesConfig(final Config config) {
	modulesConfig = config;
	return this;
	}

	/**
	* Set the tree used by this walk for finding {@code .gitmodules}.
	* <p>
	* The root tree is not read until the first submodule is encountered by the
	* walk.
	* <p>
	* 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(final AbstractTreeIterator tree) {
	rootTree = tree;
	modulesConfig = null;
	return this;
	}

	/**
	* Set the tree used by this walk for finding {@code .gitmodules}.
	* <p>
	* The root tree is not read until the first submodule is encountered by the
	* walk.
	* <p>
	* 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 IOException
	*/
	public SubmoduleWalk setRootTree(final AnyObjectId id) throws IOException {
	final CanonicalTreeParser p = new CanonicalTreeParser();
	p.reset(walk.getObjectReader(), id);
	rootTree = p;
	modulesConfig = null;
	return this;
	}

	/**
	* Load the config for this walk from {@code .gitmodules}.
	* <p>
	* Uses the root tree if {@link #setRootTree(AbstractTreeIterator)} was
	* previously called, otherwise uses the working tree.
	* <p>
	* If no submodule config is found, loads an empty config.
	*
	* @return this generator
	* @throws IOException if an error occurred, or if the repository is bare
	* @throws 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;
	} 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));
	return this;
	}
	}
	modulesConfig = new Config();
	} finally {
	if (idx > 0)
	rootTree.next(idx);
	}
	}
	}
	return this;
	}

	/**
	* Checks whether the working tree contains a .gitmodules file. That's a
	* hint that the repo contains submodules.
	*
	* @param repository
	* the repository to check
	* @return <code>true</code> if the working tree contains a .gitmodules file,
	* <code>false</code> otherwise. Always returns <code>false</code>
	* for bare repositories.
	* @throws IOException
	* @throws CorruptObjectException
	* @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();
	}

	/**
	* Set tree filter
	*
	* @param filter
	* @return this generator
	*/
	public SubmoduleWalk setFilter(TreeFilter filter) {
	walk.setFilter(filter);
	return this;
	}

	/**
	* Set the tree iterator used for finding submodule entries
	*
	* @param iterator
	* @return this generator
	* @throws CorruptObjectException
	*/
	public SubmoduleWalk setTree(final AbstractTreeIterator iterator)
	throws CorruptObjectException {
	walk.addTree(iterator);
	return this;
	}

	/**
	* Set the tree used for finding submodule entries
	*
	* @param treeId
	* @return this generator
	* @throws IOException
	* @throws IncorrectObjectTypeException
	* @throws MissingObjectException
	*/
	public SubmoduleWalk setTree(final 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;
	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 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;
	}

	/**
	* 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 ConfigInvalidException
	* @throws IOException
	*/
	public String getModulesPath() throws IOException, ConfigInvalidException {
	lazyLoadModulesConfig();
	return modulesConfig.getString(
	ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
	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 ConfigInvalidException
	* @throws IOException
	*/
	public String getConfigUrl() throws IOException, ConfigInvalidException {
	return repoConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
	path, 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 ConfigInvalidException
	* @throws IOException
	*/
	public String getModulesUrl() throws IOException, ConfigInvalidException {
	lazyLoadModulesConfig();
	return modulesConfig.getString(
	ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
	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 ConfigInvalidException
	* @throws IOException
	*/
	public String getConfigUpdate() throws IOException, ConfigInvalidException {
	return repoConfig.getString(ConfigConstants.CONFIG_SUBMODULE_SECTION,
	path, 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 ConfigInvalidException
	* @throws IOException
	*/
	public String getModulesUpdate() throws IOException, ConfigInvalidException {
	lazyLoadModulesConfig();
	return modulesConfig.getString(
	ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
	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 ConfigInvalidException
	* @throws IOException
	* @since 3.6
	*/
	public IgnoreSubmoduleMode getModulesIgnore() throws IOException,
	ConfigInvalidException {
	lazyLoadModulesConfig();
	String name = modulesConfig.getString(
	ConfigConstants.CONFIG_SUBMODULE_SECTION, path,
	ConfigConstants.CONFIG_KEY_IGNORE);
	if (name == null)
	return null;
	return IgnoreSubmoduleMode
	.valueOf(name.trim().toUpperCase(Locale.ROOT));
	}

	/**
	* Get repository for current submodule entry
	*
	* @return repository or null if non-existent
	* @throws 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 IOException
	*/
	public ObjectId getHead() throws IOException {
	Repository subRepo = getRepository();
	if (subRepo == null)
	return null;
	try {
	return subRepo.resolve(Constants.HEAD);
	} finally {
	subRepo.close();
	}
	}

	/**
	* Get ref that HEAD points to in the current submodule's repository
	*
	* @return ref name, null on failures
	* @throws IOException
	*/
	public String getHeadRef() throws IOException {
	Repository subRepo = getRepository();
	if (subRepo == null)
	return null;
	try {
	Ref head = subRepo.exactRef(Constants.HEAD);
	return head != null ? head.getLeaf().getName() : null;
	} finally {
	subRepo.close();
	}
	}

	/**
	* Get the resolved remote URL for the current submodule.
	* <p>
	* This method resolves the value of {@link #getModulesUrl()} to an absolute
	* URL
	*
	* @return resolved remote URL
	* @throws IOException
	* @throws ConfigInvalidException
	*/
	public String getRemoteUrl() throws IOException, ConfigInvalidException {
	String url = getModulesUrl();
	return url != null ? getSubmoduleRemoteUrl(repository, url) : null;
	}

	/**
	* Release any resources used by this walker's reader.
	*
	* @since 4.0
	*/
	@Override
	public void close() {
	walk.close();
	}
	}