As is often the case with application scripting, a large part of the challenge is wrapping your head around the app’s unique nomenclature – every program has its own cat-skinning inclination. I spent some time trying to “move” the selected items to the “scheduled” list, to no avail. However, thanks to the excellent AppleScript documentation provided by Cultured Code (available here), I eventually figured out that they had a special verb for me: schedule.

As usual, my preferred way of running all these scripts is with Red Sweater Software’s FastScripts, and attaching a dynamic, attractive keyboard shortcut to ‘em (historians may note that for this particular script I have chosen control-right arrow. My mnemonic: get away from me).

Download Procrastinate.rb.zip.

The source code is dozing amongst those fern fronds, just over there.

#!/usr/bin/env ruby -wKU

require "rubygems"
require 'appscript'
require "date"

things = Appscript.app('Things.app')
tomorrow = DateTime.now.next_day

things.selected_to_dos.get.each { |todo| things.schedule(todo, :for => tomorrow) }

This script (which is based on this one by Mike Hall) creates a new To Do in Things based on the currently selected headline, gives it a couple of tags to make it easy to find again, and embeds the URL in the notes section. So you can save up all your Internetistractions (and yes, that is a clumsy neologism/portmanteau of my own creation) and consume them when you’re not supposed to be working.

Download Add to Things.rb.zip

The source code is hastily finishing its breakfast and pulling on its gumboots, just south of here.

#!/usr/bin/env ruby
# coding: utf-8

# Ian Haigh - thejoyofappscript.com

# Make a new To Do in Things, based on the name and URL of the currently
# selected item in NetNewsWire. The new To Do goes slap bang into the "Someday"
# category. Handy for temporary bookmarks for things that you want to check
# out later but aren't suitable for Instapaper, like video.

# Based on this script by Mike Hall:
# http://mph.puddingbowl.org/2010/07/creating-links-in-the-body-of-a-note-in-things/

TAGS = "nnw, watch"
# tags that get added to the new To Do

def create_to_do(name, source, link)
	if link == ""
		note = name
	else
		note = "[url=#{link}]#{name} - #{source}[/url]"
	end

	task = @things.make(:at => app.lists["Someday"].beginning, :new => :to_do, :with_properties => {
		:name => "#{source} – #{name}",
		:tag_names => TAGS,
		:notes => note,
	})
end

require 'rubygems'
require 'appscript'
include Appscript

nnw = app("NetNewsWire")
@things = app("Things")

name = nnw.selectedHeadline.title.get
link = nnw.selectedHeadline.URL.get
source = nnw.selectedHeadline.subscription.givenName.get

create_to_do(name, source, link)

#`growlnotify -p 1 -m "Added \"#{name}\" to things."`

# uncomment the previous line if you've got Growl installed
# and you want a pretty message to pop up.

n.b. if you’ve carefully locked certain layers, this will reset everything to unlocked. The script could certainly be tweaked (by someone less lazy than me) to remember which layers were locked.

Download Delete invisible layers.rb.zip

What I like about this is the use of Appscript.its to operate on a bunch of items at once, rather than having to loop through them. I suspect (though I’m not sure) that this is an advantage of an Apple Events approach as opposed to ExtendScript, Adobe’s JavaScript based alternative. For more on the powerful – and sexy – filtering that Appscript.its lets you achieve, check out this section of Matt Neuberg’s book.

The source code is playfully chasing its shadow in that leafy glade over there.

#!/usr/bin/arch -i386 ruby

# Illustrator won't let me delete hidden layers containing artwork, so we'll
# invert the visibility of all the layers first (visible become invisible and
# vice versa) and then delete the visible ones.

require "rubygems"
require "appscript"

ill = Appscript.app("Adobe Illustrator")
doc = ill.current_document

# first, save a list of the layers we want to keep (i.e. that are currently
# visible)
save_these = doc.layers[Appscript.its.visible.eq(true)].get

# unlock all the layers
begin
	doc.layers[Appscript.its.visible.eq(false)].locked.set(false)
rescue Appscript::CommandError
	puts "There don't seem to be any invisible layers for me to delete."
	exit
end

# turn on visibility of all the layers
doc.layers.visible.set(true)

# loop through our list of layers to save, making them invisible
save_these.each { |l| l.visible.set(false) }

# delete the ones we can see …
doc.layers[Appscript.its.visible.eq(true)].delete

# and turn the others back on again.
doc.layers.visible.set(true)

However, the Internet toils tirelessly whether I’m paying attention or not. One tireless toiler is Mike Hall, a guy who has more rb-appscript prowess in his little finger than I have in my entire hand. He kindly pointed me in the direction of his blog, which has a terrific array of ruby scripts. It’s so good that I’m going to put it on its own line:

http://mph.puddingbowl.org/category/ruby/

If you’re jonesing for more app("Grue").do_some_stuff({:like => "now"}) then I highly recommend you check it out. I plan on porting Mike’s scripts over here too, so that they’re preserved for posterity, but mainly so I look like I know what I’m doing.

This little baby uses the front two Finder windows to figure out the source and destination. Just be careful that they are the front two windows, or you may get unexpected – perhaps terrifying – results. I took the time to build in a confirmation dialog; just edit the code if you feel like living dangerously.

The source code dances a merry jig, over yonder.

Download Symlink-this-window-to-that-one.rb.zip.

#!/usr/bin/ruby

# rb-appscript script by Ian Haigh (http://ianhaigh.com/)
# Thu Dec 17 16:50:08 EST 2009

# Looks at the front two Finder windows, and makes a symlink from the first
# window to the second. If there's something selected in the first window, it
# will loop through all the items and make them symlinks in the second.
# Otherwise, it will figure out the target of the first window, and symlink
# that.	Just make sure that the SOURCE WINDOW is the frontmost, and the
# destination window is next in the stacking order.

require 'appscript'
require "osax"
sa = OSAX.osax("standardadditions")

#  set "paranoid" to false if you don't want to confirm the symlink
PARANOID = true

finder = Appscript.app('Finder.app')

if finder.Finder_windows.get.length < 2 then
	sa.display_alert("I need two windows open: frontmost for source, the second for the destination.")
	exit
end

# I can't figure out how to get a bunch of files' paths all at once, without
# having to revert to this "collect" hack
source = finder.selection.get(:result_type => :alias).collect { |item| item.path }

if source.empty?
	# get the front window target instead
	source << finder.Finder_windows.get[0].target.get(:result_type => :alias).path
end

if PARANOID
	source_window = finder.Finder_windows.get[0].target.name.get
	dest_window = finder.Finder_windows.get[1].target.name.get

	plural = (source.length == 1) ? "" : "s"
	confirm_string = %Q{About to symlink #{source.length} item#{plural} from “#{source_window}” to “#{dest_window}”. You wanna go ahead?}

	begin
		result = sa.display_dialog(
		confirm_string,
		:buttons => %w{Cancel OK},
		:default_button => "OK"
		)
	rescue Exception => e
		exit
	end

	# exit unless result[:button_returned] == "OK"
end

destination = finder.Finder_windows.get[1].target.get(:result_type => :alias).path

source.each do |item|
	full_path = File.join(destination, File.basename(item))

	# printf("File.symlink(%s, %s)\n", item, full_path)
	File.symlink(item, full_path)
end

This script will save all your layer comps separately, in a format of your choosing. “But,” I hear you cry, “Photoshop already comes with a script that already does that already”. Yes, but this one uses the magnificent “Save for Web” command, which performs superior squishing and optimising.

Download Export-layer-comps.rb.zip.

The source code is rubbing its sleepy eyes and yawning, just over there.

#!/usr/bin/env ruby

# rb-appscript script by Ian Haigh (http://ianhaigh.com/)
# Mon Dec 14 10:32:32 EST 2009

# This is a quick & easy way to export all your layer comps to individual
# files. One advantage of this technique is that it uses the "Save for Web…"
# command, which (in my experience) generates smaller, higher quality web
# graphics.

require 'rubygems'
require 'optparse'
require 'appscript'
require "osax"

sa = OSAX.osax('StandardAdditions')

ps = Appscript.app('Adobe Photoshop CS4.app')
finder = Appscript.app("Finder.app")

begin
	comps = ps.current_document.layer_comps.get
rescue Exception => e
	sa.display_alert("Please open a document with at least two layer comps.", :as => :critical )
	exit
end

# Save them into the same directory.
# (This could be modified so the user can choose where to save the files)

begin
	dir = File.dirname(ps.current_document.file_path.get.to_s)
rescue Appscript::CommandError => e
	sa.display_alert("Please ensure the document is saved before running this script.")
	exit
end

format = sa.choose_from_list(
	%w{ jpg png psd },
	:with_title => "Export layer comps",
	:with_prompt => "Choose a format",
	:default_items => ["jpg"],
	:multiple_selections_allowed => false,
	:empty_selection_allowed => false
)[0]

# loop through each comp, applying and saving it as we go
comps.each do |c|
	ps.apply(c)
	file_name = File.basename(ps.current_document.name.get, ".*") + "_" + c.name.get

	case format
	when "jpg"
		ps.export(ps.current_document, :in => "#{dir}/#{file_name}.jpg", :as => :save_for_web,
			  :with_options => {:web_format => :JPEG, :quality => 90})
	when "png"
		ps.export(ps.current_document, :in => "#{dir}/#{file_name}.png", :as => :save_for_web,
			  :with_options => {:web_format => :PNG, :png_eight => true})
	when "psd"
		ps.save(
			ps.current_document,
			:in => "#{dir}/#{file_name}.psd",
			:as => :Photoshop_format,
			:appending => :lowercase_extension,
			:copying => true,
			:with_options => {
				:save_layers => false
			}
		)
	end
end

finder.open(MacTypes::Alias.path(dir))
finder.activate

Download Update-all-modified-images.rb.zip.

As it’s only little, I’ve decided to let this source code live on the front page.

#!/usr/bin/env ruby

# rb-appscript code by Ian Haigh : http://ianhaigh.com/
# Fri Dec  4 15:54:38 EST 2009

require 'rubygems'
require 'appscript'
include Appscript

ai = Appscript.app('Adobe InDesign CS4.app')

#  Update all modified images
ai.active_document.links[its.status.eq(:link_out_of_date)].update

Download Total-size-of-current-playlist.rb.zip.

The source code is cowering sheepishly around the corner.

#!/usr/bin/env ruby -w

# rb-appscript code by Ian Haigh : http://ianhaigh.com/
# Fri Dec  4 11:53:38 EST 2009

require 'rubygems'
require 'appscript'

class Numeric
  def to_human
    units = %w{B KB MB GB TB}
    e = (Math.log(self)/Math.log(1024)).floor
    s = "%.3f " % (to_f / 1024**e)
    s.sub(/\.?0*$/, units[e])
  end
end

app = Appscript.app("iTunes.app")

total = app.browser_windows.view.tracks.get[0].inject(0) { |total, t| total + t.size.get }

puts "#{total.to_human}"

Download All-layers-visible.rb.zip.

The source code is sheltering from a brief sun shower below.

#!/usr/bin/ruby

# rb-appscript code by Ian Haigh : http://ianhaigh.com/
# Fri Dec  4 11:21:53 EST 2009

require "rubygems"
require 'appscript'

Appscript.app('Adobe Illustrator.app').current_document.layers.visible.set(true)

Download Reveal-links-in-Finder.rb.zip.

The source code is bouncing from foot to foot in anticipatory glee, just after the jump.

#!/usr/bin/env ruby

# rb-appscript code by Ian Haigh : http://ianhaigh.com/
# Fri Dec  4 11:09:29 EST 2009

# loops through all the selected items, attempts to figure out whether any of
# them are linked images, and opens their containing folders, selecting all of
# 'em.

require 'rubygems'
require 'appscript'
include Appscript

def allItemLinks(objList)
	@myList = []

	objList.each do |obj|
		if [:PDF, :image].include?(obj.class_.get) then
			@myList << obj.item_link.file_path.get
		else
			obj.all_graphics.get.each do |img|
				@myList << img.item_link.file_path.get
			end
		end
	end
	@myList
end

@id = app('Adobe InDesign CS4.app')
@doc = @id.active_document

x = allItemLinks(@id.selection.get)
@finder = app('Finder.app')

# make an array with every image folder
image_folders = []
x.each { |path| image_folders << path.slice(/^.+:/) }

# reveal one file first
begin
	@finder.reveal(x[0])
rescue Exception => e
	puts "Couldn't reveal #{x[0]}"
end

# attempt to select all the files simultaneously
image_folders.uniq.each do |folder|
	begin
		@finder.open(folder)
		files_in_this_folder = x.select { |c| c.include?(folder) }
		@finder.set(:selection, :to => files_in_this_folder)
	rescue Exception => e
		puts "Couldn't reveal #{folder}:"
		puts e
	end

end

@finder.activate