Keeping *nix Format

Question

My code works, but not in the way I want to exactly. Basically, what my code does is that it looks through the current directory, searches for folders, and within those folders it looks at the files. If one of the file extensions is the value of the $Example variable, then it should delete all other files with the same beginning file name, regardless of extension and rename the one with the $Example extension to the same name, just without the $Example extension. Here is the code:

#!/bin/sh
set -o errexit
Example=dummy
for d in *; do
    if test "$(ls -A "$d" 2>/dev/null)"; then
        if [ $(ls -1 ${d}/*.$Example 2>/dev/null | wc -l) -ge 1 ]; then
            cd $(pwd)/$d;
            for f in *.$Example; do
                fileName="${f%.$Example}";
                mv "$f" "${f%.$Example}";
                #tr "\r" "\n" < "${f%.$Example}" > "${f%.$Example}"
                listToDelete=$(find -name "$fileName.*");
                for g in $listToDelete; do
                    rm $g;
                done;
            done;
            cd ..;
        fi;
    fi;
done

The files being used have been created in VIM, so are supposed to have Linux formatting, rather than Windows formatting. For some reason or other, once the extension has been stripped, using this code, it gets formatted with \r, and the file fails to run. I added the comment where my temporary solution is located, but I was wondering if either there is some way to alter the mv function to keep the Linux formatting, or maybe there is another way to achieve what I want. Thanks

Answer 1

The files being used have been created in VIM, so are supposed to have Linux formatting, rather than Windows formatting.

That has no impact on the line separator being used.

But I can think of 3 different possible causes.

ViM substitution

The \r and \n may have been mixed up or the Windows line separator (\r\n) may have been striped out incorrectly. If you're just trying to convert the Windows line separator at some point, convert them to to Unix line separated files with dos2unix instead of sed or vim magic if possible and then edit them. If the files are adding or replacing line separators using ViM, remember that in ViM line separators are searched for using \n and replaced with \r since ViM just loads file data into a buffer. e.g. %s/\n/somestring/ and %s/somestring/\r/g.

Cygwin

If you're using Cygwin, I'm pretty sure it defaults to ViM using Windows line separators, but you can change it to Unix line separators. Don't remember how to off the top of my head though.

ViM default line separators

Not sure how this would have happened if you're on a GNU/Linux system, but the default line separator to be used in ViM can be specified to Unix using :e ++ff=unix

Answer 2

This answer does not address the issue with a possible stray \r in the script source code, but rather gives an alternative way of doing what I believe is what the user wants to achieve:

#!/bin/bash

ext='dummy'
tmpfile=$(mktemp)

find . -type f -name "*.$ext" \
    -execdir bash -x -c \
        'cp "$3" "$2" &&
         tee "${3%.$1}"* <"$2" >/dev/null' bash "$ext" "$tmpfile" {} \;

rm -f "$tmpfile"

This finds all files with the given extension and for each of them executes

cp "$3" "$2" && tee "${3%.$1}"* <"$2" >/dev/null

• $1 will be the extension without the dot.
• $2 will be the name of a temporary file.
• $3 will be the found file.

The command will first copy the found file to a temporary file, then it will feed this temporary file through tee which will duplicate its contents to all files with the same prefix (${3%.$1} will strip the extension from the found filename and ${3%.$1}* will expand to all files in the same directory that has the same prefix).

Most modern implementations of find supports -execdir which works like -exec with the difference that the given utility will be executed in the directory of the found name. Also, {} will be the pathless basename of the found thing.

Given the following files in a directory:

$ ls test/
f1.bar   f1.foo   f2.bar   f2.foo   f3.bar   f3.foo
f1.dummy f1.txt   f2.dummy f2.txt   f3.dummy f3.txt

This script does the following:

$ bash -x script.sh
+ ext=dummy
++ mktemp
+ tmpfile=/tmp/tmp.9v5JMAcA12
+ find . -type f -name '*.dummy' -execdir bash -x -c 'cp "$3" "$2" &&
         tee "${3%.$1}"* <"$2" >/dev/null' sh dummy /tmp/tmp.9v5JMAcA12 '{}' ';'
+ cp f1.dummy /tmp/tmp.9v5JMAcA12
+ tee f1.bar f1.dummy f1.foo f1.txt
+ cp f2.dummy /tmp/tmp.9v5JMAcA12
+ tee f2.bar f2.dummy f2.foo f2.txt
+ cp f3.dummy /tmp/tmp.9v5JMAcA12
+ tee f3.bar f3.dummy f3.foo f3.txt
+ rm -f /tmp/tmp.9v5JMAcA12

Remove -x from the invocation of bash (and from bash on the command line) to disable tracing.

---

I used bash rather than sh because my sh can't grok ${3%.$1} properly.