Since I don’t use the ProjectViewer plugin this macro has to have its own logic for determining where the “project root” is. The way it works is that it tries to find the root folder of the current project by way of searching for version control system folders (i.e. .git, .hg, .bzr, _darcs, .svn or CVS). The assumption is that as the script traverses the file system folder structure from the buffer’s location towards the root the first folder that has a Git, Mercurial, Bazaar or Darcs folder (or the last to have a Subversion or CVS folder) is the root. When the script finds the project root it switches the file browser to display it while keeping the UI focus in the editor field. If no project root can be found in this manner, the script sets the file browser to the directory that contains the currently open file.

Download the macro script itself here: Open_Root_of_Current_Project_in_File_Browser.bsh

You install it by dropping it into your jEdit user settings directory’s /macros folder (select Utilities → Settings Directory from the jEdit menu to find this location) and then running Macros → Rescan Macros. You can set a keyboard shortcut for this via the Shortcuts section of jEdit’s preferences and/or add a toolbar button via the Tool Bar section.

Here is the macro source:

This class is called CalStoreHelper and it provides you with two methods: one for getting events and the other for getting tasks. An example script shows you concretely how to generate different kinds of output. Below is a small excerpt that shows how to generate CSV output:

You can get the class by cloning the version control repository with Mercurial or by downloading an archive from the repository browser page (the bz2, zip and gz links at the top). Happy hacking.

Emoji and Unicode

Emoji is basically a Japanese term for emoticons used on mobile devices. The Wikipedia article has more information on the concept, but this part is the most interesting:

When transmitted, emoji symbols are specified as a two-byte sequence, in the private-use range E63E through E757 in the Unicode character space, or F89F through F9FC for Shift-JIS.

Now, that’s not true for Apple’s Emoji implementation — it’s apparently completely incompatible with the handsets from the Japanese carriers (see OpenRadar #6402446 for more info) — but the part about them being implemented as unicode symbols is still true in iOS, the code points used are just different.

I’ve made this demo page that lists unicode symbols and the hexadecimal code points for all the different Emoji that are available on my iPhone (iOS version 4). The demo page has a cache manifest so it should be available offline as well. If you’re currently on a desktop computer you won’t be able to see them so here’s a picture of what it looks like on the iPhone:

In order to be able to use these icons you need to have easy access to the hexadecimal unicode code points so this page should come in handy. If you instead prefer a native app for this, there are many you can choose from.

Using Emoji Symbols in HTML and CSS

User agent detection is usually cited as a bad thing, and with good reason — it’s often used when feature detection would be more appropriate, causing unexpected breakage in many edge conditions. When planning on using the iOS emoji on a web page, though, you really need to sniff the user agent in order to know whether the client is an iOS device and thus has a font that implements these unicode symbols in the expected way.

Here’s an example (in PHP) of how you’d detect iOS devices:

When you’ve detected the client to be an iOS device, you can offer them an additional stylesheet:

In this stylesheet you’ll then insert the Emoji symbols into whatever locations you’d like to use them in, and to do this you can use CSS2′s content generation mechanisms (in the examples below, we use code point E00E, which is the “thumbs up” Emoji):

Containing all the iOS-specific embellishments in one separate CSS file is, I think, the way to go, but if you want you can also insert these symbols directly into your HTML as special entities:

Big Caveats to Consider

This is a great way to add little graphical cues to your web app without having to deal with images (i.e. making or obtaining them, serving them, having the app load them, possibly caching them) but of course the downside is that they are only available on Apple’s iOS devices, which makes this trick quite useless unless you’re concentrating completely on the iPhone/iPad/iPod Touch axis.

The key takeaway from this should be that there’s this neat trick you can use but if you need your icons to be visible in all clients you should forget about these and just use images for everyone (it’ll be much easier).

I read somewhere that Safari (or the OS? or iTunes?) sometimes decides to “fix” the mappings of iTunes URL protocol handlers, forcing you to “play cat and mouse” if you decide to prevent iTunes from automagically opening up by removing it as the itms: protocol handler, so I decided that it would be best to try and fix this problem by messing with the iTunes website source via GlimmerBlocker, which I already was using for ad blocking.

I couldn’t find any straightforward directions on how to do this with GlimmerBlocker so I decided to post it here myself once I figured out how to do it. So this is how I prevented iTunes from automatically opening up whenever I open up a store link in my browser:

• Open the GlimmerBlocker “filters” tab and add a new filter, as well as a new rule for this filter.
• Select Whitelist URL, optionally modifying content as the action
• For the Host section, select is as the predicate and type in itunes.apple.com
• Select ignored for both Path and Query
• Switch to the transform tab and type in the following:
replace(/detectAndOpenItunes\(\);/g, "<!-- detectAndOpenItunes() zapped -->");
• Make sure the Only for content-type selection in the bottom-right corner of the dialog sheet is html
• Save

This seems to correctly prevent the iTunes app from opening up whenever a store website is opened, but it still allows for opening the viewed product in the stand-alone app via the “View in iTunes” link on the page.

The Application Kit additions to the NSAppleScript class provide an implementation of the syntax highlighting (which would be the hardest part in implementing something like this) and I already have the ANSIEscapeHelper class that provides the translation of an NSAttributedString to an ANSI-escaped NSString (which would be the second-hardest part in implementing something like this) so writing a command-line program around these two parts was quite simple in the end. The program is called asprint and it has its own page on this site where you can download it.

This is what using asprint looks like:

Benefits of Declarative Diagramming

Web Sequence Diagrams is great. It uses a simple, readable syntax you can use to type in descriptions of sequential workflows and based on that it will generate the corresponding UML sequence diagrams for you.

Working with these diagrams in this way has a couple of nice benefits over more intricate/professional methods:

• They’re quick to create and quick to modify
• The syntax is pretty easy to read as-is
• The source is plain text, so all the benefits of using plain text apply (e.g. can put under source control, can use simple diff tools, file sizes are small etc.)

Helper Script and Syntax Highlighting

When I was sure I wanted to use this method again in the future, I hacked up a few quick and simple tools for this:

Script for generating the diagram images from source files

At the time of this writing, there’s a suggestion called “Create a command-line version of this application” on the service’s UserVoice site that’s labeled “started”, so hopefully in the future we’ll have a command-line sequence diagram generator from the author of the online service. In the meantime, though, here’s my solution. This is a Python script that can be used for generating the diagram images (using this service) from “source files” that contain the declarative workflow syntax. You just need to:

1. type up your diagram description in a text editor and save it into a file
2. begin the first line in the file with #wsd (so that the script knows this is a websequencediagrams.com syntax file)
3. (optional:) specify the diagram style you’d like to use on the first line with the syntax #wsd:style=modern-blue
4. call the script with the path to this file as an argument to generate the diagram image

The script uses a temporary SQLite database to save hashes of file contents so that even if you call it repeatedly for the same file, it’ll notice if the file contents haven’t changed and decide not to send a request over to the server. I did this in order to reduce unnecessary load on the server. I tested the script on Mac OS 10.5.7, Windows XP SP3 and Ubuntu 9.04 and it seems to work just fine on all of those (of course, on Windows you’ll first have to install Python manually).

Download the script here: wsd.py

Here’s an example on how to use it (to see the script’s usage info, run it without any arguments):

Save this into a file called ax-diagram:

#wsd

participant "Component A" as A
participant "Component X" as X

X -> A: what up
A -> A: processWhatUp()
note over A: A is confused
A -> X: go away
destroy X

Then run the script:

wsd.py ax-diagram

…and the file ax-diagram.png is created:

jEdit syntax highlighting mode

This is a simple jEdit syntax highlighting mode for the Web Sequence Diagrams syntax. You can download the file here: websequencediagrams.xml. Refer to this other blog post of mine for instructions on how to install modes for jEdit.

Here’s a screenshot of the highlighted syntax on my machine:

Like I’ve mentioned before in this blog, I develop Flex applications using the Flex SDK and jEdit instead of Adobe’s Flex Builder IDE. This setup has worked very well for me but one annoying issue I’ve had to deal with because of this is the slow compilation speed: every time I make a small change into one of my projects and recompile it, the mxmlc compiler (that my build scripts are calling) has to load the JVM into memory and recompile my whole project from scratch, which obviously takes a while. Compiling things in Flex Builder is a lot faster, and the reason for that is the Flex Compiler Shell, which it uses for compilation instead of mxmlc.

The basic idea behind the Flex Compiler Shell is that it would stay in memory between compilations (thus avoiding the cost of loading up the JVM every time you want to compile something) and use a technique called incremental compilation that, as the name suggests, is based on the idea of only compiling the parts of your project that have changed since the last compilation (thus making the process a lot faster). When you run the Flex Compiler Shell executable (called fcsh), you’re thrown into an interactive shell where you can run commands in order to compile your projects and control the operation of fcsh itself.

The Problem

When I found out about fcsh, tried it out and saw how much faster it was than mxmlc, of course I wanted to immediately start using it instead in my build scripts. The biggest problem with doing this, though, is the fact that the basic operation of these two programs is fundamentally different: when you run mxmlc, it compiles the project, prints some messages to standard output and then exits (with the exit status 0 if the compilation was successful or 1 if it wasn’t), which is perfect for integrating it into build scripts. Fcsh, on the other hand, throws you into a shell of its own and expects you to essentially operate it from within itself (instead of simply calling it with some arguments and then having it return with some standard output and an exit status like mxmlc).

The other issue that makes fcsh more difficult to use in general is that in order to use the incremental compilation feature, you have to first compile your project like you normally would (using the “mxmlc” command), then make note of the “compile target id” number that fcsh then assigns to this project and specifies in its output, and for future compilations use the “compile N” (where N is the compile target id) command.

The Solution

I tried to search for a solution to this problem that somebody else might have come up with but didn’t find an adequate one (a list of the ones that I could find is further down), so I decided to give it a shot myself. My approach, called fcshctl (short for “fcsh controller”), is basically a simple bash script that:

1. starts the fcsh process if it isn’t already running
2. forwards its arguments to fcsh as commands
3. reads the output of that command from the fcsh interactive shell and prints it to the standard output
4. exits with status 0 (success) or >0 (failure)

In addition to this, I also made the script automatically and transparently invoke the incremental compilation feature whenever applicable so that I wouldn’t have to worry about keeping track of the compile target ids and using a different command for the compilation whenever one had already been assigned.

Below is a summarization of the pros and cons of this solution:

Pros:

• It’s quite simple — just one shell script (a few others are included in the .zip that are only for convenience and not required)
• It runs the fcsh instance in a GNU screen session, which means that:
• The running fcsh instance is accessible to all user processes (i.e. not just within a single shell session, for example)
• It is possible for the user to enter the running fcsh interactive shell at any time (by attaching to the screen session via the command screen -r -S fcsh) and manually interact with it
• It automatically checks whether you’ve compiled a specific file before and keeps track of the compile target ids that fcsh assigns so that it can automatically and transparently invoke the incremental compilation feature and let you access the speed gains that are fcsh’s main offering without any additional work. This feature can also be turned off by setting an environment variable.
• A proxy script (called fcshctl-mxmlc) that can be used in place of mxmlc is provided. It simply calls fcshctl with “mxmlc” as the first argument, followed by all the other arguments you specify, so that you can simply use this script as a stand-in for mxmlc in any build scripts that you may be using without having to modify them any further.

Cons:

• It uses the GNU screen logging mechanism and polling for changes in the log file in order to catch the output of commands sent to fcsh, which is not very elegant and causes a slowdown of maybe about a couple hundred milliseconds before the output is printed to stdout.
• The output of the executed fcsh command is not printed to the standard output as it comes, but instead all at once when the command finishes (this is not a problem for me personally, but others might want to fix this).
• It’s implemented as a bash script, which means that it’s not the fastest monster out there (we’re talking about milliseconds here, though, so it doesn’t bother me at all).

Download

You can download fcshctl here:

• fcshctl-v0.5.1.zip (latest)
• fcshctl-v0.5.zip
• fcshctl-v0.4.zip
• fcshctl-v0.3.zip

fcshctl has been tested with fcsh versions 3.0.0 build 477 and 3.1.0 build 2710 on Mac OS 10.5.5. It is licensed under the MIT License.

The script requires the following to be in your $PATH: rm, mv, cat, ps, sleep, tail, head, grep, awk, screen, xargs and basename. You also need to have the FLEX_HOME environment variable set to point to the Flex SDK root path.

Example of use

fcshctl $ export FLEX_HOME=/Users/username/code/SDKs/flex_sdk_3.1
fcshctl $
fcshctl $ ./fcshctl

Usage: fcshctl <commands>

  Substitute <commands> with any commands you
  would like to send fcsh, just like you would
  enter them in the interactive fcsh shell
  session.

  To get a list of the available commands, run:

    fcshctl help

fcshctl $
fcshctl $ ./fcshctl help
List of fcsh commands:
mxmlc arg1 arg2 ...      full compilation and optimization; return a target id
compc arg1 arg2 ...      full SWC compilation
compile id               incremental compilation
clear [id]               clear target(s)
info [id]                display compile target info
quit                     quit
fcshctl $
fcshctl $ ./fcshctl mxmlc ~/code/Flex/projects/testbed/testbed.mxml
Loading configuration file /Users/username/code/SDKs/flex_sdk_3.1/frameworks/flex-config.xml
Recompile: /Users/username/code/Flex/projects/testbed/testbed.mxml
Reason: The source file wasn't fully compiled.
Files changed: 0 Files affected: 1
/Users/username/code/Flex/projects/testbed/testbed.mxml(28):  Error: Incorrect number of arguments.  Expected 2.

    func1("toka");

fcshctl $ echo $?
1
fcshctl $
fcshctl $

Other similar solutions

Below is a list of other approaches to the problem of integrating fcsh to non-standard (i.e. non-Flex Builder) workflows (roughly in order from most promising to least promising), and short lists of reasons why I personally didn’t want to use them. If my solution doesn’t seem good to you, you should maybe check some of these out.

fcsh tools by Mike Rowe

• Runs fcsh in a daemonized process, which means you won’t be able to enter the interactive shell of a running fcsh process and manually interact with it
• You can only specify the filename to compile; has no support for additional mxmlc arguments
• For GNU/Linux (but seems to work just fine on OS X as well)

flex-compiler-shell-daemon by Leonardo Soto Muños (also see his blog post about it)

• I couldn’t get it to work out of the box on OS X
• Runs fcsh in a daemonized process, which means you won’t be able to enter the interactive shell of a running fcsh process and manually interact with it

FCSH Wrapper by Mihai Vasilache

• For Windows
• Designed to be used with Ant
• A bit complicated

http://code.google.com/p/fsch/ by nimrod97

• For Windows

BigSource Zarkov by BigSource GbR

• For Eclipse & Ant

The good news is that Google provides a nice, standard POP3 interface for downloading emails from their service, and all of the software required for downloading messages via POP is already installed in Mac OS X Leopard by default. Below I’ll go through all of the steps it took me to set up periodical and automated GMail backups on my Macbook.

The following were my sources for most of the information presented here:

• LifeHacker: Geek to Live: Back up Gmail with fetchmail
• Logic Bound: Backup Gmail Data
• bronski.net: fetchmail & SSL
• Matthias Andree and Paul Elliott on [fetchmail-users]: What is a “local issuer certificate”?

Configure GMail for POP access

1. Go to GMail’s “Forwarding and POP/IMAP” settings
2. Set the “POP access” setting to “Enable POP for all mail (even mail that’s already been downloaded)”
3. Make sure that the “When messages are accessed with POP” setting says “keep Gmail’s copy in the inbox”

Configure fetchmail to Download the Messages

1. Create ~/.fetchmailrc with the following contents (replacing GMAIL_USERNAME, GMAIL_PASSWORD and LOCAL_USERNAME with their real values in your case):

poll pop.gmail.com with proto POP3 and options no dns
user 'GMAIL_USERNAME@gmail.com' there with password 'GMAIL_PASSWORD' is 'LOCAL_USERNAME' here and wants mda "/usr/bin/procmail -d %T"  options ssl keep sslcertck sslcertpath "/Users/LOCAL_USERNAME/.ssl/certs"

This configuration basically tells fetchmail to:

• Connect to the GMail POP server using the POP3 protocol,
• Map your GMail username to your localhost username,
• Deliver the downloaded mail into your local system mailbox (mail spool file),
• Connect using an encrypted SSL connection,
• Strictly check the SSL certificates of the server it connects to against local trusted certificates,
• Search for the local certificates in ~/.ssl/certs
2. Set the proper rights for ~/.fetchmailrc:
    chmod 710 ~/.fetchmailrc
3. Get the pop.gmail.com server’s SSL certificate from the POP port (note that this should be done using a secure, trusted internet connection — otherwise it kind of defeats the purpose):
    openssl s_client -connect pop.gmail.com:995 -showcerts

From the output of this command, copy the part that looks like this:

-----BEGIN CERTIFICATE-----
(a big bunch of characters here)
-----END CERTIFICATE-----

And save it into a file called ~/.ssl/certs/gmailpop.pem.

4. Download the certificate authority (Equifax) root certificate (for example from GeoTrust’s site here, where it says “Equifax Secure Certificate Authority (Base-64 encoded X.509)”), rename it to “equifax.pem” and move it to ~/.ssl/certs/equifax.pem (and just like the previous step, this should be done over a trusted internet connection as well).
5. Hash the certificates in this directory by running:
    c_rehash ~/.ssl/certs/

Optional: Specify the Location for Downloaded Messages

We’ve configured fetchmail to send messages to procmail, which will handle the storing of them in a mail spool file. By default this will be in /var/mail/LOCAL_USERNAME, but if you want to store it somewhere else, you can specify the location in the ~/.procmailrc configuration file. Below is an example (replace LOCAL_USERNAME with your username):

I prefer to exclude my mail spool file from Time Machine backups (because it’s a large file that changes very often which makes it take up a lot of disk space from my backup volume) so I have it located in ~/.mailspool/ like in the above example. This is because in OS X /var is actually a symbolic link to /private/var and Time Machine has a bug where it’s impossible to exclude anything from under that path from backups (for example, if I choose to exclude /private/var/mail in the GUI, it’ll replace this selection with /var/mail automatically, and even though /var/mail is then excluded, it’ll still back up /private/var/mail).

Download Messages with fetchmail

You can now download the mail by running this command (the -v argument is for verbose output):

Unless you only have a few mails in your Gmail box, this command will initially have to be run several times in a row in order to get all of the messages since it only downloads a few hundred messages at a time. The mail spool file containing all of the downloaded messages will then be found in /var/mail/LOCAL_USERNAME (or in whichever location you’ve specified in ~/.procmailrc).

It’s a good idea to set up a launchd job for running this command between regular intervals so that you wouldn’t have to remember to manually do it yourself. Lingon is an ideal GUI app for this purpose. My GMail backup launchd job doesn’t call fetchmail directly, though: it calls this helper Python script that I’ve written. The script does the following:

• Runs fetchmail,
• Displays Growl messages about the result (success or failure, number of messages downloaded if successful, etc.),
• Optionally saves fetchmail’s output into a log file when done.

Feel free to use it (remember to set the values in the “settings” section before running it, though).

Read Downloaded Messages with Thunderbird

In Mozilla Thunderbird, go to Tools > Account Settings… > Local Folders to get to the Local directory path. Go into this directory and create a symbolic link there that points to the mail spool file:

After this you’ll be able to find your backed up GMail messages in a folder called “GMailBackups” under “Local Folders” in Thunderbird.

Marc Liyanage at entropy.ch has already pretty much done the bulk of the work for this already. The differences between my solution and his are basically that mine tries to output lots of info to the user (via stdout or Growl,) mine doesn’t care when the last sync took place, and that mine can be configured to start up iSync if it isn’t already running.

An earlier version of my script figured out (via iSync’s AppleScript interface) when the last sync procedure took place (regardless of whether it had been invoked from this script or from iSync itself) and then either cancelled or proceeded with the syncing based on that, but after a while I realized I had no need for that kind of a feature, so I removed it. I don’t have the old version available anymore, but if anyone is interested in adding that feature, I still have the lastSync.scpt AppleScript I used to check if the difference between the current date and the last sync’s date was long enough. It’s included in the zip archive (a link to which is below.)

The (very general) directions to configuring the script and making it run are in the comments in the beginning of the file.

Download:

• The script and supporting files in a zip archive
• bluelist by Marc Liyanage and Will Harris (required for this to work — save it in /usr/local/bin or somewhere)
• Lingon by Peter Borg (optional: for setting up a launchd configuration for this from a GUI)
• Growl (optional: for notifications. also remember to install the growlnotify CLI app that is included with the distribution package, and if you’re running Leopard, check out my workaround for a Leopard bug in growlnotify)

The script:

#!/bin/bash

#
# ----------------------------------------------------------------
#
# DESCRIPTION:
#
# A script that is meant to be run periodically in order to
# force iSync to synchronize.
#
# It will not, however, invoke the sync if a specific
# device (e.g. a mobile phone) is not connected via Bluetooth.
#
#
#
# (c) Ali Rantakari, 2007-2008
#     http://hasseg.org
#
# ----------------------------------------------------------------
#
# REQUIRES:
#
# - OS X 10.4 (Tiger) or later
#
# - The "bluelist" helper application by Marc Liyanage
#   and Will Harris
#		( link to the blog post where i found it:
#		  http://tinyurl.com/2ahpme
#		  direct link to the app itself:
#		  http://will.harris.ch/bluelist.gz )
#
#
# OPTIONAL:
#
# - Growl + growlnotify (for notifications)
#
# - Lingon (launchd/launchctl GUI for scheduling the running
#           of this script at regular intervals)
#
#
# ----------------------------------------------------------------
#
# SETTING IT UP:
#
# 1) Change the settings in the "settings" area below to
#    correspond to your environment
#
# 2) Use Lingon/launchctl to schedule this script to be run
#    periodically
#
#
# ----------------------------------------------------------------
#
# NOTE 1:	You can run this script from the command line
#			with the parameter "-v" to check that it is working.
#			all notifications (and some additional info) will
#			be printed to the standard output then.
#
# NOTE 2:	I also noticed that iSync seems to not be setting the
# 			sync status value for applescript properly -
# 			a failed sync may have a status code of a successful
# 			one - and thus this script may notify you that
# 			the sync was successful when it in fact was not.
# 			I have reported this issue to Apple on 12 Feb 2008,
#           and as of this writing (17 Apr 2008,) it still seems
#           to be open (the radar ID is 5738357).
#
# NOTE 3:	I found a lot of useful info for making this
# 			script from these places:
#
# 			http://hollington.ca/technocrat/?p=44
# 			http://tinyurl.com/2ahpme  [ -> entropy.ch]
#
# ----------------------------------------------------------------
# 

# get the location of this script.
#
# do not change this (unless you know a better
# implementation ;) )
#
DN=`dirname $0`
THISDIR="`cd $DN; pwd`"

# ----------------------------------------------------------------
#
# SETTINGS:
#
# 

# the bluetooth name of your mobile phone (or any similar device
# you're syncing with iSync via BT)
#
MOBILEBTNAME="MyPhoneName"

# the level of notifications you want to receive
#
# 0 = quiet (no notifications at all)
# 1 = inform only when starting to sync and
#     when sync has completed
# 2 = inform of everything
#
NOTIFICATIONLEVEL=1

# whether to run iSync if it isn't already running
#
# "true"  =		if iSync is not running, run it
# 				and then invoke the sync procedure
# "false" =  	if iSync is not running, don't sync
#
RUNISYNCIFNOTRUNNING="false"

# locations of CLI apps used
#
# custom: (you need to get these yourself)
#
GROWLNOTIFY=/usr/local/bin/growlnotify
BLUELIST=/usr/local/bin/bluelist
#
# system: (these should be here)
#
OSASCRIPT=/usr/bin/osascript
STAT=/usr/bin/stat
TOUCH=/usr/bin/touch

# the name of this application
# (to send to growlnotify)
#
THISAPP="Autosync script"

# whether to use growl or stdout (or both) for notifications
#
# "stdout" -> notifications will be printed to stdout
# "growl"  -> notifications will be sent to growl
# "both"   -> notifications will be sent to growl _and_
#             printed to stdout
#
NOTIFICATIONS="growl"

# the icon to show in growl notifications
#
GROWLICON="$THISDIR/forcesync.icon.png"

# - - - - - - - - - - - - - - - - - - - - - -
# settings end here.
# ----------------------------------------------------------------
# 

# Script IMPLEMENTATION begins here ---------------------------
# -------------------------------------------------------------
# 

# --- functions ------

# parameters:
#
# $1 = Title
# $2 = Message
# $3 = Minimum notification level
# $4 = Location of icon to show
show_message()
{
	if [ $NOTIFICATIONLEVEL -gt $(( $3 - 1 )) ] || [ $VERBOSEMODE == 1 ];then 

		if [ "$NOTIFICATIONS" != "stdout" ]; then

			if [ -e "$4" ];then
				THISGROWLICON="$4"
			else
				THISGROWLICON="$GROWLICON"
			fi

			$GROWLNOTIFY -n "$THISAPP" -t "$1" -m "$2" --image "$THISGROWLICON"

		fi

		if [ "$NOTIFICATIONS" != "growl" ];then

			echo "** $1"
			echo "   $2"
			echo " "

		fi

	fi
}

# no params
check_isync_running()
{
	if [ "`ps xwww | grep -v grep | grep -c iSync.app/Contents/MacOS/iSync`" == "0" ];then
		echo "false"
	else
		echo "true"
	fi
}

# no params
check_mobile_present()
{
	if [ "`$BLUELIST | grep \"$MOBILEBTNAME\"`" == "$MOBILEBTNAME" ];then
		echo "true"
	else
		echo "false"
	fi
}

# no params
activate_isync()
{
	$OSASCRIPT -e "tell application \"iSync\" to activate" -s o
}

# no params
hide_isync()
{
	$OSASCRIPT -e "tell application \"System Events\" to set visible of process \"iSync\" to false" -s o
}

# --- /functions ------

# script runs from here:
# --------------------------------------------

VERBOSEMODE=0
if [ "$1" == "-v" ];then
	VERBOSEMODE=1
	NOTIFICATIONS="both"
	echo " "
fi

# check if mobile phone is in Bluetooth range

if [ $VERBOSEMODE == 1 ];then
	echo " "
	echo -n "Scanning for bluetooth device \"$MOBILEBTNAME\"..."
fi

if [ "`check_mobile_present`" == "false" ];then
	if [ $VERBOSEMODE == 1 ];then
		echo " ...not found!"
		echo " "
	fi
	show_message "Will not sync" "\"$MOBILEBTNAME\" not found (either BT is off or device is out of range)" 2
	exit 0
else
	if [ $VERBOSEMODE == 1 ];then
		echo " ...found!"
		echo " "
	fi
fi

# check if iSync is running

ISYNCRUNNING="`check_isync_running`"

if [ "$ISYNCRUNNING" == "false" ] && [ "$RUNISYNCIFNOTRUNNING" == "true" ];then

	show_message "Starting up iSync" "Activating and hiding iSync" 2
	activate_isync
	hide_isync

elif [ "$ISYNCRUNNING" == "false" ] && [ "$RUNISYNCIFNOTRUNNING" != "true" ];then

	show_message "Will not sync" "iSync is not running" 2
	exit 0

elif [ "$ISYNCRUNNING" == "true" ];then
	if [ $VERBOSEMODE == 1 ];then
		echo "iSync seems to be running. continuing..."
		echo " "
	fi
else
	show_message "Error" "The iSyncRunning applescript returned invalid value: \"$ISYNCRUNNING\"" 1
	exit 0
fi

# sync

show_message "Sync starting" "Telling iSync to synchronize..." 1

SYNCSTATUS="`$OSASCRIPT -s o \"$THISDIR/forceSync.scpt\"`"

if [ "$SYNCSTATUS" == "2" ];then
	show_message "Sync completed" "...Synchronization completed successfully." 1
	exit 0
elif [ "$SYNCSTATUS" == "3" ];then
	show_message "Sync warnings" "...Synchronization completed with warnings!" 1
	exit 3
elif [ "$SYNCSTATUS" == "4" ];then
	show_message "Sync errors" "...Synchronization completed with errors!" 1
	exit 4
elif [ "$SYNCSTATUS" == "5" ];then
	show_message "Sync cancelled" "...Synchronization was cancelled!" 1
	exit 5
elif [ "$SYNCSTATUS" == "6" ];then
	show_message "Sync failed" "...Synchronization failed to complete!" 1
	exit 6
elif [ "$SYNCSTATUS" == "7" ];then
	show_message "Sync failed" "...Synchronization did not succeed (status: (7) \"never synced\")!" 1
	exit 7
else
	show_message "Sync error" "...Undefined error with sync: \"$SYNCSTATUS\"" 1
	exit 127
fi

This metadata is most frequently used in the dialogs that are shown whenever an executable is being opened for the first time after being downloaded from the web, and it is accessible to users via the “get info” dialog box. If you have a file laying around somewhere, and you’re trying to remember where you got it from, you can always look at the file info, find the “where from:” field, copy the address, switch to your browser, paste the address to the location bar, and press enter in order to get to the origin site. I knew you could read file metadata in OS X with the mdls utility, so I figured it’d be quite simple to make a little “droplet” application for streamlining the task of navigating to the origin web site of a particular file, so that’s exactly what I did.

To use the application, simply drag and drop any file on top of it. If the file has a metadata field about the location where it was downloaded from, that address will be opened in your default web browser. If there are several locations listed in the metadata, a dialog box will pop up to ask you to choose which one to navigate to. It will also confirm whether to go to the address or not if it looks like it’s a direct link to download the file itself.

The links to download the application and/or its source code are below. It is basically a Python script made into an application with Platypus, and it’s using CocoaDialog for the popup dialogs.

• goToSource v1.0
• goToSource v1.0 source code