Can I copy files – but with certain restrictions?

Thanks for the bash script. I'll be able to give it a thorough testing if I can get it working. I've never heard of bash, and I can only do two things with Terminal – get a calendar and remove stubborn files via "sudo rm -R ". Anything else is generally beyond me. Really. But I'll give it a go.

When I clicked on "Download" on that web page you gave, I ended up with a text file called xGGGhzZ9.txt. I pasted the contents in Terminal and it went silly. Gave about 20 "pings" and then stopped.

Two questions:

1. How do run this script?

2. What is the easiest way to find the path of a folder? I think I can do so by dragging a folder into the "Compare" utility window of Toast which comes up with something like "/Volumes/C-Data/AA Archives" for an existing folder I have. Is that what is needed?

I have done a bit of research into running scripts, and one explanation I found (I still don't follow any of it) is listed below. If this is what it takes to run a bash script, I'll have to give it a miss!

+To run a non-executable bash script, use: bash myscript+

+To start an executable (which is any file with executable permission); you just specify it by its path:+

/foo/bar
/bin/bar
./bar

+To make a script executable, give it the necessary permission:+

+chmod +x bar+
./bar

+When a file is executable, the kernel is responsible for figuring out how to execute it. For non-binaries, this is done by looking at the first line of the file. It should contain a hashbang:+

+#! /usr/bin/env bash+

+The hashbang tells the kernel what program to run (in this case the command /usr/bin/env is ran with the argument bash). Then, the script is passed to the program (as second argument) along with all the arguments you gave the script as subsequent arguments.+

+That means every script that is executable should have a hashbang. If it doesn't, you're not telling the kernel what it is, and therefore the kernel doesn't know what program to use to interprete it. It could be bash, perl, python, sh, or something else. (In reality, the kernel will often use the user's default shell to interprete the file, which is very dangerous because it might not be the right interpreter at all or it might be able to parse some of it but with subtle behavioural differences such as is the case between sh and bash).+

Thanks for the suggestions, Robert. I got as far as this line:

bash comp.bash ~/Desktop/see

and came to a halt. Now when I try and go through the steps again, the listing of the script is already in Terminal and I can't get rid of it to allow me to try again.

Maybe JJJ can tell us if the second script works and can give some instructions on how to run it.

Thanks for the help, but on my system it is no-go. This episode has turned from a timesaver to a challenge, but at least I'll know a little about bash when I've finished.

I have uploaded all files connected with what I did to: http://www.mediafire.com/?nn2i2iwjijz

Anyone interested in helping out may have to download a zip folder available at the link.

This is what I did:

1. I went to http://pastebin.com/xGGGhzZ9, clicked in the second listing, selected all, and copied.

2. I opened a new iText Express document, pasted text, converted to plain text, and saved as BashTest on Desktop.

3. Duplicated BashTest to keep the original intact. Renamed the original +BashTest (original)+. Renamed +BashTest copy+ (the duplicate) to BashTest – the one I am going to test.

4. I made a test folder called Duplicates with a text file inside called "A"; and I created two more folders alongside "A": one called +A (changed)+ that has an altered version of "A" inside; and one called +A (identical)+ that has "A" inside.

5. I duplicated the entire folder and got a new folder called +Duplicates copy+, the one I was about to do the tests on.

6. The Terminal window was already full of stuff, so I selected "New Shell".

7. In Terminal I typed: "chmod +x " (including the space) and then dragged BashTest from the Desktop into the Terminal window (to make sure I had the correct file path), and then pressed Return.

8. I again dragged BashTest from the Desktop to the Terminal window, typed one space, then dragged the folder +Duplicates copy+ to the Terminal window, then pressed Return.

9. I checked the Trash. One copy of "A" appeared in the trash.

10. I checked +Duplicates copy+. Both identical copies of "A" were gone which is not what should happen.

QUES: Where did I go wrong?

*Terminal Listing*
Last login: Thu May 20 10:52:44 on ttyp1
Welcome to Darwin!
jenny-pearces-imac-g5:~ Jenny$ chmod +x /Users/Jenny/Desktop/BashTest.txt

jenny-pearces-imac-g5:~ Jenny$ /Users/Jenny/Desktop/BashTest.txt /Users/Jenny/Desktop/Duplicates\ copy/

/Users/Jenny/Desktop/BashTest.txt: line 1: md5sum: command not found
cat: /Users/Jenny/Desktop/Duplicates copy//A (changed)/A.rtf: Bad file descriptor
/Users/Jenny/Desktop/BashTest.txt: line 1: md5sum: command not found
/Users/Jenny/Desktop/BashTest.txt: line 1: md5sum: command not found
jenny-pearces-imac-g5:~ Jenny$

Back again. This is the Terminal output when run on my +Duplicates Copy+ folder:

Last login: Thu May 20 13:28:30 on ttyp1
Welcome to Darwin!
jenny-pearces-imac-g5:~ Jenny$ chmod +x /Users/Jenny/Desktop/Bash\ Test\ Documents/BashTest.txt
jenny-pearces-imac-g5:~ Jenny$ /Users/Jenny/Desktop/Bash\ Test\ Documents/BashTest.txt /Users/Jenny/Desktop/Duplicates\ copy/
/Users/Jenny/Desktop/Bash Test Documents/BashTest.txt: line 1: ${filePaths${count}}: bad substitution
/Users/Jenny/Desktop/Bash Test Documents/BashTest.txt: line 17: fileSum0=d41d8cd98f00b204e9800998ecf8427e: command not found
/Users/Jenny/Desktop/Bash Test Documents/BashTest.txt: line 1: ${filePaths${count}}: bad substitution
/Users/Jenny/Desktop/Bash Test Documents/BashTest.txt: line 17: fileSum1=d41d8cd98f00b204e9800998ecf8427e: command not found
/Users/Jenny/Desktop/Bash Test Documents/BashTest.txt: line 1: ${filePaths${count}}: bad substitution
/Users/Jenny/Desktop/Bash Test Documents/BashTest.txt: line 17: fileSum2=d41d8cd98f00b204e9800998ecf8427e: command not found
jenny-pearces-imac-g5:~ Jenny$

I'm not sure it's worth spending much more time on this. However, if you're prepared to keep posting, JJJ, I'll keep testing.

*SCRIPT AFTER THE EDIT*
#!/bin/bash

declare -i count=0
declare -a fileSum filePaths

# Main folder can be declared on the command line or if not then use /testpix
MainFolder="${1:-/testpix}"

# Set the internal field separator to newline to preserve spaces in file paths
IFS=$'\n'

# Use 'find' to create a list of files within the folders.
filePaths=( $( find "${MainFolder}" -type f \! -name ".*" ) )

# Get an MD5 checksum for each file's combined content of both data and resource forks
for file in ${filePaths[*]} ; do
fileSum${count}=$( cat "${filePaths${count}}" "${filePaths${count}}/rsrc" | md5 | cut -d'=' -f 2)
let count+=1
done

# For each file, check for a duplicate checksum and if found, move the matching file to the user's trash folder
# Rename files with duplicate names by appending #XX
for ((i=0;i<${count};i++)) ; do
[ -z "${filePaths[${i}]}" ] && continue
dupecount=1
for ((j=0;j<${count};j++)) ; do
[ -z "${filePaths[${j}]}" ] && continue
if [ "${fileSum[${i}]}" = "${fileSum[${j}]}" -a ${i} -ne ${j} ] ; then
mv "${filePaths[${j}]}" ~/.Trash && filePaths[${j}]='' && fileSum[${j}]=''
elif [ $(basename "${filePaths[${i}]}") = $(basename "${filePaths[${j}]}") -a ${i} -ne ${j} ] ; then
let dupecount+=1
dirname=$(dirname "${filePaths[${j}]}")
fullfilename=$(basename "${filePaths[${i}]}")
extension="${fullfilename##*.}"
filename="${fullfilename%.*}"
until [ ! -e "${dirname}/${filename} #${dupecount}.${extension}" ] ; do
let dupecount+=1
done
mv "${filePaths[${j}]}" "${dirname}/${filename} #${dupecount}.${extension}"
filePaths[${j}]="${dirname}/${filename} #${dupecount}.${extension}"
fi
done
done

exit 0

The zipped version appears to work on the +Duplicates Copy+ folder. I'll generate a more complex test folder and let you know how it goes before I let it loose in the real world.

The script worked with a more complicated test folder. I generated a text document "A", put that in a folder and subfolders, then made a small change to the text and dumped that in subfolders. Then I duplicated that setup but changed the file names to "B". The final folder contained:

• 3 identical "A"s
• 2 changed "A"s
• 3 identical "B"s (identical to "A")
• 2 changed "B"s (identical to changed "A")

*RESULT FOR A*
The result of running the script was a folder with one "A" (one of the changed "A"s), and an "A#2" (one of the identical "A"s). Sent to the Trash was one of the changed "A"s and two of the identical "A"s.

QUES: What happened to A#1? Does the script start at #2?

*RESULT FOR B*
No "B"s were left in the folder, but there was one "B" in the Trash. The script appears to treat files with different names, but which are otherwise identical, as the same file and therefore removes the additional copies –– in this case, all the "B"s.

QUES: Why aren't there more "B"s in the Trash? What happened to them?

I wasn't expecting that identical files that had different names would be treated as the same file. That's a nice little touch actually, which removes even more unnecessary files than I was anticipating. But this feature might have a downside – some of my images changed names during the project, so if I went looking for one of them in the archive, I might not find it because of the name change.

It's now time for a test on a real folder, within which I'll bury a few subfolders containing identical files to see what happens.