PROGRAMMING PARADIGMS

A Tour of AppleScript

There's also the tell statement, which is crucial since it specifies the destination for the command(s). It can do so with more precision than implied above, specifying rather minuscule elements of objects as command destinations. The forms in Example 2 do the same thing.

Who actually does the work in these cases is a question. Normally, it's the application that handles the actual command that the AppleScript extension passes it, although there's a situation in which a command may be directed to an application object and handled by a subroutine in a script. There are really only four kinds of AppleScript commands: application commands (handled by applications), AppleScript commands (handled by the AppleScript extension), scripting additions (handled by their own extensions), and user-defined commands (subroutines handled by handlers within a script).

Objects

Commands are sent to and operate on objects. Syntactically, the objects will typically appear as the parameters of commands. There are system objects, which AppleScript knows about (applications, zones, machines) and application objects, which individual applications know about (words and characters, for example). More precisely, all AppleScript-supporting applications in a category like word processing will know about the same basic collection of text-related classes of objects, such as lines, words, characters, and insertion points. Individual applications may know about other classes of objects that no other applications know about. A running application, or any script driving it, will operate on instances of these classes.

Commands typically tell objects to perform actions or return values. Objects can have properties (text objects can have, for example, size, style, font, alignment, and color properties) and elements (elements of a word-processing document would include words, characters, and so on).

There are also what are called "script objects." Like system objects and application objects, script objects can have properties and can respond to commands. These are objects defined within scripts; see Example 3. Elsewhere you could send a command to this object: tell duck to quack.

If applications can define their own commands and objects, how do you know what vocabulary an application supports? A language with an unknown vocabulary is not very useful. The answer is that every AppleScript-supporting application is expected to make its supported vocabulary explicit in a standard way, and the script editor knows how to display this dictionary for you in a convenient and readable manner.

Values

AppleScript supports the more obvious value classes: Boolean, class, integer, real, string, list, and date. It also supports record (defined as a collection of parameter-value pairs), data (uninterpreted binary data), constant (application-defined special values), and reference (a reference to an object).

The use of references to identify application objects is heavily used in AppleScript. You create a value of class reference using the ref operator (also known as a reference to). The value of the first of the references in Example 4(a) is a string; the value of the second is a structure within AppleScript that points to that string.

AppleScript works hard to make sense of references. There are many reference forms that it recognizes. Scripts can easily refer to the first or last or nth or nth-from-last or middle element of any organized object, an arbitrary element, every element, elements in a range, or elements satisfying some Boolean condition. Objects can also be referred to by name, ID, or relative position with respect to another object, where that is meaningful. Also, AppleScript uses tell statements and default object values to make sense of incomplete references, if possible. If you look at Example 2, in every example the object reference for the delete command was incomplete, and AppleScript completed it from default objects specified by one or more enclosing tell commands.

The property reference form is another form of reference. Its syntax is straightforward: name of window 1 references the name property of that window object. Application objects and system objects and script objects can have properties; application objects and script objects can define their own properties: footStyle of myDuck.

It's also possible to refer to properties of records (a record being a collection of properties and their values): phone of {name: "Bill", phone: "555-9861"}.

Variables, like properties, hold values. There are two commands for assigning values to variables: copy and set. These behave identically, copying the source value to the destination variable, except in the cases of lists, records, and script objects. When the source object is one of these types, the set command creates a variable that shares data with the original object, so that when the original changes, the assigned variable changes with it.

There are other differences between properties and variables as value holders. Variables are assumed local unless declared global; the opposite is true for properties, which are persistent. For example, in Example 4(b), the second line shows the syntax for defining a property. The property barks retains its last value when you close the script. It is only reset to 0 when the script is recompiled.

Subroutines

You can write your own handlers, called "subroutines." These can be recursive, as in Example 5(a). They can use positional parameters, as above, or labeled parameters. The labeled parameter form supports two dozen special labels and can be defined using either the word on or the word to. Example 5(b) provides a few examples of first lines of labeled parameter subroutine definitions.

One special kind of handler is the command handler, written in a script but attached to a particular application object. This means that you can assign behavior to objects created by applications. Applications must be written to support attachment in order for this to work.

Another special handler is the try handler, which is used for error handling. Bracketing a block of code by the try command lets you specify error handlers for error messages that may be returned in that block.

AppleScript and Apps

So what does it mean for an application to support AppleScript? There are, first of all, two directions of support: There's the ability to send AppleScript commands and the ability to respond to them. Then there are the three Apple-defined levels of support. An application can be scriptable, meaning that it responds to AppleScript commands. (There are levels of support within this, because there are several classes of commands: required, core, application-suite commands, and an application's own special commands.) An application can be recordable, meaning that users can create scripts by turning on a watch-me mode and performing normal application actions. That's a step beyond scriptable. And an application can be attachable, meaning that users can write scripts, perhaps in the script editor, and attach them to objects that the application knows about, so that the behavior of those objects is controlled by the user's script.

But the big question is, who will support AppleScript? We'll find out over the course of the next year. It'll be interesting to watch.

Example 1: Controlling string comparisons using AppleScript

ignoring case and punctuation
  if "It's" = "its" then beep 1
  considering punctuation
    if "It's" = "its" then beep 2
  end considering
end ignoring

Example 2: The tell statement

tell application "Text Editor"
  delete character 1 of word 4 of line 6 of document "Ridley 3/18"
end tell
tell word 4 of line 6 of document "Ridley 3/18" of application "Text Editor"
  delete character 1
end tell
tell application "Text Editor"
  tell document "Ridley 3/18"
    tell line 6
      tell word 4
        delete character 1
      end tell
    end tell
  end tell
end tell

Example 3: Script objects

script duck
  bill:     yellow
  footCount:    2
  footStyle:    webbed
  to quack
    open bill
    beep
    close bill
  end quack
end duck

Example 4: (a) AppleScript values; (b)

(a)
word 6 of line 4
ref word 6 of line 4
(b)
script dog
  barks: 0
  set barks to barks + 1
  display dialog barks
end dog

Example 5: (a) recursive handlers, or subroutines; (b) labeled parameter subroutine definitions.

(a)
on factorial (n)
  if n = 1 then
    return n
  else
    return factorial (n-1)
  end if
end factorial
(b)
on FahrenheitToCentigrade of temp
to searchFiles of filesToSearch for theString
to lowerCase of charsInString above minChar given sortOrder