Volume Number: 20 (2004)
Issue Number: 7
Column Tag: Programming

AppleScript Essentials

by Benjamin S. Waldie

Becoming More Efficient through Folder Watching

For the past several months, we have explored various aspects of AppleScripting in Mac OS X. We have discussed some basic Finder scripting, adding repeat loops and if/then statements to our scripts, and more. This month, we will explore a topic of frequent interest to those who want to automate various aspects of their workflow - folder watching.

Folder watching is a common automation technique that can be used to make virtually any workflow more efficient. By configuring AppleScripts to monitor folders for new items to arrive, users are able to set up watched folders to automatically process incoming items.

Folder watching can be extremely useful in a variety of situations. For example, let's say that a user in your office copies files into a drop box on your computer at various times throughout the day. Whenever these files arrive, they need to be processed. Since you have other work to do too, you may not be able to monitor the drop box for new files on a regular basis. To assist with the process, you could create an AppleScript that monitors this drop box for you, and then notifies you whenever a new item is detected. Once notified, you could manually process the detected files. Or, you could write additional AppleScript code to process the files for you, completely removing all aspects of manual processing.

In some cases, you need to configure a large number of watched folders for multiple workflows. A common technique for dealing with this type of situation is to set up an AppleScript server. In other words, any dedicated Mac whose primary purpose is to watch these folders for new items, and then process the detected items. By integrating a dedicated folder watching machine into a workflow, users are able to hand off their files for processing, freeing them to work on other less time consuming and repetitive tasks.

In this article, we will discuss some basic ways to create a folder watching script. Then, you can expand these techniques in order to create more complex automated systems.

One method for writing a script that will watch a folder is to create an AppleScript that has been saved as a stay open application and makes use of AppleScript's idle handler. A stay open application is a script that, when launched, will remain open until manually quit by the user, or told to quit by the script itself, or by another script.

on idle
   -- Add code here to watch the folder
end idle

Handlers are an important, yet fairly complex topic. I will explain handlers in detail in a future article. In the meantime, this tech-note provides a very brief overview of a handler.

A handler is a group of AppleScript statements that may be executed with a single command. There are two types of handlers in AppleScript - subroutine handlers and command handlers. Subroutine handlers are groups of statements, which are defined by the developer, and called throughout a script, or from another script. A command handler is a group of statements that is triggered by an event, such as when a script is run, opened, quit, or idle. The idle handler is considered to be a command handler.

An idle handler will always begin with an on idle line and end with an end idle line. Any AppleScript code in-between these two lines will trigger whenever the script becomes idle. In a stay open script, by default, the idle handler will trigger every 30 seconds. However, you may optionally customize this delay period by adding a line to the end of the idle handler that returns a number of seconds to delay before becoming idle again. In the code below, the script would wait 1 second between executions of the idle handler.

on idle
   -- Add code here to watch the folder
   return 1 -- The number of seconds the script should delay before being idle again
end idle

Once you have a shell for your idle handler, it is time to begin adding some folder watching code. The following example represents a very basic folder watching script. In this example, the script will monitor a user specified folder for items. Whenever items are detected in the folder, they will be moved immediately to the desktop, and the user will be notified that items were detected and moved. The idle handler in this example will trigger once every second. Of course, this example could be expanded to have much greater functionality. For example, you could write code to process only new images that are placed in the folder. The script could be written to open those images in Photoshop, perform various image manipulations, and then save the images into an output folder.

global theWatchedFolder
set theWatchedFolder to choose folder
on idle
   tell application "Finder"
      set theDetectedItems to every item of theWatchedFolder
      repeat with aDetectedItem in theDetectedItems
         move aDetectedItem to the desktop
      end repeat
   end tell
   if theDetectedItems <> {} then
      activate
      display dialog "New items were detected and moved to your desktop."
   end if
   return 1
end idle

In the example above, the first line of code indicates that the variable theWatchedFolder will be a global variable. In other words, once assigned, this variable will be available to all areas of the script, at all times. The second line of code prompts the user to choose a folder, and assigns a reference to the chosen folder to the global variable theWatchedFolder. Because these first two lines of code do not fall within the idle handler, they will only be executed when the script is initially launched.

The code within the idle handler executes after the initial code has finished running. Once executed, it determines whether any items exist in the chosen folder. If items are detected in the folder, the script moves them to the desktop, and then notifies the user that items were detected and moved.

By moving items out of the watched folder, the script ensures that the same items are not detected and reprocessed during the next idle period. If necessary, the script could instead be expanded to keep track of the items in the folder, and only process when new items are added. However, this would require quite a bit more development. Therefore, it is common practice to move files from a watched folder into an output folder once processing is complete.

As previously mentioned, idle handlers are used in scripts that have been saved as stay open applications. Therefore, in order to test the code above, you will need to save the script as a stay open application. To save a script as a stay open application, save the script as an application and select the Stay Open checkbox in Script Editor's save dialog, as shown in Figure 1.

You are now ready to test your script. Launch it from the Finder and select a folder. Next, try moving or copying items into the selected folder, and they should be moved to the desktop.

Another method of creating a folder watching script is to make use of Mac OS X's built-in Folder Actions support. Folder Actions offer a more robust way to configure watched folders, with less coding needed.

A Folder Action is a specially written AppleScript, which may be attached to a folder. Folder Actions may be configured to trigger when specific types of action are taken on the folder they are attached to. Folder Actions may be written to trigger whenever:

• A folder is opened

• A folder's opened window is moved

• A folder's opened window is closed

• Items are added or removed from a folder

Information about Folder Actions, including sample code for configuring each type of Folder Action can be found on Apple Computer's web site at <http://www.apple.com/applescript/folderactions>.

To create a Folder Action, much like the idle handler, you add a specific handler into your script, indicating the type of action that will trigger the script. Different types of Folder Action handlers exist, and the one that you will need to use will depend on the type of action that you want to trigger your AppleScript code. A list of available Folder Action handlers can be found in the Folder Actions suite in the Standard Additions scripting addition that is installed with Mac OS X.

As you can see in Figure 2, there are several different types of Folder Action handlers that you may include in your script. Since this article specifically talks about folder watching, we will only discuss the adding folder items to Folder Action handler, which is used to process items added to a folder. However, I encourage you to try out the other types of Folder Action handlers as well.

To create a Folder Action that will process items that are moved or copied into an attached folder, add the adding folder items to Folder Action handler into your script.

on adding folder items to theWatchedFolder after receiving theDetectedItems

-- Add processing code here

end adding folder items to

In the example above, the first line of the handler contains two labeled parameters, theWatchedFolder and theDetectedItems. These parameters will pass dynamically assigned values to the script whenever the script is triggered. The parameter theWatchedFolder will contain an AppleScript alias reference to the folder that the script is attached to. The parameter theDetectedItems will contain a list of AppleScript alias references to the items that were added to the attached folder.

The on adding folder items to handler will only trigger when new items are added to the attached folder, providing to the script a list of only the newly added items. Therefore, unlike the script we created using the idle handler, we could choose to process the newly detected items, without moving them out of the watched folder.

Since, when the script is triggered, it will already have a list of newly added items, there is no need to write code to determine which items were detected. Instead, we only need to add code to process the detected items. The following example code, just like our idle handler, will move newly added items to the desktop, and then notify the user.

on adding folder items to theWatchedFolder after receiving theDetectedItems
   tell application "Finder"
      move theDetectedItems to the desktop
   end tell
   activate
   display dialog "New items were detected and moved to your desktop."
end adding folder items to

Once you have written your Folder Action script, you need to save it as a compiled script.

Place the saved Folder Action script into the Library > Scripts > Folder Action Scripts folder on your computer. Next, you need to actually attach the script to the folder you want to watch.

To attach a Folder Action script to a folder, launch the Folder Actions Setup application, which is located in the Applications > AppleScript folder in Mac OS X 10.3 and higher. Once launched, verify that the Enable Folder Actions checkbox is selected. You must enable Folder Actions in order for them to function.

Click the + button under the Folders with Actions field, and you will be prompted to select a folder. Make your selection, and click the Open button in the folder selection dialog window. You will then be prompted to select a Folder Action script to attach to the specified folder. Select the desired Folder Action script, and click the Attach button.

As the Folder Actions Setup application interface will indicate, your Folder Action script is now attached to the folder that you specified.

Now that configuration is complete, quit the Folder Actions Setup application, and test your Folder Action script by copying or moving items into the attached folder. If everything has been properly configured, then your Folder Action script should process the items placed in the attached folder.

Please note that it is also possible to configure Folder Actions through the contextual menu in the Finder. To display the contextual menu, control click on the desired folder in the Finder.

While the idle handler method of folder watching can be useful at times, Folder Actions offer a very useful way to configure watched folders without a lot of extra coding. I strongly urge you to begin exploring Folder Actions in more detail. As you begin using them, you will wonder how you ever got along without them.

Until next time, keep scripting!