As the next part in the keybindings series I’m demonstrating some improvements I’ve made to the original “surround” commands since my first time around. This set of commands is designed to wrap selected text in a variety of paired characters. The keys are the same, but the commands now work inside of single-line text fields (like you often find in Safari), prevent auto-pairing in apps like nvALT, MultiMarkdown Composer and Byword, and a few refinements to cursor positioning.

Here’s the code to drop into ‘DefaultKeyBinding.dict’, located at ~/Library/DefaultKeyBinding.dict (create the folder and/or the file if you don’t have one¹):

  "^@s" = {   // surround commands
    // wrap () with spaces
    "(" = (delete:, insertText:, "( ", yank:, insertText:, " ", moveLeft:, insertText:, " )", deleteForward:);
    // wrap () no spaces
    ")" = (delete:, insertText:, "( ", deleteBackward:, yank:, insertText:, " ", moveLeft:, insertText:, ")", deleteForward:);
    // wrap [] with spaces
    "[" = (delete:, insertText:, "[ ", yank:, insertText:, " ", moveLeft:, insertText:, " ]", deleteForward:);
    // wrap [] no spaces
    "]" = (delete:, insertText:, "[ ", deleteBackward:, yank:, insertText:, " ", moveLeft:, insertText:, "]", deleteForward:);
    // wrap {} with spaces
    "{" = (delete:, insertText:, "{ ", yank:, insertText:, " ", moveLeft:, insertText:, " }", deleteForward:);
    // wrap {} no spaces
    "}" = (delete:, insertText:, "{ ", deleteBackward:, yank:, insertText:, " ", moveLeft:, insertText:, "}", deleteForward:);
    // wrap <> with spaces
    "<" = (delete:, insertText:, "< ", yank:, insertText:, " ", moveLeft:, insertText:, " >", deleteForward:);
    // wrap <> no spaces
    ">" = (delete:, insertText:, "< ", deleteBackward:, yank:, insertText:, " ", moveLeft:, insertText:, ">", deleteForward:);
    // wrap single quotes
    "'" = (delete:, insertText:, "' ", deleteBackward:, yank:, insertText:, " ", moveLeft:, insertText:, "'", deleteForward:);
    // wrap backticks
    "`" = (delete:, insertText:, "` ", deleteBackward:, yank:, insertText:, " ", moveLeft:, insertText:, "`", deleteForward:);
    // wrap double quote
    "\"" = (delete:, insertText:, "\" ", deleteBackward:, yank:, insertText:, " ", moveLeft:, insertText:, "\"", deleteForward:);
  };

Key: ^=control, @=command

The whole set is bound to Control-Command-S, so you use them by: * selecting some text that needs quotes, parenthesis, brackets, etc. wrapped around it * press Control-Command-S * typing the key you want to wrap the text in

It’s set up to handle parenthesis, square brackets, angle brackets, curly brackets, single/double quotes and backticks. In the parenthesis and brackets, typing the left character of the pair adds the wrapping with spaces on the inside of the pair (e.g. ( text I wrapped )) and the right character wraps with no spaces (e.g. (text I wrapped)).

If you just want one or two and don’t need them bundled in the Control-Command-S wrapper, you can always extract them from that section of the plist and move them into the root. Because we’re just wrapping and not autopairing, the commands make more sense (to me) with a hotkey to enable them.

If you don’t have a selection when you run these, it’s going to insert the last thing it “yanked” and you never know what you’ll get. The yank pasteboard is separate from the main pasteboard, so it has little to do with what you intentionally copied last. If you’re using these keybindings, it will likely contain the last selection you ran one of them on.

Just for edification, let’s dissect one, shall we? Here’s the binding for wrapping in double quotes, made a little prettier for readability:

// wrap double quote
"\"" = (    delete:, 
            insertText:, "\" ", 
            deleteBackward:, 
            yank:, 
            insertText:, " ", 
            moveLeft:, 
            insertText:, "\"", 
            deleteForward:, 
    );

• In the first three line delete the selection. The text is now in our yank pasteboard.
• Then we insert the text “\” “
  • The backslash escapes the double quote so it doesn’t break the surrounding quotes in the plist
  • The trailing space fools most auto-pairing setups into not inserting the right-side pairing automatically. We immediately delete backward to remove the extra space
• Next, we use the “yank:” method to put back the text we originally cut out and insert a space immediately after it. The space allows us to manipulate the end of the text without hitting the end of the line, as would happen in certain editors and always in single-line text fields.
• We move left past the new space and insert the closing quote
• Finally, we delete to the right remove the trailing space

We want the cursor to end up after the last character of the wrapped text, so we can just stop there.

Hopefully that gives you enough ammo to start coming up with more, and enough of a taste to help you realize that this is seriously the most powerful text tool in your arsenal. It’s application agnostic, completely customizable and totally free. Have fun.

For my full DefaultKeyBinding.dict file, check out the GitHub repo and feel free to steal/fork mine. I’ll continue posting and describing pieces of it, but if you’re impatient and know how to read it already, go for it.

Related posts:

1. New text navigation KeyBindings
2. KeyBinding madness
3. The keys that bind: KeyBinding Madness part 2

Originally posted on BrettTerpstra.com at KeyBindings: new, improved “surround” commands

You can monitor all file access with @copy(sudo opensnoop)

The answer would be presented as “You can monitor all file access with sudo opensnoop,” and sudo opensnoop would be copied to your clipboard. If you don’t have an @copy() in the answer, nothing special happens.

If your answers are in Markdown files and you’re having any trouble querying them, this will help.

Source and downloads also on GitHub.

Related posts:

1. Geeklet: Top CPU processes
2. Forget about it. Or not.
3. Quick tip: running nvALT after a Notational Velocity update

Originally posted on BrettTerpstra.com at QuickQuestion 1.1 update

I forget a lot of things. I forget how I did something, or where I found an answer, or where I put my glasses. I use technology to help with that to some extent, and Notational Velocity/nvALT are excellent at helping me find previous notes, assuming I bothered to take them.

I keep a log in VoodooPad, especially when I’m up late enough at my computer that I might not remember what I was working on in the morning. That’s handy, the search is excellent, and gathering tagged entries together on one page automatically is sweet. After a couple of years of doing it religiously, though, I’ve found that I rarely reference anything beyond the previous day or two. I rarely go back because the things I log aren’t “knowledge”, just activities. My logging system lacks the details I need to remember exactly how I did what I did. That’s my own fault, of course, but I needed a system that would build an environment-agnostic knowledgebase for remembering all the things I tend to forget.

Thus, I’ve been playing with an idea. I’m building a collection of plain-text notes (primarily using nvALT with notes saved to a Dropbox folder) where the title of the note is the question I think I would ask myself long after I’ve forgotten the answer. The content of the note is the answer in its briefest form, including commands, filenames, urls and whatever is necessary to get me back on the right track.

I can query these notes quickly from the command line (qq where glasses or qq best h.264 settings), as well as from LaunchBar and Alfred. Adding new notes can be done just as easily from the same sources. The text files are stored among all of my nvALT notes (with a special prefix to easily separate them), so it automatically benefits from Notational Velocity-style searching and editing.

One of the reasons I prefer to store my nvALT notes as plain text files is that I have access to them from Spotlight and mdfind (man page). Spotlight allows me to query a little more intricately, separating tags from titles and titles from content in a way that nvALT currently can’t. mdfind is the crux of this system. You can store all you want in plain text and feel great about it, but the ease of querying any information system is the measure of its worth.

I like tagging. I’ve found that tagging isn’t the solution for my forgetfulness, though. It’s been extremely helpful in tracking projects across multiple folders, but not so much in dealing with aged notes. I’m as likely to forget a tag I associated as I am anything else. Extra, more verbose text seems to be the trick. Instead of piling on a bunch of tags, I set my scripts up to search–but not output–anything inside of a @(extra text tag). Then I can add extra verbosity and keywords that I think might help the search later… without fouling up my tag database.

While there’s definite GTD-style comfort in knowing I have my discoveries and important notes in a portable, syncable system, the process of thinking through the syntax of the question/filename is actually helping me remember things better to begin with. It’s a conscious effort to connect neurons in a way that keeps the information more readily accessible to my feeble memory. I’ve only been doing it for a month, though, so I’m curious to see how the knowledgebase looks and functions in a year.

I’ve put the whole system and installation/usage/best practices up on GitHub. There’s a command line tool (bash), a pair of LaunchBar Actions and two standalone Alfred extensions for adding and querying the notes. As I use it more, I’ll probably come up with more ways to interface with it. Right now I’m thinking about an AppleScript/Mail Rule-based system for adding and querying notes via a GMail alias. More to come, pending determination that the new method is worth the fiddling time in the end. I do love having universal access to any bucket I use, though…

If you’ve ever forgotten where you put something important or solved a problem and later forgotten the solution, check out the QuickQuestion GitHub page. The Readme and up-to-date files are also available as a direct download below.

Related posts:

1. Quick tip: running nvALT after a Notational Velocity update
2. Taking the Markdown to Evernote service further
3. nvALT 2.2 public beta

Originally posted on BrettTerpstra.com at Forget about it. Or not.

So, I’m digging through the code Lri’s posted and I find a DefaultKeyBinding.dict file. It’s the best one I’ve ever seen, and it inspires me to do some “fiddling” of my own. I figured I’d post my result, but with due credit to Lri (hi, Lri!).

The DefaultKeyBinding.dict file tells your computer at a fairly root level how to handle keyboard shortcuts in input fields. It doesn’t work everywhere, but sometimes it’s surprising where it does work. In those cases, you can save yourself a ton of time by committing a few custom keystrokes to memory.

You may be familiar with the basic Emacs keybindings that are default (Ctrl-a beginning of line, Ctrl-e end of line, etc.), but this allows you to go much further. For more information, check out Macworld hints, an older but very relevant article from Harvard and do a search for more information.

Basically, all you need to do is put the DefaultKeyBinding.dict file into ~/Library/KeyBindings and restart applications you want it to work in. Edit away, and change shortcuts to things you’re comfortable with. Several of mine are sequences which allow groupings, which I like, but you might not. Be aware that these can be a little unpredictable as to when they’ll override a system/application default and when they’ll be overridden (I know there’s a logic to it, I just don’t want to dive into that).

I’ve posted my KeyBindings on GitHub and included a cheatsheet in MultiMarkdown as well as a Readme with the tables already rendered. Direct download link below. If you’re looking for something to nerd out on this weekend, this should whet your appetite.

Just for reference, here’s the table of shortcuts in the KeyBindings file:

Grouped items begin with the groups shortcut, followed by the Keys specified. Items separated by commas are sequential, not concurrent.

Related posts:

1. KeyBindings: new, improved “surround” commands
2. The keys that bind: KeyBinding Madness part 2
3. Option-arrow navigation in iTerm2

Originally posted on BrettTerpstra.com at KeyBinding madness

You can select an entire stylesheet and it will send back the text with the necessary changes, or just run it on a single rule to have it vendor-prefixed for you. It turns this:

p {
  transition: all .2s ease-in-out;
  box-shadow: 1px 1px 4px rgba(0,0,0,.3) ;
  color: #333;
}

into:

p {
	-webkit-transition: all .2s ease-in-out;
	-moz-transition: all .2s ease-in-out;
	-o-transition: all .2s ease-in-out;
	-ms-transition: all .2s ease-in-out;
	transition: all .2s ease-in-out;
 
	-webkit-box-shadow: 1px 1px 4px rgba(0,0,0,.3);
	-moz-box-shadow: 1px 1px 4px rgba(0,0,0,.3);
	box-shadow: 1px 1px 4px rgba(0,0,0,.3);
 
	color: #333;
}

Pretty handy. Sass can do this for you, and there are already plugins for TextMate, Vim, Espresso, Coda and more on Prefixr’s API page. Just thought I’d add one more to the pile.

Unzip it and drop it into ~/Library/Services. Select some text containing CSS3 properties and right click on the selection, then look under “Services” for the Prefixer service. Run it and (assuming you have an internet connection), it’ll do some of the tedious parts of CSS3 for you.

Related posts:

1. App Review: Gradient
2. A little HootSuite userstyling
3. Fixing Gleebox

Originally posted on BrettTerpstra.com at Prefixr OS X Service

Quite a while back, developer Jan Van Boghout posted a tip for unlinking the default Webkit framework and using the one inside of the latest nightly build you have installed. It was a simple Terminal command that you had to launch from the command line, and the effect only lasted for that session. The command eventually stopped working, until Ian Beck noted that the location of the frameworks in Webkit.app had changed. It worked with that tweak, but it was still a pain sometimes, even with aliases.

The solution

I don’t know why it took me this long to think of it, but there’s an easy way to make the command into a wrapper within the CSSEdit application bundle. This isn’t for the faint of heart, and it will have to be done again if CSSEdit ever updates in the future, but it’s a good hack for the time being.

I’m going to write these instructions to exclusively use Terminal, although many steps can be accomplished through Finder (use Show Package Contents from the right click menu).

• Go to the executable folder within the CSSEdit.app bundle:

  $ cd /Applications/CSSEdit.app/Contents/MacOS/

• Rename the main executable:

  $ mv CSSEdit _CSSEdit

• Create a new CSSEdit file (using whatever editor you like):

  $ vim CSSEdit

• Put the following code into it:

#!/bin/bash
env DYLD_FRAMEWORK_PATH=/Applications/WebKit.app/Contents/Frameworks/10.6/ WEBKIT_UNSET_DYLD_FRAMEWORK_PATH=YES /Applications/CSSEdit.app/Contents/MacOS/_CSSEdit

• Save the file, close it, and make it executable:

  chmod a+x CSSEdit

Now, when you launch the app, it will run the shell command to unlink and relink the Webkit framework. Note that if you do this on Leopard, you’ll need to change the DYLD_FRAMEWORK_PATH to point to 10.5 instead of 10.6. Enjoy!

Related posts:

1. Quick Tip: Extracting Mac App Store reviews as text
2. Prefixr OS X Service
3. Duplicating Safari browsing sessions between Macs

Originally posted on BrettTerpstra.com at Make CSSEdit use the latest Webkit nightly every time

I actually already own an app which can do this to some extent, and I know there are more available. I like to do things the hard way once in a while. What I wanted was a basic script which could execute arbitrary code whenever a file of a certain type changed within a directory. The use case is web development: whenever I change a site-related file (html, php, css, less, rb, erb, etc.), I want Safari to refresh the related page.

Folder Actions don’t work well on my system (do they work for anyone?). Hazel would work, but I needed something more immediate. I had a version that used launchd, but it was difficult to consistently start and stop from a script. Here’s the final solution I came up with.

At the top, let me say that the heavy lifting in my script was taken from a SASS file-watching script by Carlo Zottman. It uses Ruby to poll a file collection for modification date variations, and keeps a pretty low profile. I wanted to avoid compiled code for this, as I eventually do want to go to bed tonight.

The basic goals:

• Watch only files of a specific type
• Refresh my primary browser when a change occurs
• Refresh across windows and tabs, but limit by user-specified keyword in URL

I built both a command line script and a System Service to do this, and both work as standalone solutions. The Automator action makes it possible to right click a folder in Finder and choose “Watcher” to start watching it, and it asks you for the tab keyword in a nice popup dialog. Beyond that, it really just wraps the command line script. You can modify either with the following instructions.

Here’s the command line version:

#!/usr/bin/env ruby
# watch.rb by Brett Terpstra, 2011 <http://brettterpstra.com>
# with credit to Carlo Zottmann <https://github.com/carlo/haml-sass-file-watcher>
 
trap("SIGINT") { exit }
 
if ARGV.length < 2
  puts "Usage: #{$0} watch_folder keyword"
  puts "Example: #{$0} . mywebproject"
  exit
end
 
dev_extension = 'dev'
filetypes = ['css','html','htm','php','rb','erb','less','js']
watch_folder = ARGV[0]
keyword = ARGV[1]
puts "Watching #{watch_folder} and subfolders for changes in project files..."
 
while true do
  files = []
  filetypes.each {|type|
    files += Dir.glob( File.join( watch_folder, "**", "*.#{type}" ) )
  }
  new_hash = files.collect {|f| [ f, File.stat(f).mtime.to_i ] }
  hash ||= new_hash
  diff_hash = new_hash - hash
 
  unless diff_hash.empty?
    hash = new_hash
 
    diff_hash.each do |df|
      puts "Detected change in #{df[0]}, refreshing"
      %x{osascript<<ENDGAME
        	tell application "Safari"
          	set windowList to every window
          	repeat with aWindow in windowList
          		set tabList to every tab of aWindow
          		repeat with atab in tabList
          			if (URL of atab contains "#{keyword}") then
          			  tell atab to do javascript "window.location.reload()"
          			end if
          		end repeat
          	end repeat
        	end tell
ENDGAME
}
    end
  end
 
  sleep 1
end

Installing

If you want to use the above script from Terminal, just put it in a directory in your path and run chmod a+x watch.rb on it. Then you can call it with watch.rb folder/to/watch keyword. The keyword you pass will determine which tabs will refresh in your browser. For example, if I’m working on dev.heckyesmarkdown.com (my local development version), I would use “dev.heckyes” to limit the refresh to only associated tabs. Once the script is running, you can stop it any time by typing Control-C in that Terminal. If you’ve run it in the background, you’ll either need to foreground it or kill it manually.

To install the System Service, download the workflow, unzip it and place it in ~/Library/Services (where ‘~’ is your home folder). It will now show up when you right click on one or more selected folders in the Finder. Choose “Watcher,” enter a URL-matching keyword and let it go. You should see the spinning gear icon in your menubar. When you want to stop watching the folder, click that icon and choose “Stop Watcher”.

Customizing

In the standalone Ruby script (above), you can easily modify the watched filetypes in line 14, and you can replace the AppleScript with your own starting on line 34. I’ll offer some examples for other browsers below.

The Service contains pretty much the same script, but modified to work with an Automator workflow. If you open it in Automator and skip to the last action, you’ll see the script and you can make your filetype and AppleScript modifications in there.

Using other browsers

Chrome has decent AppleScript support these days, so changing this script to work with it is trivial. Just replace the AppleScript portion (beginning with “tell application…”) with the following:

tell application "Google Chrome"
	set windowList to every window
	repeat with aWindow in windowList
		set tabList to every tab of aWindow
		repeat with atab in tabList
			if (URL of atab contains "#{keyword}") then
				tell atab to reload
			end if
		end repeat
	end repeat
end tell

Firefox is a little less elegant, as far as I know, and requires System Events scripting to refresh a page. If you know a better way, I’d love to hear it, but here’s a basic script for reloading the front page. You might as well delete the keyword portions of the script/workflow if you go this route, they won’t be applicable:

 tell app "Firefox" to activate
 tell app "System Events"
   keystroke "r" using command down
 end tell

I won’t detail any other browsers; if you’re doing web development in something more exotic, I’ll assume you know how to script it.

Executing arbitrary code

You don’t have to refresh browsers with this. You don’t even have to use it for web development. Have it watch text files for changes and run an iCal script when one is modified. It’s basically a hyperactive Folder Action.

If you want to have the script do something new every time you use it, you might want to externalize the action code. Just modify the diff_hash.each do |df| block to run an outside script. If it’s shell code, just make it executable and call it with %x{path/to/script}, and if it’s AppleScript, call it with %x{/usr/bin/osascript path/to/script}. Then you can modify the action script each time without changing the watch.rb file.

If you want to get really crazy, you could pass the script to execute as a command line parameter, or request it in the Automator workflow and pass it in. I don’t have a need for that right now, but if you build it, let me know!

I hope folks find this useful. Now, excuse me while I go retch for a little bit.

Download

Related posts:

1. OS X Service for natural language dates
2. A few scripts for TaskPaper users
3. A Bash function for Markdown bloggers

Originally posted on BrettTerpstra.com at Watch for file changes and refresh your browser automatically

You can download ready-to-go versions of the workflows covered in this post here: GrabIconWorkflows.zip.

If you want to customize these workflows, you’ll need to know a little bit about the inner Bash workings, but nothing an up-and-coming nerd can’t figure out. To get started, open up Automator.app and create a new file with the “Application” preset.

A basic workflow

We’ll start with a really simple Automator application that you can drop an application onto to extract its icon at 512px and save it as a JPEG to the Desktop. One step, no interaction.

In your new Automator workflow, find “Run Shell Script” in the Library on the left. You can use the filter at the top to quickly narrow down the choices. Drag the action into your workflow editor on the right, and paste the following code into it:

APPDIR=$1
ICON=`defaults read "$APPDIR/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'`
ICONFILE="$APPDIR/Contents/Resources/$ICON.icns"
APPNAME=`basename "$APPDIR" .app`
OUTFILE="$HOME/Desktop/${APPNAME}_icon.jpg"
/usr/bin/sips -s format jpeg --resampleHeightWidthMax 512 "$ICONFILE" --out "$OUTFILE"

Make sure the shell is set to “/bin/bash” and change “Pass input” to “as arguments”. Save the workflow. You’ll probably want to name it something creative and put it somewhere useful, such as ~/Applications/512Desktop.app. I have the utmost faith that you’ll come up with something brilliant. Here’s what your workflow should look like:

Now, you can just drop an application onto the icon for 512Desktop.app and the extracted icon will show up on your Desktop, named based on the name of the application you dropped on the workflow, with “_icon.jpg” appended to it. That was easy, right?

A complete workflow with user interaction

To make something more universally useful, we’ll create a workflow that asks the user where to save it. This time, we’ll output a PNG file and use the maximum available icon size. We covered how to do both of these in the last post, so I won’t go into all of the details in this one. Page back if you’re curious (or confused).

We’ll also need to store variables and pass multiple arguments to shell scripts in the workflow to pull this off. This is the stuff that makes Automator both awesome and frustrating, but once you get the hang of it, new possibilities open up. In this example it may seem like a lot of work just to ask a user where to save a file, but the concept allows you to get user input (without using AppleScript) in shell scripts. It’s worth knowing.

Create a new Automator application, just like above. Since this is going to be a droplet, the path of the Application will be passed to the first action when you run it (by dragging an app onto it). We need to store that as a variable for later, and then pass it on to the first shell script. To do so, drag the “Set Value of Variable” action from the library into your workflow. Click the dropdown for “Variable:” and choose “New variable”. Title the variable “appname”.

Next, drag the “Run Shell Script” action in after the variable action. Paste the following code into it:

ICON=`defaults read "$1/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'`
echo "$1/Contents/Resources/$ICON.icns"

This gets the icon file’s name and hands it back to Automator. We’ve got the application name and location, as well as the name and path of the icon file we need. We just need to know where the user wants to save it to. Add the “Ask for Finder Items” action in next, and set the prompt to “Save to:”. “Start at:” should be set to Desktop by default, but you can modify that to open the dialog to whatever directory makes sense for you. Change “Type:” to “Folders” and make sure that “Allow Multiple Section” is unchecked.

Now we need our appname variable back, so drag “Get Value of Variable” in as the next action. Set “Variable:” to “appname” (which will be available in the dropdown). The outputs of each command stack up, so now we have the icon file path, the user’s destination selection and the Application’s name (appname) all ready to pass to the final shell script as arguments ($1 $2 $3).

Drag in a “Run Shell Script” action as the last command. Again, set it to “/bin/bash” and pass input as arguments. Then, paste this code into it:

APPNAME=`basename "$3" .app`
OUTFILE="$2/${APPNAME}_icon.png"
MAX=`sips -g pixelWidth "$1"|tail -1|awk '{print $2}'`
/usr/bin/sips -s format png --resampleHeightWidthMax $MAX "$1" --out "$OUTFILE"

Here’s what it should look like now:

Done. Save the workflow to a file such as ~/Applications/SaveMaxIcon.app. Try dragging an application directly onto it. You’ll be asked to choose a folder. Click “OK” and the resulting icon image file will show up in the selected location. You can stick this app on your Desktop (or alias it there) for easy access, add it to your Finder sidebar or even drag it into the toolbar of a Finder window.

If you want to choose an app from a dialog instead, you can insert an “Ask for Finder Items” action at the beginning of the workflow. Set “Start at:” to “/Applications”, “Type:” to “Files” and uncheck “Allow Multiple Selections”. Running the workflow will pop up a file dialog asking you to select an application manually before requesting the destination and running the rest of the script. This might be faster than finding, dragging and dropping, in some cases.

Bonus tip: you can incorporate Automator workflows into shell scripts (and AppleScripts using do shell script) with the automator command line utility. You can call it directly on a workflow (automator nameof.workflow) or pass input to it using the –i parameter. The most practical application I can think of in this case would be to create an AppleScript application bundle containing both on run and on open handlers and both versions of the above workflow embedded in it. Then you could create a single application that would act on dropped files or offer a dialog if it was run directly. There’s probably an easier way to do that, though.

Grab copies of the workflows to get started (GrabIconWorkflows.zip), and I’d love to hear if you come up with other uses for them. That’s a wrap, hope it gave you some ideas for your own nerdery.

Related posts:

1. Grabbing a Mac app’s icon: building blocks
2. Grabbing a Mac app’s icon: advanced Bash usage
3. Dropbox and seamless mutli-Mac computing?

Originally posted on BrettTerpstra.com at Grabbing a Mac app’s icon: Automator style

• Logic to locate the app if it exists outside of /Applications
• A check using sips to find the maximum available image size
• Allow user input to set the final output size
• Allow the user to decide whether to open the result in Preview.app

We’ll also look at a very, very cool trick for adding tab-completion for application names to the open -a command, as well as our geticon() function. Yes, it’s that nerdy.

In the next post, we’ll use Automator to make this into a droplet we can drag apps onto from Finder. If you don’t give a flying fire truck about Terminal, you can skip straight there and create something useful without touching the command line. This one’s for the nerds (and wannabe nerds).### A for loop directory search ###

We’ll use a bash for loop to search some predefined locations. You could also use mdfind¹ to let Spotlight locate the app, but we’ll keep it simple for now. I’ve set it up to look in some standard locations for the file:

APPDIR=''
 for dir in "/Applications/" "/Applications/Utilities/" "/Developer/Applications/" "/Developer/Applications/Utilties/"; do
   if [[ -d ${dir}$APP.app ]]; then 
       APPDIR=$dir
       break
   fi
 done

$APPDIR is now set to the location that $APP was found, or to ” (blank) if it wasn’t found in any of the specified folders. We can check for that in the next part and fail gracefully if we didn’t find the specified app.

Getting the maximum image size

Modern Mac icons generally have a pixel width of 512 or greater, but some legacy applications’ icons are 256px or smaller. Finding the maximum pixel width of the image allows us to avoid creating a distorted image as a result of sizing up beyond the largest image in the .icns file. The sips command can do this with a little help from awk² to clean up the output. The following command gets the pixelWidth property from the icon file, grabs the last line of output and removes extraneous text to leave us with just a number:

MAXAVAIL=`sips -g pixelWidth "${APPDIR}$APP.app/Contents/Resources/$ICON.icns"|tail -1|awk '{print $2}'`

We could use the number we found to output a file with the maximum dimensions, but since we’re making a general-purpose function, we’ll ask the user what they want.

Getting user input

There are a few ways to offer options in Bash. This is the simplest route I know. It doesn’t innately allow for a lot of error checking; the user could enter letters instead of numbers or an unattainable dimension, for example. We’ll add some basic checks, but we’ll assume that you can properly enter a number when asked. You’re smart like that.

echo -n "Enter max pixel width ($MAXAVAIL): "
read MAX
if [[ $MAX == '' || $MAX -gt $MAXAVAIL ]]; then
  MAX=$MAXAVAIL
fi

We echo the prompt (the –n keeps it from echoing a newline), and we use our previously determined $MAXAVAIL variable to set a cap. If the user’s answer is empty or larger than $MAXAVAIL, we default to $MAXAVAIL.

The whole shebang

Here’s a complete Bash function that you can paste at the end of your ~/.bash_profile. It offers to open the resulting image in Preview.app, but you can easily modify that to whatever app makes sense in your workflow.

function geticon() {
  APP=`echo $1|sed -e 's/\.app$//'`
  APPDIR=''
  for dir in "/Applications/" "/Applications/Utilities/" "/Developer/Applications/" "/Developer/Applications/Utilties/"; do
    if [[ -d ${dir}$APP.app ]]; then 
        APPDIR=$dir
        break
    fi
  done
  if [[ $APPDIR == '' ]]; then
    echo "App not found"
  else
    ICON=`defaults read "${APPDIR}$APP.app/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'`
    OUTFILE="$HOME/Desktop/${APP}_icon.jpg"
    MAXAVAIL=`sips -g pixelWidth "${APPDIR}$APP.app/Contents/Resources/$ICON.icns"|tail -1|awk '{print $2}'`
    echo -n "Enter max pixel width ($MAXAVAIL): "
  	read MAX
  	if [[ $MAX == '' || $MAX -gt $MAXAVAIL ]]; then
  	  MAX=$MAXAVAIL
  	fi
    /usr/bin/sips -s format jpeg --resampleHeightWidthMax $MAX "${APPDIR}$APP.app/Contents/Resources/$ICON.icns" --out "$OUTFILE" > /dev/null 2>&1
    echo "Wrote JPEG to $OUTFILE."
  	echo -n 'Open in Preview? (y/N): '
  	read ANSWER
  	if [[ $ANSWER == 'y' ]]; then
  	  open -a "Preview.app" "$OUTFILE"
  	fi
  fi
}

Extra credit: tab completion for app names

Before we get into making this into a GUI using Automator, wouldn’t it be cool if you could autocomplete an app name from the command line when you use this? This is where you find out that I can nerd anything to death, but let’s do it.

First, we need some functions to build a list of all of our available applications and provide them to Bash’s completion command. I’m modifying a script from Kim Holburn for this, updated to work on 10.6 and provide case-insensitive completion. Just put the file in your user’s home directory for now. When we’re done, it will also provide application name tab completion for open -a (and o if you alias o=“open –a” in your .bash_profile). Click the link below to open the script, then save it to your home folder as “.app_completions”.

Download .app_completions

Once you have that file located in ~/.app_completions, we just need to reference it in .bash_profile and add a few settings. Put this near the top of ~/.bash_profile:

source ~/.app_completions
bind "set completion-ignore-case on"
set show-all-if-ambiguous on
alias o="open -a"

At the command line, run source ~/.bash_profile. Now, assuming you’ve also added the previous geticon function to .bash_profile, you should be able to type geticon term and hit tab right after the ‘m’ to have it complete to “Terminal.app” automatically. This makes it a lot easier to get the app’s name, spacing and capitalization exactly right. You’ve also aliased “o” to launch an app in the process. Type o auto to complete to “Automator.app” and launch it.

We’ll dig into Automator next and turn this whole thing into something pretty.

Related posts:

1. Grabbing a Mac app’s icon: Automator style
2. Grabbing a Mac app’s icon: building blocks
3. Mac App Giveaway: TextExpander

Originally posted on BrettTerpstra.com at Grabbing a Mac app’s icon: advanced Bash usage

My solution ended up having some tricks in it that I thought were worth sharing, so I’m going to write it up here. This is the first post in a three-part series; an epic tribute to obsessive nerdery. It will probably eventually be summarized into the how-to section, but this is the ever-so-informative longhand version.

Introduction/excusatory verbage

I use application icons quite a bit in my writing for TUAW, so having a quick way to do this is worthwhile. You may never need an application icon as a ready-to-post JPEG, but it’s worthwhile to know tricks such as how to grab, resize and convert images from the command line or how to build an Automator action which combines Finder dialogs, shell scripts and Automator variables.

I’ll start with the basic Terminal commands to lay a foundation.

Finding an app’s icon with the defaults command

On a Mac, every application is actually a folder, referred to as a “bundle”. Within that folder are libraries, executables and resources (like images and icons). There’s also an important file called Info.plist which stores information like the application’s name, identifiers, file types and–most relevant right now–the name of the file containing the application’s icon. The application icon is an an .icns file, stored in AppName.app/Contents/Resources. Its title does not have to be the same as the app’s, so–before we can extract and convert it–we need to get its actual filename from Info.plist.

Info.plist is stored as an XML file (as opposed to a binary plist). As such, we could grep for the filename and run a bunch of Unix commands to parse out the filename, but there’s an easier and more reliable way to do it using the defaults² command built into OS X. defaults reads plist files and can output the value of specific keys. The key we want is CFBundleIconFile, which holds the icon’s filename. We’ll assume that we’ve already retrieved the name of the app and stored it in a variable called $APP. Here’s what you would run on the command line:

defaults read "/Applications/$APP.app/Contents/Info" CFBundleIconFile

The response may or may not have a file extension (.icns). We want to trim the extension if it exists so that we have a clean foundation to build on. You can do this with several different Unix utilities, including basic bash substitution; we’ll stick with sed³ for now. We pipe (|) the output of the defaults command into sed, and remove “.icns” if it exists:

defaults read "/Applications/$APP.app/Contents/Info" CFBundleIconFile|sed -e 's/\.icns$//'

Converting the icon file to an image format

The .icns format holds multiple versions of the icon, and doesn’t do us much good if we want an image file for the web. Fortunately, the built-in command sips can do some neat tricks with it, including converting it to various formats⁴. We know what the icon file is titled now, and we know where to look for it. We just build a sips command to read it, convert it and output the result.

The -s format parameter sets an output format in sips. This can be one of many formats, but we’ll use the JPEG format for this example. This will compress the result to a web jpeg with a solid, white background. Using the PNG format instead would preserve the transparency, so if you need to do other image manipulation, you can substitute “png” for “jpeg”.

Let’s use the $APP variable we’ve created to set a default output filename on the Desktop. For now, we’re assuming the app exists in the standard /Applications folder (I’ll show a more complex workflow for locating the app in a bit). We’re also assuming that we’ve stored the result of the above defaults command in $ICON.

OUTFILE="$HOME/Desktop/${APP}_icon.jpg"
sips -s format jpeg "/Applications/$APP.app/Contents/Resources/$ICON.icns" --out $OUTFILE

Now we have the basic pieces we can use to build a script to automate this from the command line. Here’s an example which expects the application name as the only argument, properly cased:

#!/bin/bash
 
APP=`echo $1|sed -e 's/\.app$//'`
# Removes ".app" if it was passed
 
ICON=`defaults read /Applications/$APP.app/Contents/Info CFBundleIconFile|sed -e 's/\.icns$//'`
# Removes ".icns" if the Info.plist value includes it
# Harcoded for /Applications, needs to be rewritten for other locations or droplets
 
## Save icon on Desktop in JPEG format, resized to 256 max width/height
OUTFILE="$HOME/Desktop/${APP}_icon.jpg"
/usr/bin/sips -s format jpeg "/Applications/$APP.app/Contents/Resources/$ICON.icns" --out $OUTFILE

Extra credit: image optimization

Since we’re automating, we can add a final step to the script to handle whatever steps we would normally take next. For example, we could open it in Skitch for quick resizing, or in Acorn for more complex manipulation. If we saved a JPEG to a size we already know is correct for our purposes, we could open it straight in an optimizer such as ImageOptim to quickly improve the compression. We could also make use of a command line utility like ImageMagick, jpegtran or pngcrush, all of which require some installation and extra work. If you have them, great, if not, that’s an article for another time.

For the record, Skitch saves horribly large JPEGs, whereas Acorn saves amazingly well-compressed images. If you resize with Skitch, you’ll want to compress it with something else as well.

Assuming we’re using an application and not a CLI utility, we can use the open command to send the resulting file to the app. We can also avoid some confusion by initially saving the converted icon file to a default temporary directory and then opening it from there. Here’s a revised script that does that, then opens the final image in Acorn for quick resizing and saving to any location. We’ll use the PNG format to preserve the original transparency, and you can substitute any graphics application for Acorn:

#!/bin/bash
 
APP=`echo $1|sed -e 's/\.app$//'`
# Removes ".app" if it was passed
 
ICON=`defaults read /Applications/$APP.app/Contents/Info CFBundleIconFile|sed -e 's/\.icns$//'`
# Removes ".icns" if the Info.plist has it
# Harcoded for /Applications, needs to be rewritten for other locations or droplets
 
## Output file to a temp directory (TMPDIR) as a PNG and open in Acorn for resizing and conversion
 
OUTFILE="$TMPDIR${APP}_icon.png"
sips -s format png "/Applications/$APP.app/Contents/Resources/$ICON.icns" --out $OUTFILE
open -a "Acorn.app" $OUTFILE

I think you get the idea. You can take this script and easily adjust the output format and destination application. In the next post, we’ll cover making this into a fully customized Bash function, with some extra goodies.

Related posts:

1. Grabbing a Mac app’s icon: Automator style
2. Grabbing a Mac app’s icon: advanced Bash usage
3. Bored with your MacVim icon? Me too.

Originally posted on BrettTerpstra.com at Grabbing a Mac app’s icon: building blocks

In recent versions they’ve added the ability to post directly to WordPress, which has been pretty cool. I always got a little frustrated with the amount of extra markup included in the templates, though. Today I asked them if they could add a Markdown export feature. Their response? It’s already there.

It doesn’t process Markdown to HTML, but that’s great for me as I do that server-side. It uploads the images in your lesson, inserts the resulting urls in your page, and uploads the plain old Markdown straight to your blog as either a post or a page. I re-created a couple of my older how-to’s using this new template, and they came out great. Check them out in the new How-To section.

Creating the template is quite simple, and everything you need to know is detailed in Blue Mango’s help system. I’m not going to go into a lot of detail, but here’s a copy of the template I’m using. Just unzip the file into ~/Library/Application Support/ScreenSteps/2.0/Templates/HTML/Blog and edit the index.html file inside.

Here’s where I went a little crazy. I have a custom post type in WordPress for the How-To’s, and I have plans to expand that section over time. I can’t post directly to WordPress as a How-To, and it was a little annoying to post it as a page and copy it over just to get the images uploaded. So… here’s a service called Upload Images to Blog. You can export as HTML in ScreenSteps using the above template and save it to a local folder. Run the service on the html file created, and it will upload all of the images to your blog and create a new filename-out.html file with the new image urls. You can render that to HTML or paste the Markdown directly to your post page, if your blog supports that.

The service requires a configuration file to be located at ~/.imguploader. The content of the file is just one line, like this:

username:password@http://yourblogname.com/xmlrpc.php

It also requires that you’re using an image output format like the one found in the template above. It just scans the file for ![](filename.jpg "alt text") lines for the uploadable images. I can’t guarantee the service will work for everybody. It’s a quick and dirty solution, but it works really well for me. It even has Growl notifications, if you have Growl installed.

That’s it. Back to work on more serious things.

Related posts:

1. Fun with MarsEdit, part I
2. Minor TabLinks update
3. AutoTag2: smarter tagging for TextMate and WordPress

Originally posted on BrettTerpstra.com at Markdown in ScreenSteps

For a rundown of new features and tips, see the project page I just posted: Notational Velocity ALT.

Related posts:

1. Notational Velocity ALT expatiation (and roadmap)
2. Notational Velocity ALT 5.3
3. Lunch-break bugfixes for Notational Velocity ALT

Originally posted on BrettTerpstra.com at Notational Velocity ALT 1.0 release

This version cleans up the preview panel a little, replacing the Aqua tabs with a nice HUD-style toggle button for Preview/Source. Other visual changes are quite minor, mostly related to spacing.

An interesting change is that NV ALT now reads its HTML and CSS for the preview from your user’s Library/Application Support/Notational Velocity folder, which it will create on launch if it doesn’t exist. There you’ll find template.html and custom.css. You can edit both to your heart’s content; if you mess up, just delete or rename them and they’ll be recreated.

I also fixed the Save HTML (which I’m pretty sure I broke) so that it saves full, valid XHTML documents. The Preview shows fragments, Save makes documents.

I’m experimenting with adding some JavaScript to the preview template to make sure that external links open in a browser, but internal (page anchor) links get some nice smooth scrolling action. Just for fun. The CSS has the basic definitions for you to play with, and you can see your changes by switching notes, which will regenerate the preview.

I managed to make all of the scrollbars look great, except for the Preview window. Web views are way too much trouble to re-skin, I found, so I scrapped all of those changes and went back to default toolbars. Elastic Threads has a fork of Notational Velocity that I really like which has great toolbars, but I’m betting he can’t get a web view to look good either! Too bad his source isn’t available… there’s a lot there to love.

Have fun with the customizations, if you try that out!

Related posts:

1. Notational Velocity and MultiMarkdown
2. Lunch-break bugfixes for Notational Velocity ALT
3. Notational Velocity alternative MultiMarkdown version

Originally posted on BrettTerpstra.com at Notational Velocity ALT 5.3

For the record, I’m fully aware of the Option-Click shortcut to make all current notifications disappear, but thanks to all of the Twitter responses to that effect nonetheless. I really wanted a pure keyboard solution to handle this (I’m not alone). Usually, at least with apps that adhere to the Growl suggestion regarding stickiness, you only get sticky notifications when something goes wrong, and then you usually get more than one. I just wanted to be able to “poof” them away quickly and tend to whatever was causing them. I’m weird, I know.

After a lot of toying around, I decided to just go with a brute force method: quit the helper application and start it back up. It does the trick, and if you use AppleScript to handle the process, you can keep the bridge alive and experience no interruption in your Growl service. If you call the AppleScript with FastScripts, a launcher like Spark or even QuickSilver or LaunchBar, you can cause all sticky notifications to disappear with a keystroke of your choice.

Here’s the script:

tell application "GrowlHelperApp" to quit
delay 1
tell application "GrowlHelperApp" to activate

I found the 1 second delay necessary to let the process close out before trying to launch it again. If you run into issues with Growl not responding after running this script, you might try increasing that delay by a second or two. I also played around with using kill (grep/awk for the PID, kill the process, etc.), but the whole system stays much more stable this way.

There, my contribution to the keyboard-obsessed minority of OS X users.

Related posts:

1. Quick Tip: Quickly clear stuck Growl notifications
2. Quick tip: AppleScript application toggle
3. Answer Skype with a hotkey

Originally posted on BrettTerpstra.com at Clear sticky Growl notifications with a keyboard shortcut

I’ll be the first to admit that I get a little obsessed with projects that aren’t really going to improve my life all that much. Those projects can be fun to blog about, though, so I present you my brief obsession for this Sunday afternoon.

You may have noticed on this blog that some posts have header images, and some don’t, and that they get styled differently based on whether there’s an image or not. It pulls the header images from one of two places: the post thumbnail (which I can’t edit from MarsEdit) or the first image in the post content with a class of “headerimg”. As long as I’m blogging in MarsEdit (or TextMate for that matter), I’m stuck with the latter option. Because the whole header image deal is handled through PHP in my functions.php file, I can’t really preview how it’s going to look; rather, I get a header image stuck somewhere before, in or after my content. In TextMate, I have a little more “scriptability” at my disposal, and the previews I’ve created there are quite accurate. As far as I can tell, I can’t pre-process content before the template is generated, so I had to try something else… My solution, for now, is jQuery in the preview template. I load the jQuery library up top (inside the header) using Google’s Ajax API:

<script src="http://www.google.com/jsapi"></script>
<script>google.load("jquery", "1.4");</script>

Then, at the bottom, I just start polling for an image with the right class to show up. I know it’s brute force, but this isn’t exactly public-facing, and it doesn’t seem to cause any hiccups in my writing. I have this right before my closing body tag:

<script>
function fixHeader() {
    if ($('img.headerimg').attr('src') != undefined) {
        headerImg = $('img.headerimg').removeClass('headerimg').remove();
        postThumb = $('.postthumb:first');
        headerImg.prependTo(postThumb);
        postThumb.addClass('hasimage').removeClass('noimage');
    }
}
setInterval(fixHeader,2000);
</script>

I’m sharing this just to toss the idea out there, not because I think there’s anyone else with the exact same template setup as mine.

In addition to having Javascript at my disposal, MarsEdit is also AppleScript-able. I haven’t looked very far into that yet, but I did whip up a quick script for adding the “headerimg” class to my images (because I always forget which class I assigned for this):

tell application "MarsEdit"
    set selectionContents to selected text of document 1
    set {astid, AppleScript's text item delimiters} to {AppleScript's text item delimiters, "/>"}
    if selectionContents is not "" then
        set textToInsert to (text item 1 of selectionContents) & "class=\"headerimg\" />"
    end if
    set AppleScript's text item delimiters to astid
    set selected text of document 1 to textToInsert
end tell

That lets me just select an image (or pending upload tag) and run the script to add the necessary class.

Related posts:

1. MultiMarkdown in MarsEdit
2. Instapaper Beyond for Safari
3. Marked scripts: nvALT, Evernote, MarsEdit, Scrivener

Originally posted on BrettTerpstra.com at Fun with MarsEdit, part I