Git command line - know if in submodule?

Question

Is there any way in git to know if you're in a submodule? You can do thinks like git submodule foreach in the parent directory but I can't seem to come up with a generic way to show that you're in a submodule if you're in one, or in any of the child directories inside the submodule.

I guess you could find the repo root with git rev-parse --show-toplevel, and then cd-ing up a level, and finding the root of that repo again and then comparing the list of submodules to the current directory, but that seems so sticky...

Answer 1

(Update April 2017 for Git 2.13, Q2 2017)

There is now an official command to determine if a repo is a submodule of a parent repo:

cd /path/to/potential/submodule/repo
git rev-parse --show-superproject-working-tree

See commit bf0231c (08 Mar 2017) by Stefan Beller (stefanbeller).
^{(Merged by Junio C Hamano -- gitster -- in commit 3edcc04, 17 Mar 2017)}

rev-parse: add --show-superproject-working-tree

In some situations it is useful to know if the given repository is a submodule of another repository.

Add the flag --show-superproject-working-tree to git-rev-parse to make it easy to find out if there is a superproject.
When no superproject exists, the output will be empty.

Jethro Yu suggests in the comments:

get super project path regardless inside/outside of submodule:

git rev-parse --show-superproject-working-tree --show-toplevel | head -1

---

(Update 2014) As noted by Quentin Pradet, more recent Git submodule repos show a simple .git file instead of a .git folder.
That .git file reference the path of the actual submodule git repo, stored in the parent repo .git/modules subfolder.

jeffrson adds in the comments (2023):

Existing '.git' itself is not sufficient, because that's the same for worktrees.
However, the file should contain the string "modules" or "worktrees", respectively, as part of the target.

---

(Original answer: Sept. 2011)

The very nature of a submodule is for the git repo acting as submodule has no idea it is used as a submodule by a parent repo.

One dirty trick would be to:

• change a file
• go back one level above the current repo
• try a "git status --ignore-submodules=none"
• restore the changed file.

If you see the file in the result of the git status, your repo should be a submodule.
If it is only a nested repo, the git status should ignore your nested repo entirely.

Answer 2

Here is a shell function that you can use to detect this:

function is_submodule() 
{       
     (cd "$(git rev-parse --show-toplevel)/.." && 
      git rev-parse --is-inside-work-tree) | grep -q true
}

Edit In response to your proposed script:

Looking good.

• There is a bug in

  for line in $submodules; do cd "$parent_git/$line"; \
      if [[ `pwd` = $_git_dir ]]; then return 0; fi; \
  done
  

because it won't cd back (so it would only work if the first submodule is a match). My version checks without changing directories; That could be done done by cd-ing in a subshell, but returning the exitcode is getting complicated that way

• I don't know where you get $_git_dir from - I used basename(1) to get that information (see below).

• There was also a problem with submodules containing a space in the name. In my version, there is still a problem with newlines in submodule names left, but I don't care enough to fix that. (Note the 'idiomatic' way to avoid having the while read in a subshell without needing new bash-isms like readarray)

• finally declaring all the vars local fixes potential problems when using this inside other scripts (e.g. when the outer script uses the $path variable...)

• I renamed _git_dir to top_level (which is less confusing, because GIT_DIR means something else)

Remaining issues:

• I don't know whether git supports it (I don't think so) but this script could fail if the submodule directory is a symlink (because "$top_level/.." might resolve outside the containing repository)

• submodule names with newlines will not be recognized properly

• I also suggest you trap errors (either with 'set -e', 'trap "return 1" ERR' or similar) -- not in my script/exercise for reader

#!/bin/bash

function is_submodule() {
    local top_level parent_git module_name path
    # Find the root of this git repo, then check if its parent dir is also a repo
    top_level="$(git rev-parse --show-toplevel)"
    module_name="$(basename "$top_level")"
    parent_git="$(cd "$top_level/.." && git rev-parse --show-toplevel 2> /dev/null)"
    if [[ -n $parent_git ]]; then
        # List all the submodule paths for the parent repo
        while read path
        do
            if [[ "$path" != "$module_name" ]]; then continue; fi
            if [[ -d "$top_level/../$path" ]];    then return 0; fi
        done < <(cd $parent_git && git submodule --quiet foreach 'echo $path' 2> /dev/null)
        #return 1
    fi
    return 1
}

Usage

if is_submodule; then
    echo "In a submodule!"
else
    echo "Not in a submodule"
fi

Answer 3

try git rev-parse --git-dir which will return ".git" if and only if called from the project root:

if `git rev-parse --git-dir` == ".git"
    // in root directory
else
    // in submodule directory

unless you set $GIT_DIR which will be the returned value in that case (see rev-parse):

--git-dir

Show $GIT_DIR if defined. Otherwise show the path to the .git directory. The path shown, when relative, is relative to the current working directory.

If $GIT_DIR is not defined and the current directory is not detected to lie in a Git repository or work tree print a message to stderr and exit with nonzero status.

Answer 4

I tried the script suggested above and it didn't work for me. Of course, I may be the only person in the world who has a submodule that's not a direct child of the parent module. The code above assumes that it is.

It would also be nice to then show the submodule path inside the parent - I plan to use this to show a bash shell prompt telling me if I'm in a submodule, and where.

Here's my update:

function is_submodule() {
    local git_dir parent_git module_name path strip
    # Find the root of this git repo, then check if its parent dir is also a repo
    git_dir="$(git rev-parse --show-toplevel)"
    parent_git="$(cd "$git_dir/.." && git rev-parse --show-toplevel 2> /dev/null)"

    if [[ -n $parent_git ]]; then
        strip=$((${#parent_git} + 1))
        module_name=${git_dir:$strip}
        # List all the submodule paths for the parent repo
        while read path
        do
            if [[ "$path" != "$module_name" ]]; then continue; fi
            if [[ -d "$parent_git/$path" ]]; then
                echo $module_name
                return 0;
            fi
        done < <(cd $parent_git && git submodule --quiet foreach 'echo $path' 2> /dev/null)
    fi
    return 1
}

# Usage
submodule=$(is_submodule)
if [[ $? -eq 0 ]]; then
    echo "In a submodule! $submodule"
else
    echo "Not in a submodule"
fi

Answer 5

The selected answer doesn't work for submodules that aren't at the top level. This does and is also simpler:

function is_git_submodule() {
    local module_name 

    module_path="$(git rev-parse --show-toplevel 2> /dev/null)"

    # List all the submodule paths for the parent repo and look for our module's path
    (cd "${module_path}/.." && git submodule --quiet foreach 'echo $toplevel/$path' 2> /dev/null) | \
        grep --quiet --line-regexp --fixed-strings "$module_path"
}