Bash function for 'Deep Replace' in file contents, file name, directory name, allowing for whitespace

Question

On my Ubuntu system, I commonly need to do a 'Deep Replace' in file contents, the file name and directory name. For example when copying source code as a template for another application.

I've put together a function in ~/.bashrc which works, but fails if the find or replace string has white space in it. I believe this is due to the sed command not accepting white space in the script as is, and the cd to the path variable also fails where the path includes white space.

The arguments are ($1) directory, ($2) find text, ($3) replace text.

Is it possible to improve this script so the arguments can all include white space?

deepreplace() {
if [ -z "$1" ] || [ -z "$2" ] || [ -z "$3" ]
then
    echo "A parameter is missing"
else

    cd $1

    vfind=$2
    vreplace=$3 

    # Replace the string in file

    find . -type f -exec sed -i "s/$vfind/$vreplace/g" {} +

    # Replace the string in file names, then directories


    find . -type d -name "*$vfind*" | while read f; do mv $f $(echo $f | sed "s/$vfind/$vreplace/g"); done
    find . -type f -name "*$vfind*" | while read f; do mv $f $(echo $f | sed "s/$vfind/$vreplace/g"); done
fi

}

Answer 1

As in comments, I've determined that a pure bash solution was not optimal for my use case.

I've settled for a command that depends on Node.js / npm (since Node is fairly ubiquitous on environments I work on, including non Unix (Windows / Mac).

It depends on two npm packages renamer and replace.

The advantage of using these libraries is that they support regex and other more advanced rename / replace scenarios.

With Node.js / npm installed:

# Globally install the required packages (this prevents npx from trying to install in current directory if they do not already exist)
$ npm install -g renamer
$ npm install -g replace
Set variables (dir, find, replace) for directory, find and replace strings, then run change directory, rename and replace, before reverting to original directory.
npx is not strictly required, but have included to prevent collisions with command names on the PATH.
$ dir="./example_dir" && 
   find="example_find" && 
     replace="example_replace" && 
       cd "$dir" && 
        npx renamer --find "$find" --replace "$replace" "**" && 
            npx replace "$find" "$replace" . -r 
                && cd -

The equivalent .bashrc function looks like this

renamereplace() {
# Install global packages if not installed

npm list -g renamer || npm install -g renamer
npm list -g replace || npm install -g replace

# Alias positional arguments

dir="$1"
find="$2"
replace="$3" 

# Change to replace directory

cd "$dir"

# Rename in directory and file names

npx renamer --find "$find" --replace "$replace" "**" 

# Replace in file contents

npx replace "$find" "$replace" . -r 

# Revert current directory

cd -

}

And can be called with:

$ renamereplace "./example_dir" "example_find" "example_replace"

Disclaimer: To avoid data loss, ensure you a) understand this script, b) have checked the directory this command will run in and c) have backed up any important data before running the above.

Answer 2

Your function were almost conform to your requirements, just missing a lot of quotes around variables and substitutions, that's why it did not resist to space in filenames.

• variables : "$1" "$2" "$f" etc.
• substitutions : "$( ... )"

Here is a first low touch review:

deepreplace() {
  if [ -z "$1" ] || [ -z "$2" ] || [ -z "$3" ]
  then
      echo "A parameter is missing"
  else
    cd "$1" # quote missing
    vfind="$2" # quote missing
    vreplace="$3" # quote missing
    # Replace the string in file contents
    find . -type f -exec sed -i "s/$vfind/$vreplace/g" {} +
    # Replace the string in directory names
    find . -type d -name "*$vfind*" |
    while read d ; do
      mv "$d" "$(echo "$d" | sed "s/$vfind/$vreplace/g")"
    done
    # Replace the string in file names
    find . -type f -name "*$vfind*" |
    while read f; do
      mv "$f" "$(echo "$f" | sed "s/$vfind/$vreplace/g")"
    done
  fi
}

next improvements:

• instead of $(echo $v | sed s/x/y/g) use the built-in ${v//x/y}
  example: mv "$f" "${f//$vfind/$vreplace}"
• you have a problem when the path is to be replaced at more than directory level; that's why you first target directories then files (and not files then directories)
• it's useless to perform find three times

Here is a pure bash new approach:

    find . | while read p ; do
      ddir="$(dirname "${p//$vfind/$vreplace}")"
      obas="$(basename "$p")"
      nbas="${obas//$vfind/$vreplace}"
      # if object rename
      [[ $obas != $nbas ]] && mv "$ddir/$obas" "$ddir/$nbas"
      # if object is file, edit
      [ -f "$ddir/$nbas" ] && sed -i "s/$vfind/$vreplace/g" "$ddir/$nbas"
    done

• find natural output order make that directories are always renamed before their children, so that it is safe to rename only the basename element
• all names may safely contain spaces
• only one find does the job at lower cost
• you save dependencies to js