How to pass a shell function to `git rebase --exec`

In bash, to pass a variable or function to a child process, you need to export it.

#!/bin/bash

f() { echo hello; }

# calling shell function `f` in child process
bash -c "f" # bash: f: command not found

# export the function
export -f f
bash -c "f" # "hello"

However, I can't seem to achieve the same result with git rebase --exec

#!/bin/bash

f() { echo hello; }

# export the function
export -f f
git rebase --exec "f" # does not work
git rebase --exec "bash -c 'f'" # does not work

I know I could declare the function inline: git rebase --exec 'f() { echo hello; }; f' or put the function in another script and call it: git rebase --exec './f.sh'

Is there a way to make it work? What am I missing?

Bash's export -f is a nice hack rather than something "standard". See the following commands and outputs (on Linux):

$ foo() { echo hello; }
$ export -f foo
$ bash -c foo
hello
$ bash -c 'tr "
$ foo() { echo hello; }
$ export -f foo
$ bash -c foo
hello
$ bash -c 'tr "\0" "\n" < /proc/$$/environ | grep -A 1 foo'
BASH_FUNC_foo%%=() {  echo hello
}
" "\n" < /proc/$$/environ | grep -A 1 foo'
BASH_FUNC_foo%%=() {  echo hello
}

As we can see, bash puts the exported foo()'s definition in an env var named BASH_FUNC_foo%%.

If current bash's subprocess is another bash, the sub-bash would happily recognize this weird env var and restore it as a function and all works expected.

But if the subprocess is not bash, then the behavior is undefined. The subprocess may choose to pass the weird env var over to its subprocess, but it can also choose to unset this weird env var ^{(because it looks weird/invalid or may be malicious!)} so its subprocess ^{(say, another bash)} would not see it.

Note that the env var naming format for exported functions was ever changed to deal with the shellshock issue.

Try serializing the function to text:

f() { echo hello; }
git rebase --exec "$(printf "%q " bash -c "$(declare -f f); f")"

As previously discussed, exported functions are stored in environment variables in a namespace that POSIX does not speak to; shells are neither required to pass through such names to children, nor prohibited from doing so.

One easy workaround is to put evalable content into an environment variable with an unambiguously legal name.

#!/usr/bin/env bash
f() { echo hello; }

cmd_q="$(declare -f f); f"
cmd_q=$cmd_q git rebase --exec $'bash -c \'eval "$cmd_q"\'' "$@"

Here is my solution. Thanks to @CharlesDuffy for his help.

#!/usr/bin/env bash

f() {
  for i in "$@"; do
    echo "$i"
  done
}

printf -v cmd_q '%q ' "$(declare -f f); f" # serialise function f
export cmd_q
printf -v args '%q ' "$@" # serialise arguments f
export args

# remove -r --root and adapt to your needs here
git rebase -r --root --exec $'bash -c "eval $cmd_q \'$args\'"'